计算机操作系统-存储器管理篇

计算机操作系统-存储器管理篇：

---

内容：

1. 页面置换算法作业
2. 页面置换算法实训代码-C语言实现

---

页面置换算法作业

1.有一个页式虚存系统，某进程占用3个内存块，开始时内存为空，执行如下访问页号序列：0，1，2，3，4，1，2，0，5，1，0，1，2，3，2，4，5 （共17个）

1. 若用最优（OPT）算法，缺页次数和缺页率是多少？
2. 采用先进先出（FIFO）置换算法，缺页次数和缺页率是多少？
3. 采用最近最久未使用（LRU）置换算法，缺页次数和缺页率是多少？
   请解题时列出详细过程

思路：

由题目可知，页面走向和有3个内存块，根据每种算法以表格的方式列出内存块的变化

1. OPT算法是置换以后不再被访问，或者在将来最迟才会被访问的页面，简单来说，物理块存放的页面序号在未来页面走向中出现最晚的就替换
2. FIFO算法是按照进入内存的先后次序排列成队列，从队尾进入，从队首删除
3. LRU算法的核心思想是置换最近一段时间以来最长时间未访问过的页面，用变量t表示访问时间，计算物理块的时间，哪个时间长就替换哪个物理块
   详细介绍请查看P181~P183或点击页面置换算法查看百度百科

答案：

1. OPT:如下表所示，缺页次数10次，缺页率为10/17

页面走向	0	1	2	3	4	1	2	0	5	1	0	1	2	3	2	4	5
内存块1	0	0	0	3	4	4	4	0	0	0	0	0	2	2	2	4	4
内存块2		1	1	1	1	1	1	1	1	1	1	1	1	3	3	3	3
内存块3			2	2	2	2	2	2	5	5	5	5	5	5	5	5	5
缺页次数	+	+	+	+	+			+	+				+	+		+

2. FIFO:如下表所示，缺页次数14次，缺页率为14/17

页面走向	0	1	2	3	4	1	2	0	5	1	0	1	2	3	2	4	5
内存块1	0	0	0	3	3	3	2	2	2	1	1	1	1	1	1	4	4
内存块2		1	1	1	4	4	4	0	0	0	0	0	2	2	2	2	5
内存块3			2	2	2	1	1	1	5	5	5	5	5	3	3	3	3
缺页次数	+	+	+	+	+	+	+	+	+	+			+	+		+	+

3. LRU:如下表所示，缺页次数14次，缺页率为14/17

页面走向	0	1	2	3	4	1	2	0	5	1	0	1	2	3	2	4	5
内存块1	0	0	0	3	3	3	2	2	2	1	1	1	1	1	1	4	4
内存块2		1	1	1	4	4	4	0	0	0	0	0	0	3	3	3	5
内存块3			2	2	2	1	1	1	5	5	5	5	2	2	2	2	2
缺页次数	+	+	+	+	+	+	+	+	+	+			+	+		+	+

2.在一个请求分页系统中，采用LRU页面置换算法时，假如一个作业的页面走向为1、3、2、1、1、3、5、1、3、2、1、5，当分配给该作业的物理块数M分别为3和4时，试计算在访问过程中所发生的缺页次数和缺页率，并比较所得结果

答案

当物理块数为3时，缺页次数6次，缺页率为6/12

页面走向	1	3	2	1	1	3	5	1	3	2	1	5
内存块1	1	1	1	1	1	1	1	1	1	1	1	1
内存块2		3	3	3	3	3	3	3	3	3	3	5
内存块3			2	2	2	2	5	5	5	2	2	2
缺页次数	+	+	+				+			+		+

当物理块数为4时，缺页次数4次，缺页率为4/12

页面走向	1	3	2	1	1	3	5	1	3	2	1	5
内存块1	1	1	1	1	1	1	1	1	1	1	1	1
内存块2		3	3	3	3	3	3	3	3	3	3	3
内存块3			2	2	2	2	2	2	2	2	2	2
内存块4							5	5	5	5	5	5
缺页次数	+	+	+				+

---

2.实训代码

代码如下：

#include <stdio.h>
#define MAXSIZE 100
#define BlookMaxSize 10
//17 3
//0 1 2 3 4 1 2 0 5 1 0 1 2 3 2 4 5
struct work {//用于LRU算法
	int black;//用于物理块存储数据
	int t;//用于计算时间
};
void fifo(int a[MAXSIZE],int n,int bn) {
	printf("\n-------------FIFO置换算法-------------\n");
	int block[BlookMaxSize];
	int miss=0,bk=0,f=0,i=0,k;
	for (i=0; i<bn; i++) block[i]=-1; //内存块初始化
	for (i=0; i<n; i++) {//页面走向遍历
		for (int j=0; j<bn; j++) {//内存块遍历
			//printf("---block=%d----i=%d\n",block[j],i);
			if(a[i]==block[j]) break;//如果内存块已存储该数据则退出当前循环
			else if (a[i]!=block[j] && j==bn-1) {//如果遍历内存块数据都匹配不上则保存
				f=1;
			}
		}
		if (f) {
			//printf("======block[%d]=%d,a[%d]=%d=====\n",bk,block[bk],i,a[i]);
			block[bk]=a[i];
			bk++;
			if (bk>=bn) bk%=bn;//确保内存块不超出范围
			miss++;
			f=0;
		}
		/*printf("i=%d\tmiss=%d\t\t",i,miss);
		for (k=0; k<bn; k++) printf("block[%d]=%d\t",k,block[k]);
		putchar('\n');*/
	}
	printf("最后内存中的值为：");
	for (i=0; i<bn; i++) printf("%d\t",block[i]);
	printf("\nFIFO页面置换算法的缺页次数为%d,缺页率为%d/%d\n",miss,miss,n);
}
void opt(int a[MAXSIZE],int n,int bn) {
	printf("\n-------------OPT置换算法-------------\n");
	int block[BlookMaxSize],blockindex[BlookMaxSize];//blockindex数组用于记录新数据在未来的页面走向的下标，比较出走向最远的，实现页面置换
	int miss=0,bk=0,f=0,index=0,i,j,k,l;
	for (i=0; i<bn; i++) {
		block[i]=-1;
		//blockindex[i]=-1;
	}
	for (i=0; i<n; i++) {
		for (l=0; l<bn; l++)	blockindex[l]=-1;
		for (j=0; j<bn; j++) {
			if (block[j]==-1) {//内存块未分配完
				f=1;
				break;
			}
			if(a[i]==block[j]) break;
			else if (a[i]!=block[j] && j==bn-1) {
				//printf("\nenter zhihuan1\n");
				for (k=0; k<bn; k++) {//内存块
					for (l=i; l<n; l++) {//未来的页面走向
						if(block[k]==a[l]) {
							blockindex[k]=l;//记录第一次出现的下标
							//printf("\nblockindex[%d]=%d\n",k,l);
							break;
						}
					}
				}
				//printf("\nenter zhihuan2\n");
				for (k=0; k<bn; k++) {
					//printf("\nindex=%d,blockindex[%d]=%d\n",index,k,blockindex[k]);
					f=2;
					if (blockindex[k]==-1) {//还有一种情况，未来走向中该数据没再次出现，则直接将其替换
						index=k;
						break;
					}
					if (blockindex[index]<blockindex[k]) index=k;
				}
			}
		}
		if (f==1) {
			//printf("======block[%d]=%d,a[%d]=%d,f=%d=====\n",bk,block[bk],i,a[i],f);
			block[bk]=a[i];
			bk++;
			if (bk>=bn) bk%=bn;
			miss++;
			f=0;
		} else if(f==2) {
			//printf("======block[%d]=%d,a[%d]=%d,f=%d,index=%d=====\n",index,block[index],i,a[i],f,index);
			block[index]=a[i];
			miss++;
			f=0;
			index=0;
		}
		/*printf("i=%d\tmiss=%d\t\t",i,miss);
		for (k=0; k<bn; k++) printf("block[%d]=%d\t",k,block[k]);
		putchar('\n');*/
	}
	printf("最后内存中的值为：");
	for (i=0; i<bn; i++) printf("%d\t",block[i]);
	printf("\nOPT页面置换算法的缺页次数为%d,缺页率为%d/%d\n",miss,miss,n);
}
void lru(int a[MAXSIZE],int n,int bn) {
	printf("\n-------------LRU置换算法-------------\n");
	int miss=0,bk=0,f=0,index=0,i,j,k,l;
	struct work lru[BlookMaxSize];
	for (i=0; i<bn; i++) {
		lru[i].black=-1;
		lru[i].t=0;
	}
	for (i=0; i<n; i++) {
		for (j=0; j<bn; j++) {
			if (lru[j].black==-1) {//内存块未分配完
				lru[j].t=-1;
				f=1;
				//printf("====1====\n");
				break;
			} else if(a[i]==lru[j].black) {
				lru[j].t=-1;
				f=2;
				//printf("====2====\n");
				break;
			} else if (a[i]!=lru[j].black && j==bn-1) { //置换条件
				//printf("====3====\n");
				for (k=0; k<bn; k++) { //比较时间t
					if(lru[index].t<lru[k].t) index=k;
					//printf("k=%d,t=%d\n",k,lru[k].t);
					f=3;
				}

			}
		}
		if (f==1) {
			lru[bk].black=a[i];
			for (j=0; j<bn; j++) lru[j].t++; //整体访问时间+1
			bk++;
			if (bk>=bn) bk%=bn;
			miss++;
			f=0;
		} else if(f==2) {
			for (j=0; j<bn; j++) lru[j].t++;
			f=0;
		} else if (f==3) {
			//printf("is 3 time,index=%d\n",index);
			lru[index].black=a[i];
			lru[index].t=-1;
			for (j=0; j<bn; j++) lru[j].t++;
			miss++;
			f=0;
			index=0;
		}
		/*printf("i=%d\tmiss=%d\t\t",i,miss);
		for (k=0; k<bn; k++) printf("block[%d]=%d\t",k,lru[k].black);
		for (l=0; l<bn; l++) printf("t[%d]=%d\t",l,lru[l].t);
		putchar('\n');*/
	}
	printf("最后内存中的值为：");
	for (i=0; i<bn; i++) printf("%d\t",lru[i].black);
	printf("\nLRU页面置换算法的缺页次数为%d,缺页率为%d/%d\n",miss,miss,n);
}
int main() {
	int page[MAXSIZE],pagenumber,blocknumber,n;
	printf("请输入页号个数及物理内存块数：");
	scanf("%d%d",&pagenumber,&blocknumber);
	printf("请输入页面走向：");
	for (int i=0; i<pagenumber; i++) {
		scanf("%d",&page[i]);
	}
	printf("运行算法，请等待：\n");
	fifo(page,pagenumber,blocknumber);
	opt(page,pagenumber,blocknumber);
	lru(page,pagenumber,blocknumber);
	return 0;
}

效果：

---