OS实验：实现页面替换的FIFO与LRU算法（C++）

1.FIFO

       FIFO算法即为“先进先出”算法，主要用到的数据结构是队列，用到一个页面时，先判断它是否已在内存中，如果已在内存中，则未产生缺页错误，直接使用该页面即可，继续看下一个页面；否则，产生缺页错误，需要将该页面调入内存。这时，需要判断队列（内存单元）是否已满，如果满了，就需要将队首元素移出队列，再将新元素加入其中；如果没满，直接将新元素加入队列即可。

用到的变量及数据结构：

int ap：队列的大小/内存单元的个数

int pp：进程用到的页面号的最大值+1（eg：pp==7表示要用的页面为123456）

int total_instruction：页面使用总次数

int page[ap]：表示内存单元，数组元素取值为页面号，表示某个页面放入了内存

int pagecontrol[pp]：此数组从pagecontrol[1]开始用，下标表示页面号（不从0开始，因为page[i]取0表示该内存单元无页面，所以不用0号页面）。数组的元素取值为1或0，表示某个页面是否在内存中

int main[total_instruction]：该序列表示页面使用顺序

int diseffect：缺页错误次数

queue<int>q：队列

代码如下：

#include<iostream>
#include<stdlib.h> //rand()
#include<queue> //队列 
using namespace std;

int main(){
	//初始化 
	queue<int>q; //初始化队列 
	int ap; //队列大小 
	int pp; //页面号最大值+1 
	int total_instruction; //使用页面的总次数 
	int diseffect; //缺页错误次数  
	cout<<"please input ap:";
	cin>>ap;
	cout<<"please input pp:";
	cin>>pp;
	cout<<"please input total_instruction:";
	cin>>total_instruction;
	int *page=new int[ap]; //page[i]存放pagecontrol的下标 
	int *pagecontrol=new int[pp]; //pagecontrol的下标是页面号，该数组从pagecontrol[1]开始用，元素取值0/1
	int *main=new int[total_instruction]; //main[i]表示要用到的页面号，即pagecontrol的下标 ，此序列表示页面使用顺序 
	for(int i=0;i<ap;i++) page[i]=0; //内存每个单元都没放页面 
	for(int i=1;i<pp;i++) pagecontrol[i]=0; //每个页面都不在内存(page)中
		//生成随机页面序列并输出 
	cout<<"page using order: ";
	for(int i=0;i<total_instruction;i++){
		main[i]=rand()%(pp-1)+1; //取值为从1到pp-1 
		cout<<main[i]<<" ";
	}
	cout<<endl;
	cout<<"queue:"<<endl;
	diseffect=0; //刚开始，缺页错误次数为0 
	//开始进程，使用页面 
	for(int i=0;i<total_instruction;i++){
		if(pagecontrol[main[i]]==1){ //该页面已经在内存中，即未发生缺页错误，再看下一个页面 
		}  
		else{ //缺页错误 
			pagecontrol[main[i]]=1; //页面号为main[i]的页面被调入内存 
			diseffect++;
			bool flag=1; //1满0未 
			int j; 
			for(j=0;j<ap;j++){//看内存队列是否满了 
				if(page[j]==0){ //只要有一个内存单元为空，则队列未满 
					flag=0;
					break;
				}
			}
			if(flag==0){ //队列没满，只需要将其放入队列即可 
				page[j]=main[i]; //将该页面放入内存的page[j]空间	
				q.push(main[i]); //将页面号加入队列		
			}
			else{ //队列满啦，页面替换 
				for(int k=0;k<ap;k++){ //找出队首元素在哪个内存单元 
					if(page[k]==q.front()){
						page[k]=main[i]; //内存中页面号替换 
						break;
					}
				}
				pagecontrol[q.front()]=0; //队首元素被调出内存 
				q.pop(); //出队列 
				q.push(main[i]); //入队列		
			}
		}
		//输出每步的队列 
		int *temp=new int[ap];
		int count=0;
		cout<<main[i]<<": ";
		while(!q.empty()){//输出队列中all元素 
			cout<<q.front()<<" ";
			temp[count]=q.front();
			q.pop();
			count++;
		}
		cout<<endl;
		for(int h=0;h<count;h++){//把刚刚输出的all元素放回队列 
			q.push(temp[h]);
		}
		delete [] temp;
	}
	//进程结束，计算整个过程中的命中率=1-缺页错误率 
	cout<<"hit_rate = "<<(1-((float)diseffect/(float)total_instruction))*100<<"%"<<endl; 
	delete [] page;
	delete [] pagecontrol;
	delete [] main;
	return 0;
} 

 运行结果：

本程序的优点主要是可以根据不同的输入来产生相应的输出，适用于多种情况，且每步都会输出相应的队列，便于分析。

缺点主要是使用的随机数函数为rand()，在输入相同时，输出也是相同的，也就是说，并没有实现完全的随机。

2.LRU

LRU即“最近最少使用”算法，该算法根据之前元素的使用来预测未来的使用，即“用过去估计未来”。该算法的特点在于，之前的使用如果是111112，那么当需要替换时，还是1被替换，这体现出该算法对于优先级的评定重点在于“最近的使用”，也就是说优先级评定更看重“最近”而不是“最多”。

根据该算法的特点，书上给出了两种实现方法，第一种是每个内存中元素加一个计数器，第二种是用栈。但是，个人认为计数器的实现较麻烦，而栈的那种实现方式竟然把要移出的元素放在栈底，但是根据我们常规的思维来说，栈是“先进后出”，针对LRU的特点，也就是“先使用后出”，但是这种实现方法竟然把栈用成了“先使用先出”，这一看，用队列显然就更好嘛。

因此我采用队列来实现该算法。

用队列还有一个好处，就是可以直接在FIFO的程序上来改。而FIFO的思路基本上就是先判断要用的页面是否在内存中，如果不在，再判断内存是否满。我们要用LRU，在FIFO的基础上需要改的就是队列不能完全按照之前的“先进先出”，而要改成“先使用先出”。那么具体应该怎样更改呢？我发现，LRU只需要当要用的页面在内存中时，把队列重新组织即可，其他都与FIFO相同。这个“重新组织”，说白了就是把用到的这个元素放在队尾，而其他元素的位置不变。

具体实现类似于FIFO中的“输出每步的队列”那部分，也就是说，把队列中所有元素都“倒出来”，其他元素再按顺序放进去，而需放在队尾的那个最后再放进去。我是用了一个暂存数组temp1[ap]，把倒出来的其他元素暂存在里面。

由于是在FIFO的代码上改，因此只列出了改动部分的代码（懒）

		if(pagecontrol[main[i]]==1){ //该页面已经在内存中，即未发生缺页错误，需将该元素放在队尾
			int count1=0;//记录队列中除了那个元素外，还有几个元素
			int *temp1=new int[ap];//将队列中元素拿出来暂存在temp1 
			while(!q.empty()){ 
				if(q.front()!=main[i]){ //将除了需移动的那个元素外的所有元素拿出来存放在temp1 
					temp1[count1]=q.front();
					count1++;
					q.pop();
				}
				else{
					q.pop(); //如果是那个元素，就直接扔出去，不用暂存 
				} 
			}
			for(int g=0;g<count1;g++){ //先将除了此元素的所有元素放入队列 
				q.push(temp1[g]);
			}
			q.push(main[i]); //再把此元素放入队列，即实现了将其放在队尾的操作 
			delete [] temp1;
		} 

运行结果：

 文章到此结束啦，感谢支持~