操作系统——FIFO和LRU页面置换算法

最新推荐文章于 2024-02-19 09:17:16 发布
最新推荐文章于 2024-02-19 09:17:16 发布
阅读量5.5w 收藏 458
点赞数 94
分类专栏： 原创教程 算法 操作系统 文章标签： 页面置换算法 操作系统 FIFO LRU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012321457/article/details/80714640
版权

一、算法介绍

1. 先进先出FIFO页面置换算法（来自百度百科-先进先出页面置换算法）

  • 简介：优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。 
  • 实现过程：假定系统为某进程分配了三个物理块，并考虑有以下页面号引用串：7, 0, 1, 2, 0, 3, 0,4,2,3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1。釆用FIFO算法进行页面置换，进程访问页面2时，把最早进入内存的页面7换出。然后访问页面3时，再把2, 0, 1中最先进入内存的页换出。由下图可以看出，利用FIFO算法时进行了12次页面置换。
访问页面70120304230321201701
物理块1777222444000777
物理块200033322211100
物理块31110003332221
缺页否√√√√√√√√√√√√√√√
  • 缺点：FIFO算法还会产生当所分配的物理块数增大而页故障数不减反增的异常现象，这是由Belady于1969年发现，故称为Belady异常，如下图所示。只有FIFO算法可能出现Belady异常，而LRU和OPT算法永远不会出现Belady异常。

2. 最近最久未使用LRU页面置换算法（来自博客园-操作系统之页面置换算法）

  • 简介：利用局部性原理，根据一个作业在执行过程中过去的页面访问历史来推测未来的行为。它认为过去一段时间里不曾被访问过的页面，在最近的将来可能也不会再被访问。所以，这种算法的实质是：当需要淘汰一个页面时，总是选择在最近一段时间内最久不用的页面予以淘汰。 
  • 实现过程：对上面的实例釆用LRU算法进行页面置换，如图所示。进程第一次对页面2访问时，将最近最久未被访问的页面7置换出去。然后访问页面3时，将最近最久未使用的页面1换出。
  • 补充说明：LRU性能较好，但需要寄存器和栈的硬件支持。LRU是堆栈类的算法。理论上可以证明，堆栈类算法不可能出现Belady异常。FIFO算法基于队列实现，不是堆栈类算法。

访问页面70120304230321201701
物理块1777224440111
物理块200000033300
物理块31133222227
缺页否√√√√√√√√√√√√

二、代码实现

#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<iomanip>
using namespace std;
/*
2018.06.15
测试数据 
------------------------------------------- 
3
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1 #
------------------------------------------- 
3
1 2 3 4 1 2 5 1 2 3 4 5 #
------------------------------------------- 
5
0 1 2 3 4 5 0 2 1 8 5 2 7 6 0 1 2 #
------------------------------------------- 
*/
int GetDistance(int currentPageID,int page);//按照页面编号获取在物理块内的页面最久未使用的时间（哪个距离当前pageID最远）
class BLOCK{
public:
	int blockNum;	//物理块总数
	int pageNum;	//物理块中的页面数量 
	int *pageID;	//页面号（大小为blockNum）
	int *stayTime;	//页面在物理块中的停留时间（与物理块ID对应）
	BLOCK(int num)
	{
		int i;
		pageNum=0;
		blockNum=num;
		pageID=new int[num];
		stayTime=new int[num];
		for(i=0;i<num;i++)
		{
			pageID[i]=-1;	//初始化每个物理块中没有放置，页面号表示为-1
			stayTime[i]=0;	//初始化停留时间为0
		}
	}
	void Init()
	{
		int i;
		int num=blockNum;
		pageNum=0;
		pageID=new int[num];
		stayTime=new int[num];
		for(i=0;i<num;i++)
		{
			pageID[i]=-1;	//初始化每个物理块中没有放置，页面号表示为-1
			stayTime[i]=0;	//初始化停留时间为0
		}
	}
	void ShowPage()
	{
		int i;
		for(i=0;i<blockNum;i++)
		cout<<"Page["<<i<<"]: "<<pageID[i]<<endl;
	}
	void ShowStayTime()
	{
		int i;
		for(i=0;i<blockNum;i++)
		cout<<"Stay["<<i<<"]: "<<stayTime[i]<<endl;
	}
	int GetLongestStay()	//获取在物理块中停留时间最长的页面所在物理块号 
	{
		int i;
		int max_pos=0;
		for(i=0;i<pageNum;i++)
		if(stayTime[max_pos]<stayTime[i])
		max_pos=i;
		return max_pos;
	}
	int GetRencentNotUse(int currentPageID)	//获取在物理块中最近最久未使用的页面编号 
	{
		//默认currentPageID一定大于等于BLOCKNUM
		int i;
		int DestID=0;
		for(i=0;i<blockNum;i++)
		{
			if(GetDistance(currentPageID,pageID[i])>GetDistance(currentPageID,pageID[DestID]))
			DestID=i;
		}
		return DestID;
	}
};	//物理块数据结构定义

//-----------------------全局变量-------------------------
int BLOCKNUM;		//物理块数
int *PVS;			//PageVisitSequence页面访问序列
int PVS_NUM;		//页面访问序列长度
int **replaceTable;	//页面置换表格（维度：BLOCKNUM*PVS_NUM）
int *replaceArray;	//页面置换标志数组（大小为访问页面的次数，存储每次访问是否进行页面置换） 
int *lackArray;		//缺页中断标志数组（大小为访问页面的次数，存储每次访问是否存在缺页中断） 
//-----------------------函数声明-------------------------
void showMenu();							//菜单显示
void InputAndInit();						//数据输入和变量初始化
void ReplaceFIFO(BLOCK block);				//FIFO页面置换算法
int FindPage(int pageID,BLOCK block);		//页面查找（按照页面编号在物理块中查找页面是否存在） 
void ShowReplaceTable();					//置换表格输出
void ReplaceLRU(BLOCK block);				//LRU页面置换算法
void InfoDisplay();							//初始化信息显示 
int GetReplaceTimes();						//获取页面置换总次数
int GetLackTimes();							//获取缺页中断总次数 
//-----------------------函数定义-------------------------
int main()
{
	int select;
	int i;
	cout<<"亲爱的召唤师，在使用本程序之前，请按提示输入算法模拟需要的数据..."<<endl;
	InputAndInit();
	BLOCK block(BLOCKNUM);	//定义物理块（注意该语句必须在变量和数据初始化后，否则BLOCKNUM未知） 
	cout<<"信息初始化完成！"<<endl<<endl;
	showMenu();
	cout<<"请输入要进行的操作..."<<endl;
	cin>>select;
	while(1)
	{
		switch(select)
		{
			case 1:
				InfoDisplay();
				cout<<endl;
			break;
			case 2:
				ReplaceFIFO(block);
				cout<<"|=================> FIFO页面调度算法正在执行......"<<endl;
				ShowReplaceTable();
				cout<<"页面置换次数为："<<GetReplaceTimes()<<endl;
				cout<<"缺页中断次数为："<<GetLackTimes()<<endl;
				cout<<endl;
				cout<<endl;
			break;
			case 3:
				ReplaceLRU(block);
				cout<<"|=================> LRU页面调度算法正在执行......"<<endl;
				ShowReplaceTable();
				cout<<"页面置换次数为："<<GetReplaceTimes()<<endl;
				cout<<"缺页中断次数为："<<GetLackTimes()<<endl;
				cout<<endl;
				cout<<endl;
			break;
			case 0:
				cout<<"欢迎下次使用..."<<endl;
			return 0;
			default:
				cout<<"输入有误，请重新输入..."<<endl;
				cout<<endl;
			break; 
		}
		//------防止页面置换和缺页次数计算错误------------- 
		for(i=0;i<PVS_NUM;i++)
		{
			replaceArray[i]=0; 					//页面置换标志数组初始化为0 
			lackArray[i]=0; 					//缺页中断标志数组初始化为0 
		} 
		showMenu();
		cout<<"请输入要进行的操作（退出请输入0）..."<<endl;
		cin>>select;
	}
	
	delete[] PVS;
	delete[] replaceArray;
	delete[] lackArray;
	for(i=0;i<BLOCKNUM;i++)
	delete[] replaceTable[i];
	delete[] replaceTable;
	return 0;
}
//----------------------FIFO页面置换算法--------------------------
void ReplaceFIFO(BLOCK block)			//FIFO页面置换算法
{
	int i,j;
	for(i=0;i<BLOCKNUM;i++)
		for(j=0;j<PVS_NUM;j++)
			replaceTable[i][j]=0;
	block.Init();
	int replacePosition;				//待置换位置 
	for(i=0;i<PVS_NUM;i++)				//依次对页面访问序列的每一个页面PVS[i]进行操作
	{
		for(j=0;j<block.pageNum;j++)
		block.stayTime[j]++;			//每循环一次，物理块（0~pageNum）停留时间自增 
		if(block.pageNum<block.blockNum)
		{
			if(!FindPage(PVS[i],block))	//若页面PVS[i]不存在
			{
				lackArray[i]=1;			//由于访问页面不存在造成页面中断 
				block.pageID[block.pageNum]=PVS[i];
				block.pageNum++;
			}
		}
		else							//FIFO算法（置换停留时间最长的页面所在物理块位置） 
		{
//			TODO:若页面已存在的情况（上述三条语句应该是页面不存在的情况，应加上if(页面在物理块中不存在)的判断） By_2018.06.15_16:11
			if(!FindPage(PVS[i],block))	//若页面PVS[i]不存在
			{
				replaceArray[i]=1;		//由于访问页面不存在且无空闲物理块造成页面置换
				lackArray[i]=1;			//由于访问页面不存在造成页面中断 
				replacePosition=block.GetLongestStay();
				block.pageID[replacePosition]=PVS[i];	//选择停留时间最长的页面置换
				block.stayTime[replacePosition]=0;		//置换后，该页面所在物理位置停留时间清零 
			}
		}
		for(j=0;j<BLOCKNUM;j++)
		replaceTable[j][i]=block.pageID[j];	//将访问一次页面后的结果存入数组中（replaceTable）
	}
}
int FindPage(int pageID,BLOCK block)		//页面查找（按照页面编号在以存放页面的物理块（长度为pageNum）中查找页面是否存在） 
{
	int i=0;
	for(i=0;i<block.pageNum;i++)
	if(block.pageID[i]==pageID)
	break;
	return !(i==block.pageNum);				//若页面存在，则返回1，否则返回0 
}
//----------------------LRU页面置换算法--------------------------
void ReplaceLRU(BLOCK block)			//LRU页面置换算法
{
	int i,j;
	for(i=0;i<BLOCKNUM;i++)
		for(j=0;j<PVS_NUM;j++)
			replaceTable[i][j]=0;
	block.Init();
	int replacePosition;				//待置换位置 
	for(i=0;i<PVS_NUM;i++)				//依次对页面访问序列的每一个页面PVS[i]进行操作
	{
		for(j=0;j<block.pageNum;j++)
		block.stayTime[j]++;			//每循环一次，物理块（0~pageNum）停留时间自增 
		if(block.pageNum<block.blockNum)
		{
			if(!FindPage(PVS[i],block))	//若页面PVS[i]不存在
			{
				lackArray[i]=1;			//由于访问页面不存在造成页面中断 
				block.pageID[block.pageNum]=PVS[i];
				block.pageNum++;
			}
		}
		else							//FIFO算法（置换停留时间最长的页面所在物理块位置） 
		{
//			TODO:若页面已存在的情况（上述三条语句应该是页面不存在的情况，应加上if(页面在物理块中不存在)的判断） By_2018.06.15_16:11
			if(!FindPage(PVS[i],block))	//若页面PVS[i]不存在
			{
				replaceArray[i]=1;		//由于访问页面不存在且无空闲物理块造成页面置换
				lackArray[i]=1;			//由于访问页面不存在造成页面中断 
				replacePosition=block.GetRencentNotUse(i);
				block.pageID[replacePosition]=PVS[i];	//选择停留时间最长的页面置换
				block.stayTime[replacePosition]=0;		//置换后，该页面所在物理位置停留时间清零 
			}
		}
		for(j=0;j<BLOCKNUM;j++)
		replaceTable[j][i]=block.pageID[j];	//将访问一次页面后的结果存入数组中（replaceTable）
	}
}
//----------------------OTHRES--------------------------
void showMenu()						//菜单显示 
{
	cout<<"\t\t|---------------------------------------------------------------|"<<endl;
	cout<<"\t\t|\t\t\t第22组\t\t                        |"<<endl;
	cout<<"\t\t|\t组员：赵文浩 赵前严 王婉玉 庞刘成 赵亚军                |"<<endl;
	cout<<"\t\t|----------------------------MENU-------------------------------|"<<endl;
	cout<<"\t\t|\t1. 初始化信息显示                                       |"<<endl;
	cout<<"\t\t|\t2. FIFO页面置换算法                                     |"<<endl;
	cout<<"\t\t|\t3. LRU页面置换算法                                      |"<<endl;
	cout<<"\t\t|\t0. 退出程序                                             |"<<endl;
	cout<<"\t\t|---------------------------------------------------------------|"<<endl;
}
void InputAndInit()					//数据输入和变量初始化 
{
	int i=0;
	int j=0;
	char PVS_char[100];
	cout<<"请输入物理块数..."<<endl;
	cin>>BLOCKNUM;
	cout<<"请依次输入页面访问序列（0~9，以#结束）..."<<endl;
	cin>>PVS_char[i];
	getchar();
	while(PVS_char[i]!='#')
	{
		i++;
		cin>>PVS_char[i];
		getchar();
	}
	PVS_char[i]='\0';					//设置字符串终止符
	PVS_NUM=i;
	PVS=new int[PVS_NUM];
	for(i=0;i<PVS_NUM;i++)
	PVS[i]=PVS_char[i]-'0';				//字符转数字（页面号）
	
	replaceArray=new int[PVS_NUM];
	lackArray=new int[PVS_NUM];
	for(i=0;i<PVS_NUM;i++)
	{
		replaceArray[i]=0; 					//页面置换标志数组初始化为0 
		lackArray[i]=0; 					//缺页中断标志数组初始化为0 
	} 
	replaceTable=new int*[BLOCKNUM];	//页面置换表初始化
	for(i=0;i<BLOCKNUM;i++)
		replaceTable[i]=new int[PVS_NUM];
}
void ShowReplaceTable()						//置换表格输出 
{
	int i,j;
	cout<<"页面置换过程如下图所示"<<endl<<endl;
	cout<<setw(PVS_NUM*3+14)<<setfill('-')<<"-"<<endl;
	cout.fill(' ');
	cout<<"页面访问序列 ";
	for(i=0;i<PVS_NUM;i++)
	cout<<" "<<setw(2)<<PVS[i];
	cout<<endl;
	cout<<setw(PVS_NUM*3+14)<<setfill('-')<<"-"<<endl;
	cout.fill(' ');
	cout<<"页面置换过程 ";
	for(i=0;i<BLOCKNUM;i++)
	{
		if(i>0)
		cout<<"\t     ";
		for(j=0;j<PVS_NUM;j++)
		{
			if(replaceTable[i][j]!=-1)
			cout<<"|"<<setw(2)<<replaceTable[i][j];
			else cout<<"|"<<setw(2)<<" ";	//-1时代表该物理块无页面，不输出
		}
		cout<<"|"<<endl;
	}
	cout<<setw(PVS_NUM*3+14)<<setfill('-')<<"-"<<endl;
	cout<<"页面置换标志 ";
	cout.fill(' ');
	for(i=0;i<PVS_NUM;i++)
		cout<<" "<<setw(2)<<replaceArray[i];
	cout<<endl;
	cout<<setw(PVS_NUM*3+14)<<setfill('-')<<"-"<<endl;
	cout<<"页面中断标志 ";
	cout.fill(' ');
	for(i=0;i<PVS_NUM;i++)
		cout<<" "<<setw(2)<<lackArray[i];
	cout<<endl;
	cout<<setw(PVS_NUM*3+14)<<setfill('-')<<"-"<<endl<<endl;
}
int GetDistance(int currentPageID,int page)	//按照页面编号获取在物理块内的页面最久未使用的时间（哪个距离当前pageID最远）
{
	int distance=0;
	int i;
	for(i=currentPageID-1;i>=0;i--)
	if(PVS[i]!=page)
	distance++;
	else break;
	return distance;
}
void InfoDisplay()							//初始化信息显示 
{
	int i;
	cout<<"本页面置换模拟算法中: "<<endl;
	cout<<"物理块数为： "<<BLOCKNUM<<endl;
	cout<<"页面访问序列为：";
	for(i=0;i<PVS_NUM;i++)
	cout<<PVS[i]<<" ";
	cout<<endl;
}
int GetReplaceTimes()						//获取页面置换总次数 
{
	int sum=0;
	int i;
	for(i=0;i<PVS_NUM;i++)
	sum+=replaceArray[i];
	return sum;
}
int GetLackTimes()							//获取页面中断总次数 
{
	int sum=0;
	int i;
	for(i=0;i<PVS_NUM;i++)
	sum+=lackArray[i];
	return sum;
}

三、运行结果

*引用请注明来源

终于看完啦！如果我的代码对你有些帮助，欢迎各位给我打个赏激励我创作更加优质的内容 ~

同时也欢迎大家订阅我的github账号（https://github.com/LeoHaoVIP）

LeoHao-VIP
关注
  • 94
    点赞
  • 踩
  • 458
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
操作系统实训——模拟页面置换（OPT、LRU、FIFO）
12-23
操作系统实训选题，通过三种算法（OPT、LRU、FIFO）实现模拟页面置换的工作过程。初始设定最多20个页面引用串，设定3个物理块。缺页率如果要输出，去掉注释//，把20改为获取用户输入字符串长度。有三个版本，1.0是直接输出结果，2.0、2.0s支持用户输入。2.0s改进了在codeblocks等平台的编译报错。
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现算法比较的程序输出，比如：缺页率和页面置换次数等。 3.采用固定分配局部置换，且可以在程序中实现块数重新分配。 具有抖动判断和Belady异常判断机制 根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,置换次数,命中率的结果; 3.进行虚拟存储算法设计分析。
前端开发者必知的缓存淘汰策略：LRU算法解析与实践
最新发布
球球不吃虾WHR2349博客
02-19 1216
LRU算法作为前端开发者工具箱中的一种重要武器，在提升应用性能、降低资源消耗方面发挥着不可忽视的作用。希望这篇博客能帮助你更好地理解和运用LRU算法，让我们的前端应用更加高效和流畅！愿你在编程之路上不断积累知识，如同LRU缓存中的数据一样，总是保留最新的智慧，淘汰掉陈旧的困扰！
页面置换算法（FIFO和LRU）
weixin_74337975的博客
01-31 855
之后就是页面置换算法，lru函数接受两个参数，一个是数组，一个是该数组中元素个数，先用函数创建一个栈，然后遍历整个数组，用currentpage来存储当前遍历到的页面，如果栈空，就直接将页面调入内存，如果栈非空，但是页面不在内存中，也是将页面调入内存，如果栈非空，但是页面在内存中，就要将页面调到栈顶。当页面在内存中时，还需要将这个页面调到栈顶，要先知道这个页面在数组中的位置，所以还要一个查找函数，查找函数和判断是否在内存中一样，唯一不同的是，如果遍历时找到页面了，查找函数要返回该页面在内存中的位置。
操作系统实验——内存管理之页面置换算法
12-15
操作系统实验——内存管理之页面置换算法，包括FIFO，LRU，CLOCK三种算法
操作系统课程设计——页面置换算法模拟实现
02-24
内含源代码及课程设计报告。 设计目的：存储管理的主要功能之一是合理的分配空间。请求页式存储管理是一种常用的虚拟存储管理技术。通过对请求页式存储管理中页面置换算法的模拟设计，掌握请求页式存储管理页面置换算法，并进一步理解虚拟存储技术的原理及特点。 设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰算法（OPT），最近最久未使用算法（LRU）计算不同内存容量下的缺页率，模拟表示出不同算法内存中页面的变化情况，并对不同内存容量下不同算法的缺页率进行比较分析（例如，可以采用图表、动画等方式来表示各种算法的执行过程；可以用图表方式来对比分析不同算法的缺页率）。
页面置换算法
Bit_Dong的博客
07-23 1万+
进程运行时，若其访问的页面不在内存而需将其调入，但内存已无空闲空间时，就需要从内存中调出一页程序或数据，送入磁盘的对换区，其中选择调出页面的算法就称为页面置换算法。好的页面置换算法应有较低的页面更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页面先调出在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做。....
页面置换算法（FIFO,OPT,LRU)
充满焦虑的大学生
05-20 7007
先进先出页面置换算法（First In First Out，FIFO）是一种简单的页面置换算法，它依据页面进入主存储器的先后顺序进行页面置换。FIFO算法是一种非常直观的页面置换算法，它将最早进入主存储器的页面作为最先置换的页面。具体来说，FIFO算法维护一个先进先出的页面队列，当一个页面需要调入主存储器时，它被加入队列的末尾。当需要置换页面时，FIFO算法选择队列头部的页面进行置换。这样，最先进入主存储器的页面总是最先被置换出去，而最后进入主存储器的页面总是保留在主存储器中。
先进先出页面置换算法详解
qq_48708303的博客
05-12 1万+
*先进先出（First In first Out,FIFO) 页面置换算法的基本思想： **每次置换最先调入内存的页面，即将内存中等待时间最长的页面进行置换。此算法的适用范围是顺序结构程序。 基本原理 FIFO页面置换算法, 也就是先进先出的意思。这和我们现实生活中的排队方式很相似, 先进队伍的人会先买到票, 然后先从队伍中离开。如果使用FIFO算法作为页面置换算法, 缓存空间大小是三个页面时, 一次进入Page1, Page2, Page3。当Page4要进入缓存时, 操作系统将会把Page1清除出...
LRU 页面置换算法
热门推荐
tel17784456683的博客
06-09 2万+
LRU的简单实现 LRU是Least Recently Used的缩写，即最近最少使用，常用于页面置换算法，是为虚拟页式存储管理服务的。 为了尽量减少与理想算法的差距，产生了各种精妙的算法，最少使用页面置换算法便是其中一个。LRU算法的提出，是基于这样一个事实:在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。这...
操作系统课设——FIFO页面置换算法演示
m0_62209604的博客
06-03 2605
通过本课程设计，更好地综合利用所学的操作系统基本原理和方法，增强系统级程序设计能力，进一步加深对操作系统的设计和实现思路的理解，培养系统软件设计能力和动手能力，学会在内核、系统调用及应用程序几个层次上编写程序，提升计算机问题求解的水平，增强系统分析能力。算法需要设置预演的访问序列长度和内存中有的页面数量，在这我使用了宏定义来进行预设： 预演的访问序列长度：#define M 12 内存中含有的页面数量 #define N 3，此处我预设了访问序列长度为12、内存中所含页面数量为3。
页面置换算法OPT+FIFO+LRU+clock
12-31
C语言 页面置换算法 OPT FIFO LRU clock
操作系统页面置换LRU,FIFO,OPT算法实现代码（C#）
01-06
操作系统页面置换LRU,FIFO,OPT，LFU算法实现代码，使用C#动态实现，有TLB快表，可设置页面数量、驻留集大小、自动生成十六进制地址码，分析页号，可设置TLB时间，访问内存时间。
【算法】页面置换算法FIFO、LRU和LFU的概述以及实现方式
IT_Mitchell的博客
08-27 1万+
页面置换算法，我们最常用的页面置换算法包括FIFO先来先服务，LRU最近最久未被使用，LFU最近最少被使用以及我们的时钟置换算法。 一、FIFO算法——先来先服务 1、简述FIFO算法 FIFO算法是我们比较简单的置换算法，就是先来先服务或者说是先进先出。也就是说在进行页面置换的时候，最先来的那个会被最先置换出去。先进入的指令先完成并引退，跟着才执行第二条指令。 2、FIFO算法的简单...
LRU缓存算法(页面置换)
qq_45540125的博客
04-07 3423
LRU（Least Recently Used）是一种常见的页面置换算法，在计算中，所有的文件操作都要放在内存中进行，然而计算机内存大小是固定的，所以我们不可能把所有的文件都加载到内存，因此我们需要制定一种策略对加入到内存中的文件进项选择。 LRU的设计原理就是，当数据在最近一段时间经常被访问，那么它在以后也会经常被访问。这就意味着，如果经常访问的数据，我们需要然其能够快速命中，而不常访问的数据，我们在容量超出限制内，要将其淘汰。
页面置换算法之 LRU算法
零碎@流年絮语 的博客
12-05 9715
最近最久未使用（LRU）算法 基本思想： 利用局部性原理，根据一个作业在执行过程中过去的页面访问历史来推测未来的行为。它认为过去一段时间里不曾被访问过的页面，在最近的将来可能也不会再被访问。所以，这种算法的实质是：当需要淘汰一个页面时，总是选择在最近一段时间内最久不用的页面予以淘汰。 即淘汰最近最长时间未访问过的页面。（往前看） LRU置换算法的硬件支持 寄存器 为每个在内存中的页面配置一个移位寄存器，用来记录某进程在内存中各页的使用情况。移位寄存器表示为 R=Rn-1Rn-2Rn-3…R2R1R0 当进
FIFO页面置换算法简单实现
tel17784456683的博客
06-09 2万+
FIFO页面置换算法简单实现 先进先出置换算法 （页面置换） 最简单的页面置换算法是先入先出(FIFO)法。这种算法的实质是，总是选择在主存中停留时间最长(即最老)的一页置换，即先进入内存的页，先退出内存。理由是:最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。建立一个FIFO队列，收容所有在内存中的页。被置换页面总是在队列头上进行。当一个页面被放入内存时，就把它插在队尾上。 这种算...
LRU页面置换算法
qq_45057259的博客
05-01 4524
LRU页面置换算法 文章目录LRU页面置换算法前言一、LRU算法介绍二、代码1.源程序2.运行结果 前言 LRU页面置换算法是虚拟存储器中使用的算法，通过选取最近最少使用的页面换出 一、LRU算法介绍 LRU（最近最少使用）页面置换算法是根据过去使用次数来预测将来的页面使用情况，具体过程如下： 当发生缺页而分配给进程的物理块耗尽时，需要将所需页面置换入内存，被换出的页面是最近最少被使用的页面。具体的实现方法为为每个内存中的页面配置一个移位寄存器，每过一段时间（如10ms）将其中的数字右移。当该页面被访问
fifo算法_页面置换算法学习总结
weixin_39605835的博客
11-30 4541
近期，学习了操作系统页面置换算法，为了巩固所学知识，主要用先进先出（FIFO）页面置换算法和最近最久未使用（LRU）置换算法进行一个复习。1.FIFO页面置换算法此算法是淘汰最先进入内存的页面，选择在内存中驻留最久的页面予以淘汰，而替换此时需要调用的页面。实现原理：需把一个进程已调入内存的页面按先后顺序链接成一个队列，设置一个指针（替换指针），将指针指向最久调入的页面，若在此队列中已存在，则不进行...
OPT、FIFO和LRU页面置换算法
11-28
以下是对OPT、FIFO和LRU页面置换算法的介绍： 1. OPT页面置换算法 OPT算法是一种理论上的算法，它是根据未来的页面访问情况来进行页面置换的。具体来说，OPT算法会预测在未来最长时间内不会被访问的页面，并将其置换出去。但是，由于无法准确预测未来的页面访问情况，因此OPT算法在实际应用中并不常用。 2. FIFO页面置换算法 FIFO算法是一种最简单的页面置换算法，它是根据页面进入内存的时间顺序来进行页面置换的。具体来说，FIFO算法会将最先进入内存的页面置换出去。但是，FIFO算法存在“先进先出”的缺陷，即最先进入内存的页面可能在未来仍然会被频繁访问，而被置换出去的页面可能在未来很长一段时间内都不会再被访问。 3. LRU页面置换算法 LRU算法是一种基于“最近最少使用”原则的页面置换算法，它是根据页面最近一次被访问的时间来进行页面置换的。具体来说，LRU算法会将最近最少被访问的页面置换出去。LRU算法相对于FIFO算法来说，更加符合实际应用场景，因为最近被访问的页面很可能在未来仍然会被频繁访问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值