页面置换算法(C语言)
页面置换常用的算法总结
页⾯置换常⽤的算法总结本⽂转载⾃:进程运⾏时,若其访问的页⾯不在内存⽽需将其调⼊,但内存已⽆空闲空间时,就需要从内存中调出⼀页程序或数据,送⼊磁盘的对换区。
选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率,也就是说,应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的,或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的,因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块,并考虑有以下页⾯号引⽤串:7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时,先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时,产⽣缺页中断,根据最佳置换算法,选择第18次访问才需调⼊的页⾯7予以淘汰。
然后,访问页⾯0时,因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推,如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到,发⽣缺页中断的次数为9,页⾯置换的次数为6。
访问页⾯70120304230321201701物理块1777222227物理块200004000物理块31133311缺页否√√ √√√√√√√图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯,亦即在内存中驻留时间最久的页⾯。
该算法实现简单,只需把调⼊内存的页⾯根据先后次序链接成队列,设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应,因为在进程中,有的页⾯经常被访问。
页面替换算法
页面替换算法一、实验目的1,通过模拟实现几种基本页面置换的算法,了解虚拟存储技术的特点。
2,掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想,用三种算法来模拟实现。
3,通过对几种置换算法页面来比较他们的优缺点。
二,实验内容:设计一个虚拟工作区和内存工作区,并使用下列算法来模拟实现页面的置换:1,先进先出算法2,最近最少使用算法3,最佳置换算法三,源程序#include<iostream>#include<stdlib.h>using namespace std;int const InsideCount = 3;//内存中存放的页面数int count = 0;int Inside[InsideCount];int const PageCount =10;//总的页面数int Page[PageCount];int insert = 0;//先到先出置换算法fcfo中表示当内存满的时候,新进入的页号放的位置int suiji = 0; //随机置换算法randchange 当内存满的时候,新进入的页号放的位置int state[InsideCount];//clock置换算法中,内存中的每个页面号对应的状态int state2[InsideCount][2];// 二维数组,第一行第一列为访问位,第一行的第二列为修改位double lost = 0.0;bool isInside(int num)//检测页号是否在内存中{for(int i = 0; i < InsideCount; i++){if(Inside[i] == Page[num]){state[i] = 1;return true;}}return false;}bool change() //判断页面是否已经被修改{if((rand()%2+1) == 1 ){cout<<"该页面被修改"<<endl;return true;}elsereturn false;}void LRU(int num)//最近最久未使用置换算法LRU{int max = 0; // 表示内存中的页号,下一次出现的距离int maxchange; //表示内存中下次出现距离最大的页号在内存中的位置int k;if(isInside(num)){cout<<"命中"<<endl;for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}elseif(count == InsideCount){lost++;for(int j=0; j < InsideCount; j++){for( k = num; k >0;k--) //从当前的页号向前看,发现页号与内存中的页号相同,break ;比较内存中三个页号,看哪一个走的远,用max记录{if(Inside[j] == Page[k])break;}if( num - k > max){max = num - k;maxchange =j;//j 表示把内存中第j个Inside中的页面从内存拿出,把新的页面放入}}Inside[maxchange] = Page[num];for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}else{Inside[count] = Page[num];count++;for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}}void FIFO(int num)//先进现出置换算法(FIFO):{if(isInside(num)){cout<<"命中"<<endl;for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}elseif(count == InsideCount){lost++;Inside[insert] = Page[num];insert++;insert = insert % 3;for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}else{Inside[count] = Page[num];count++;for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}}void OPT(int num)//最佳置换算法(OPT){int max = 0; // 表示内存中的页号,下一次出现的距离int maxchange; //表示内存中下次出现距离最大的页号在内存中的位置int k;if(isInside(num)){cout<<"命中"<<endl;for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}elseif(count == InsideCount){lost++;for(int j=0; j < InsideCount; j++){for( k = num; k < PageCount;k++){if(Inside[j] == Page[k])break;}if( k > max){max = k; //k表示在这个地方会再次出现给定页面maxchange =j;//j 表示把内存中第j个Inside中的页面从内存拿出,把新的页面放入}}Inside[maxchange] = Page[num];for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}else{Inside[count] = Page[num];count++;for(int i=0 ; i <InsideCount; i++)cout<<"内存Inside["<<i<<"]中内容为:"<<Inside [i]<<endl;}}int main(){char ch ;//选择使用哪种算法while(1){for(int i = 0; i < PageCount; i++){Page[i] =rand()%9 + 1;}cout<<"O 最佳置换算法(OPT)(理想置换算法)"<<"\n"<<endl;cout<<"F 先进现出置换算法(FIFO)"<<"\n"<<endl;cout<<"U 最近最少使用(LRU)算法"<<"\n"<<endl;cin>>ch;switch(ch){case 'O':{lost = 0;count = 0;for(int j = 0; j < InsideCount; j++){Inside[j] = 0;}for(int i = 0; i < PageCount; i++){cout<<"读入Page["<<i<<"]="<<Page[i]<<endl;OPT(i);}cout<<"共" <<PageCount<<"次,"<<"缺失"<<lost<<" 次,缺失率为"<<lost/(PageCount)<<"\n\n"<<endl;}break;case 'F':{lost = 0;count = 0;for(int j = 0; j < InsideCount; j++){Inside[j] = 0;}for(int i = 0; i < PageCount; i++){cout<<"读入Page["<<i<<"]="<<Page[i]<<endl;FIFO(i);}cout<<"共" <<PageCount<<"次,"<<"缺失"<<lost<<" 次,缺失率为"<<lost/(PageCount)<<"\n\n"<<endl;}break;case 'U':{lost = 0;count = 0;for(int j = 0; j < InsideCount; j++){Inside[j] = 0;}for(int i = 0; i < PageCount; i++){cout<<"读入Page["<<i<<"]="<<Page[i]<<endl;LRU(i);}cout<<"共" <<PageCount<<"次,"<<"缺失"<<lost<<" 次,缺失率为"<<lost/(PageCount)<<"\n\n"<<endl;}break;}}return 0;}四、调试结果。
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法,并实现FIFO、LRU和Clock算法。
二、实验原理页面置换算法是操作系统中用到的一种算法,其作用是在内存不够用时,选择牺牲已经在内存中的一些页,腾出更多的空间给新的内容。
本次实验主要实现了FIFO、LRU和Clock算法。
1、FIFO算法FIFO算法是最简单的页面置换算法,它采用先进先出的原则,即最先进入内存的页面应该最早被替换出去。
该算法的实现非常简单,只需要维护一个队列即可。
当需要置换页面时,选择队列的第一个页面进行替换即可。
2、LRU算法LRU算法是Least Recently Used的缩写,即最近最少使用算法。
该算法的核心思想是选择最久没有被使用的页面进行替换。
为了实现该算法,需要维护记录页面使用时间的链表、栈或队列等结构。
3、Clock算法Clock算法也叫做二次机会算法,是一种改良的FIFO算法。
它是基于FIFO算法的思想,并且每个页面都设置了一个使用位(use bit),用于记录该页面是否被使用过。
当需要置换一个页面时,检查该页面的使用位,如果该页面的使用位为1,则将该页面的使用位设置为0并移到队列的末尾,表示该页面有“二次机会”继续待在内存中;如果该页面的使用位为0,则选择该页面进行替换。
三、实验过程本次实验采用Python语言实现页面置换算法,并使用样例进行测试。
1、FIFO算法实现FIFO算法的实现非常简单,只需要用一个队列来维护已经在内存中的页面,当需要置换页面时,选择队列的第一个元素即可。
代码如下:```pythonfrom collections import dequeclass FIFO:def __init__(self, frame_num):self.frame_num = frame_numself.frames = deque(maxlen=frame_num)def access(self, page):if page in self.frames:return Falseif len(self.frames) >= self.frame_num:self.frames.popleft()self.frames.append(page)return True```2、LRU算法实现LRU算法的实现需要维护一个记录页面使用时间的链表或队列。
页面置换算法
页面置换算法2008-03-01 22:30评价一个算法的优劣,可通过在一个特定的存储访问序列(页面走向)上运行它,并计算缺页数量来实现。
1 先入先出法(FIFO)最简单的页面置换算法是先入先出(FIFO)法。
这种算法的实质是,总是选择在主存中停留时间最长(即最老)的一页置换,即先进入内存的页,先退出内存。
理由是:最早调入内存的页,其不再被使用的可能性比刚调入内存的可能性大。
建立一个FIFO队列,收容所有在内存中的页。
被置换页面总是在队列头上进行。
当一个页面被放入内存时,就把它插在队尾上。
这种算法只是在按线性顺序访问地址空间时才是理想的,否则效率不高。
因为那些常被访问的页,往往在主存中也停留得最久,结果它们因变“老”而不得不被置换出去。
FIFO的另一个缺点是,它有一种异常现象,即在增加存储块的情况下,反而使缺页中断率增加了。
当然,导致这种异常现象的页面走向实际上是很少见的。
2 最优置换算法(OPT)最优置换(Optimal Replacement)是在理论上提出的一种算法。
其实质是:当调入新的一页而必须预先置换某个老页时,所选择的老页应是将来不再被使用,或者是在最远的将来才被访问。
采用这种页面置换算法,保证有最少的缺页率。
但是最优页面置换算法的实现是困难的,因为它需要人们预先就知道一个进程整个运行过程中页面走向的全部情况。
不过,这个算法可用来衡量(如通过模拟实验分析或理论分析)其他算法的优劣。
3 最久未使用算法(LRU)FIFO算法和OPT算法之间的主要差别是,FIFO算法利用页面进入内存后的时间长短作为置换依据,而OPT算法的依据是将来使用页面的时间。
如果以最近的过去作为不久将来的近似,那么就可以把过去最长一段时间里不曾被使用的页面置换掉。
它的实质是,当需要置换一页时,选择在最近一段时间里最久没有使用过的页面予以置换。
这种算法就称为最久未使用算法(Least Recently Used,LRU)。
常见的页面置换算法
常见的页面置换算法1.概述页面置换算法是操作系统中用于管理内存的一种算法,其目的是确保可用内存的最大化并实现对内存的高效使用。
在操作系统中,当进程所需的内存空间超出了可用的物理内存空间时,操作系统就需要从主存中选择一些页面腾出空间来装载进程所需的页面。
这就需要使用页面置换算法。
2.常见的页面置换算法2.1最优页面置换算法(OPT)最优页面置换算法是一种理论上的置换算法。
它的核心思想是通过计算进程未来访问各个页面的时间和距离,来推断出离当前时间最久的页面。
这种算法的优点是能够保证页面置换的最优性,但是它需要预先知道进程未来所有的页面调度情况,这在实际应用中是不可行的。
2.2先进先出(FIFO)置换算法先进先出置换算法是一种很简单的置换算法,它选取主存中驻留时间最长的页面作为替换目标。
优点是实现简单,但是缺点是可能会引发置换震荡问题。
2.3最近最久未使用算法(LRU)最近最久未使用算法是一种比较常用的页面置换算法,其核心思想是将驻留时间久且最近一次使用时间早的页面视为需要置换的页面。
相对于FIFO算法,LRU算法能够保证更高的页面命中率和更小的置换次数。
2.4时钟置换算法(Clock)时钟置换算法是一种改进型的FIFO算法。
该算法使用一个环形队列来存储主存中的页面位置信息。
当需要置换页面时,指针先指向队列首位置,遍历队列并且在第一遍扫描时,将页框的访问位ACC设置为0。
第一遍扫描结束后,如果有页面的ACC位为0,就将其替换出去。
如果找不到未访问页面,指针再回到队列首位置,以此类推,直到找到为止。
3.总结以上所述的几种页面置换算法是操作系统中常见的算法。
它们各有优点和缺点,在实际应用中,需要根据实际情况进行选择。
在选择算法后,还需要对其进行适当的调整,以满足实际需求。
页面置换算法模拟实验 操作系统大作业(含源文件)
“计算机操作系统”课程设计大作业页面置换算法模拟实验(含完整资料,可直接提交)一、题目: 页面置换算法模拟实验二、目的分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法对用户输入的页面号请求序列进行淘汰和置换,从而加深对页面置换算法的理解。
三、内容和要求请用C/C++语言编一个页面置换算法模拟程序。
用户通过键盘输入分配的物理内存总块数,再输入用户逻辑页面号请求序列,然后分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法三种算法对页面请求序列进行转换,最后按照课本P150页图4-26的置换图格式输出每次页面请求后各物理块内存放的虚页号,并算出总的缺页率(缺页次数/总的请求次数)。
最后三种页面置换算法的优缺点。
三种页面置换算法的思想可参考教材P149-P152页。
假设页面号请求序列为4、3、2、1、4、3、5、4、3、2、1、5,当分配给某进程的物理块数分别为3块和4块时,试用自己编写的模拟程序进行页面转换并输出置换图和缺页次数、缺页率。
四、提交内容本大作业每个人必须单独完成。
最后需提交的内容包括:源程序(关键代码需要注释说明)、可运行程序、运行结果、算法思路及流程图、心得体会。
大作业严禁抄袭。
发现抄袭一律以不及格论。
请大家严格按照大作业题目来编写程序,不要上交以前布置的大作业。
如果提交的大作业题目与本文档要求不符,成绩一律为及格。
目录摘要 (2)正文 (2)1、设计思路 (3)2、各模块的伪码算法 (6)3、函数的调用关系图 (8)4、测试 (13)设计总结 (15)参考文献 (16)致谢 (17)附录:部分源程序代码 (18)摘要UNIX中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
页面置换的名词解释
页面置换的名词解释页面置换指的是操作系统中一种内存管理技术,其主要目的是根据内存中的页面使用情况,动态地将内存中的某些页面替换出去,以便腾出空闲的内存空间给其他需要的页面使用。
页面指的是被划分为固定大小的块的内存空间,通常为4KB或者8KB。
在计算机系统中,程序在执行的过程中,会将需要的数据或指令加载到内存中进行处理。
然而,由于内存容量有限,无法一次性将所有程序所需的页面全部加载到内存中。
当程序需要页面而内存空间不足时,操作系统就会采用页面置换的技术,将原本在内存中的某些页面替换出去,给需要的页面腾出空间。
页面置换的目标是使得内存中的页面尽量是那些将来要使用到的页面,以提高程序的运行效率。
常见的页面置换算法有FIFO(先进先出)、最不常用(Least Frequently Used)、最近最少使用(Least Recently Used)等。
FIFO算法是最简单的置换算法,根据页面进入内存的先后顺序来进行替换。
当内存空间不足时,将最早进入内存的页面替换出去。
最不常用算法则是根据页面在一段时间内被访问的频率进行替换。
具体来说,每次页面被访问时,都会将该页面的访问频率加一,当内存空间不足时,选择访问频率最低的页面进行替换。
最近最少使用算法是根据页面最近一次被访问的时间来进行替换。
系统会为每个页面维护一个计时器,记录上次访问的时间。
当需要替换页面时,选择一个最久未被访问的页面进行替换。
这些页面置换算法都有各自的特点和适用场景。
FIFO算法简单且容易实现,但容易产生“抢占”现象;最不常用算法采用了频率统计的方式,可以较好地预测页面的使用情况;最近最少使用算法则更注重于页面的时间局部性。
然而,这些页面置换算法都存在着一定的问题。
例如,FIFO算法没有考虑页面的使用频率;最不常用算法也可能在短时间内无法完全准确地确定页面的使用频率;最近最少使用算法则需要维护精确的访问时间戳,带来了额外的开销。
为了解决这些问题,研究者们还提出了更加复杂的页面置换算法,如二次机会算法、clock算法、工作集算法等。
操作系统页面置换算法实验报告
学生实验报告姓名:年级专业班级学号成绩【实验结果或总结】(对实验结果进行相应分析,或总结实验的心得体会,并提出实验的改进意见1.程序的执行结果如下:(1)先进先出页面置换算法(2)最佳页面置换法(3)最近最久未使用置换算法2.以上三个程序通过数组和排序语句实现页面的三种基本调度算法。
(1)先进先出算法事先设定标志k=3,页面每发生一次置换k值增加1。
通过取k对3的余数来确定被置换的内存中的页面,当被访问页面存在于内存时,不置换,而直接输出原内存中的3个页面。
(2)最佳置换算法通过设定c1,c2,c3来记录当前内存中的页面被下一次访问的位置(时间),通过对c1,c2,c3的大小比较确定内存中需要被置换的页面。
三者中值最大的对应的内存页面选择被置换。
即实现了未来最长时间未访问的机制,即最佳置换算法。
(3)最近最久未使用置换算法的原理跟最佳置换算法类似。
初始设定变量c1,c2,c3记录当前内存中的以前的最近一次未被访问的位置(时间),比较三者的大小来确定需要被置换的页面。
三者中至最小的对应的内存页面选择被置换。
即实现了最近最久未使用的机制,即最近最久未使用置换算法。
3.上述三个程序分别能较好的模拟页面的基本调度算法,实现页面的置换,保证进程的正常执行。
但也分别存在一些不足。
(1)当内存中三个页面有部分相同时,程序不能很好的实现调度。
即c1,c2,c3中有部分变量值相等,源程序可能不能准确的找到调度顺序,如图所示。
(LRU算法)改进的方法为在c1,c2,c3间的大小比较判断语句中增加关系语句的默认处理办法,当三者间有部分相同时,默认选择按从前到后的顺序执行。
比如当c2=c3的时候选择页面a[2]进行置换。
当c1=c2=c3时则选择页面a[0]进行置换。
也就相当于无法运用LRU算法调用的时候折衷采取先进先出置换算法,以实现页面的合理调度,提高页面的利用效率。
指导教师签名:20 年月日【备注】。
页面置换算法实验报告
页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程,了解不同算法的优缺点,掌握算法的实现方法,以及对算法的性能进行评估。
二、实验原理页面置换算法是操作系统中的一个重要概念,它是为了解决内存不足的问题而产生的。
当系统中的进程需要使用内存时,如果内存已经被占满,就需要将一些页面从内存中置换出去,以便为新的页面腾出空间。
页面置换算法就是用来决定哪些页面应该被置换出去的算法。
常见的页面置换算法有以下几种:1. 最佳置换算法(OPT)最佳置换算法是一种理论上的最优算法,它总是选择最长时间内不会被访问的页面进行置换。
但是,由于无法预测未来的页面访问情况,因此最佳置换算法无法在实际中使用。
2. 先进先出置换算法(FIFO)先进先出置换算法是一种简单的置换算法,它总是选择最先进入内存的页面进行置换。
但是,这种算法容易出现“抖动”现象,即频繁地将页面置换出去,然后再将其置换回来。
3. 最近最久未使用置换算法(LRU)最近最久未使用置换算法是一种比较常用的置换算法,它总是选择最长时间未被访问的页面进行置换。
这种算法可以避免“抖动”现象,但是实现起来比较复杂。
4. 时钟置换算法(Clock)时钟置换算法是一种改进的FIFO算法,它通过维护一个环形链表来实现页面置换。
当需要置换页面时,算法会从当前位置开始扫描链表,如果找到一个未被访问的页面,则将其置换出去。
如果扫描一圈后都没有找到未被访问的页面,则将当前位置的页面置换出去。
三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序,可以模拟上述四种算法的过程,并输出算法的性能指标。
程序的主要流程如下:1. 读取输入文件,获取页面访问序列和内存大小等参数。
2. 根据选择的算法,初始化相应的数据结构。
3. 遍历页面访问序列,模拟页面置换的过程。
4. 输出算法的性能指标,包括缺页率、页面置换次数等。
下面分别介绍四种算法的实现方法。
1. 最佳置换算法(OPT)最佳置换算法需要预测未来的页面访问情况,因此需要遍历整个页面访问序列,找到最长时间内不会被访问的页面。
页面置换算法实验报告
页面置换算法实验报告背景页面置换算法是计算机操作系统中的一个重要概念,它用于解决操作系统需要共享有限的物理内存资源给多个进程使用的问题。
在操作系统中,每个进程都有自己的虚拟地址空间,但实际的物理内存资源是有限的。
当物理内存不足时,操作系统需要根据一定的策略将一部分进程暂时从内存中移出,以便为其他进程让出空间,而后再从外存中将其重新加载到内存中。
这个过程就是页面置换。
页面置换算法有很多种,比如最优页面置换算法(Optimal)、先进先出页面置换算法(FIFO)、最近最久未使用页面置换算法(LRU)等等。
不同的算法对于系统性能、响应时间等指标有着不同的影响,因此在实际应用中需要选择合适的算法来平衡各种需求。
本实验旨在通过模拟页面置换算法,并对不同算法进行性能分析,以便了解各种算法的优缺点,为实际系统的选择提供依据。
分析在实验中,我们选择了三种常用的页面置换算法,分别是FIFO、LRU和Optimal。
下面对这三种算法进行详细的分析和说明。
先进先出页面置换算法(FIFO)FIFO算法是最简单和最直观的页面置换算法。
它按照页面进入内存的顺序来选择被淘汰的页面。
当内存不足时,选择最早进入内存的页面进行置换,即将其从内存中移出。
FIFO算法不需要进行进一步的页面访问计算,只需要维护一个页面进入内存的队列即可,因此实现起来比较简单。
然而,由于FIFO算法没有考虑页面的访问频率和重要性,所以可能会导致被频繁访问的页面被淘汰出内存,从而影响系统的性能。
最近最久未使用页面置换算法(LRU)LRU算法是一种基于”最近使用原则”的页面置换算法。
它根据页面最近被访问的时间来选择被淘汰的页面。
当内存不足时,选择最长时间未被访问的页面进行置换,即将其从内存中移出。
LRU算法需要维护一个页面访问时间的记录,以便在需要置换时能够快速找到最近最久未使用的页面。
相比于FIFO算法,LRU算法更加合理地利用了页面的访问情况,但实现起来相对复杂一些。
lru页面置换算法实验c语言总结
LRU页面置换算法实验C语言总结1.引言在计算机科学中,页面置换算法是解决主存容量有限的情况下,如何有效地管理页面(或称为内存块)的一种重要方法。
L RU(L ea st Re ce nt ly Us e d)页面置换算法是其中一种经典的策略,通过淘汰最久未使用的页面来提高内存的利用率。
本文将总结使用C语言实现L RU页面置换算法的相关实验。
2.算法原理L R U页面置换算法的核心思想是:最近被访问的页面可能在未来继续被访问,而最久未被使用的页面可能在未来也不再被访问。
基于这一思想,L R U算法维护一个页面访问的时间顺序链表,每次发生页面置换时,选择链表头部(即最久未使用)的页面进行淘汰。
3.实验设计本次实验旨在使用C语言实现LR U页面置换算法,并通过模拟页面访问的过程来验证算法的正确性。
具体设计如下:3.1数据结构为了实现LR U算法,我们需要定义几个关键的数据结构:3.1.1页面节点结构t y pe de fs tr uc tP age{i n tp ag eI D;//页面I Ds t ru ct Pa ge*n ex t;//下一个节点指针s t ru ct Pa ge*p re v;//上一个节点指针}P ag e;3.1.2内存块结构t y pe de fs tr uc tM emo r y{i n tc ap ac it y;//内存块容量i n ts iz e;//当前存储的页面数量P a ge*h ea d;//内存块链表头指针P a ge*t ai l;//内存块链表尾指针}M em or y;3.2实验步骤本次实验主要包括以下几个步骤:3.2.1初始化内存块根据实际需求,设置内存块的容量,并初始化链表头指针和尾指针。
3.2.2页面置换每次发生页面访问时,检查访问的页面是否已经在内存块中。
如果在,将该页面移动到链表尾部;如果不在,执行页面置换。
3.2.3页面淘汰当内存块已满时,选择链表头部的页面进行淘汰,将新访问的页面加入链表尾部。
页面置换算法(FIFO算法,LRU算法)
实验四页面置换算法一、实验流程图二、实验程序#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define null 0#define len sizeof(struct page)struct page{ int num;int tag;struct page *next;};struct page *create(int n) /*建立分配的内存空间,并初始化,返回头结点*/{int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len); //开辟一个新的单元,并将malloc返回的指针转换为结构体类型的指针p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;struct page *cp,*dp,*head,*new1;int count=0;head=create(n);p=array;while(*p!=-1){ cp=dp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if (cp->num==*p) printf(" ! " );else{ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){cp->num=*p;printf(" * ");}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*new1,*endp;head=create(n);while(*p!=-1){cp=dp=rp=endp=head;for(;endp->next!=null;) endp=endp->next;for(;cp->num!=*p&&cp->next!=null;){rp=cp;cp=cp->next;}if(cp->num==*p){printf(" ! ");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;{printf(" * ");cp->num=*p;cp->tag=0;}else{new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*new1;p=array;head=create(n);while(*p!=-1){ cp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if(cp->num!=*p){ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){printf(" * ");cp->num=*p;cp->tag=0;}else{ i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){ for(;*q!=cp->num&&cp->next!=null;) cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){for(;cp->tag!=0;) cp=cp->next;printf(" %d ",cp->num);cp->num=*p;}else{ cp=head;for(;cp->tag!=0;) cp=cp->next;if(cp==head){ for(;cp->next!=null;) cp=cp->next;new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}else{ printf(" %d ",cp->num);cp->num=*p;}}cp=head;for(;cp->next!=null;) {cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf(" ! ");p++;}printf("\nQueye Zongshu : %d \n",count);}main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Cann't open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF)/*将数字字符串转化成整型-开始*/ {if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1) break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n') break;else{space=1;j++;i=0;}}}}}/*结束*/if(pt==EOF) {str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1) {printf(" %d ",page[i]);i++;}fclose(fp);printf("\n");printf(" ! : mean no moved \n * : mean have free space \n\n"); printf("FIFO ");FIFO(page,3);printf("\nLRU ");LRU(page,3);printf("\nOPT ");OPT(page,3);}。
【操作系统】页面置换算法(最佳置换算法)(C语言实现)
【操作系统】页⾯置换算法(最佳置换算法)(C语⾔实现)【操作系统】页⾯置换算法(最佳置换算法)(C语⾔实现)(编码⽔平较菜,写博客也只是为了个⼈知识的总结和督促⾃⼰学习,如果有错误,希望可以指出)1.页⾯置换算法:在地址映射过程中,若在页⾯中发现所要访问的页⾯不在内存中,则产⽣缺页中断。
当发⽣缺页中断时,如果操作系统内存中没有空闲页⾯,则操作系统必须在内存选择⼀个页⾯将其移出内存,以便为即将调⼊的页⾯让出空间。
⽽⽤来选择淘汰哪⼀页的规则叫做页⾯置换算法。
⼀个好的页⾯置换算法,应具有较低的页⾯更换频率。
从理论上讲,应该保留最近重复访问的页⾯,将以后都不再访问或者很长时间内不再访问的页⾯调出。
----百度百科2.具体的页⾯置换算法:2.1 最佳置换算法:⼀个进程在内存的若⼲个页⾯中,哪⼀个页⾯是未来最长时间内不再被访问的,那么如果发⽣缺页中断时,就将该页⾯换出,以便存放后⾯调⼊内存中的页⾯。
1.这是计算机操作系统(第四版)中的⼀个例⼦。
系统⾸先为进程分配了三个物理块。
上⾯⼀排数字是作业号。
在转满三个物理块后,要访问2号作业,2号作业不在内存,所以会发⽣缺页中断,然后系统需要将2号作业调⼊内存,但是此时物理块已经装满。
2.依据最佳置换算法,会将7号页换出(0号页在2号页后第1个就会被访问,1号页在2号页后第10个会被访问,7号页在2号页后第14个会被访问,7号页在已经装⼊内存的作业中是未来最长时间不会被访问的,所以换出7号页)。
3.后⾯依次类推。
2.2 先进先出算法:如果发⽣缺页中断,需要换出⼀个页⾯的时候,总是选择最早进⼊内存的页⾯,即选择在内存中驻留时间最久的页⾯进⾏换出。
有点不清楚。
就是每次发⽣缺页就将最早进⼊内存的页⾯换出,然后将刚调⼊的页⾯换⼊该物理块。
2.3 最近最久未使⽤(LRU)置换算法:LRU算法是缺页中断发⽣时选择最久未使⽤的页⾯进⾏换出。
这个算法其实也很好判断。
分享⼀个⼩技巧。
内存分配了k个物理块,发⽣缺页中断将要往内存调⼊某个页⾯的时候,在该页⾯往前⾯数K个物理块最前⾯的那个就会是要换出的,因为该页⾯最长时间未被使⽤过。
页面置换算法模拟程序-附代码
目录1.问题的提出 (2)1.1关于页面置换算法模拟程序问题的产生 (2)1.2任务分析 (2)2.需求分析 (2)3.方案设计 (3)4.总体设计 (4)4.1程序N-S图 (4)4.2主要的函数 (4)4.3主要流程图及代码 (5)4.3.1 FIFO(先进先出) (5)4.3.2 LRU(最近最久未使用) (6)4.3.3 OPT(最佳置换算法) (8)4.4实现结果 (11)5.程序测试 (14)5.1设计测试数据 (14)5.2测试结果及分析 (15)摘要随着计算机的普及人们的物质生活得到了极大的满足,人们在精神生活方面同样也需要提高,所以越来越多的人进行着各种各样的学习。
操作系统是计算机教学中最重要的环节之一,也是计算机专业学生的一门重要的专业课程。
操作系统质量的好坏,直接影响整个计算机系统的性能和用户对计算机的使用。
一个精心设计的操作系统能极扩充计算机系统的功能,充分发挥系统中各种设备的使用效率,提高系统工作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理,容比较繁琐,具有很强的实践性。
要学好这门课程,必须把理论与实践紧密结合,才能取得较好的学习效果.本课程设计是学生学习完《操作系统教程》课程后,进行的一次全面的综合训练,通过课程设计,让学生更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
熟悉页面置换算法及其实现,引入计算机系统性能评价方法的概念。
关键词:编制页面置换算法模拟程序、打印页面、FIFO页面算法、LRU页面置换算法、OPT页面置换算法。
引言1.问题的提出1.1关于页面置换算法模拟程序问题的产生在各种存储器管理方式中,有一个共同的特点,即它们都要求将一个作业全部装入存方能运行,但是有两种情况:(1)有的作业很大,不能全部装入存,致使作业无法运行;(2)有大量作业要求运行,但存容量不足以容纳所有这些作业。
而虚拟存技术正式从逻辑上扩充存容量,将会解决以上两个问题。
操作系统之页面置换算法(最佳置换OPT,先进先出FIFO,最近最久未使用LRU)
操作系统之页⾯置换算法(最佳置换OPT,先进先出FIFO,最近最久未使⽤LRU)最近学习操作系统时,实验要求实现常见的三种页⾯置换算法,博主按照书上要求试着编写,实现了案例,并记录在博客随记中,以便后续⾃⼰复习并也给需要的同学分享参考⼀下!⽔平有限,若有错,请悄悄告诉博主!博主好⽴即改正。
最佳置换算法(optimal replacement,OPT)是从内存中选择今后不再访问的页⾯或者在最长⼀段时间后才需要访问的页⾯进⾏淘汰。
如下例⼦:根据页⾯⾛向依次处理,得到最终的置换结果如下图表,整个页⾯缺页次数为7,缺页率为7/12=58%。
1 #include <iostream>2 #include <stdio.h>3 #include <stdlib.h>4#define N 125#define B 36using namespace std;78int pageArr[N]={1,2,3,4,1,2,5,1,2,3,4,5};//页⾯⾛向9int block[B]={0};//物理块3个,其数值是页号10 typedef struct FLAG {11int flags[B];12int counts;13 } FLAG;1415void opt(int pageArr[],int block[]);16int inBlock(int which);17int findFar(int next);18void Replace(int index,int value);19void disPlay();2021int main(void){22 cout << "begin:" <<endl;23 opt(pageArr,block);24 cout << "end!" <<endl;25return0;26 }2728void opt(int pageArr[],int block[]){29int getIndex;30for(int i=0;i<N;i++){31if(i<3){//前3页号#短缺#进队列32 block[i]=pageArr[i];33 printf("缺页:(null)-->%d\n",pageArr[i]);34 }35else {36if(i==3){37 disPlay();3839 }40if(inBlock(pageArr[i])!=-1){//下⼀个页⾯if在物理块中返回index并跳过,反-141 disPlay();4243continue;44 }45 getIndex=findFar(i+1);//从下⼀个页号,找到最远出现的页⾯,替换的下标46if(getIndex==-1){47 cout<<"error,not replace obj!"<<'\t';48 }49else{50 Replace(getIndex,pageArr[i]);//由下标找到上⼀组替换⽬标,⽤第⼆参数替换51 disPlay();5253 }54 }55 }56return;57 }5859//替换block中的物理块60void Replace(int index,int value){61 printf("缺页:%d--被替换为-->%d\n",block[index],value);62 block[index]=value;63return;64 }656667//找到最远出现的页⾯68int findFar(int next){69int index=-1;//error,默认返回不存在的索引70 FLAG myflag;71 myflag.flags[0]=0;72 myflag.flags[1]=0;73 myflag.flags[2]=0;74 myflag.counts=0;75int stop = N-next;76while(stop--){77 index=inBlock(pageArr[next++]);78if(index!=-1){79 myflag.flags[index]=1;80 myflag.counts++;83break;84 }85 }86for(index=0;index<B;index++){87if(myflag.flags[index]==0)88break;89 }90return index;91 }929394//下⼀个页⾯if在物理块中返回index,反-195int inBlock(int which){96//int i=0;97//while(i<B)98// if(block[i++]==which)99// return i-1;100for(int i=0;i<B;i++){101if(block[i]==which)102return i;103 }104return -1;105 }106107//打印⼀元组108void disPlay(){109int i=0;110while(i<B){111 printf("%d\t",block[i++]);112 }113 printf("\n");114return;115 }上⾯是博主使⽤C++(基本是C语法)编写的代码,运⾏结果如下://////////////////////////////////////////////////////////////////////////begin:缺页:(null)-->1缺页:(null)-->2缺页:(null)-->31 2 3缺页:3--被替换为-->41 2 41 2 41 2 4缺页:4--被替换为-->51 2 51 2 51 2 5缺页:1--被替换为-->33 2 5缺页:3--被替换为-->44 2 54 2 5end!//////////////////////////////////////////////////////////////////////////先进先出算法:先进先出置换算法(first in first out,FIFO)是淘汰最先进⼊内存的页⾯,即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
NUR页面置换算法
NRU页面置换算法1)假设每个页面中可存放10条指令,分配给作业的内存块数为4。
2)用C语言模拟一个作业的执行过程,该作业共有320条指令,即它的地址空间为32页,目前它的所有页都还未调入内存。
在模拟过程中,如果所访问的指令已在内存,则显示其物理地址,并转下一条指令。
如果所访问的指令还未装入内存,则发生缺页,此时需记录缺页的次数,并将相应页调入内存。
如果4个内存块均已装入该作业,则需进行页面置换,最后显示其物理地址,并转下一条指令。
在所有320指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。
3)置换算法:最近最不经常使用(NRU)算法。
#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define N 4#define size 320typedef struct Page{int page_num;int flag_A; //访问位int flag_M; //修改位int read_or_write; //0表示不被修改,1表示被修改}PAGE;typedef struct Block{int block_num; //块号PAGE page; //所装页的信息struct Block *next;}BLOCK,*BLOCKLIST;typedef struct instruct{ //指令数据结构int address; //指令地址PAGE page; //对应页的信息}INSTRUCTION,*INSTRUCTIONLIST;INSTRUCTION instructions[size];//定义320个指令BLOCKLIST block_head; //块的头指针int diseffect=0; //缺页次数int blockSize=0;void Init_Instructions(){for(int i=0;i<320;i++)instructions[i].address=rand()%320;for(int k=0;k<320;k++){instructions[k].page.page_num=(int)instructions[k].address/10;instructions[k].page.flag_A=0;instructions[k].page.read_or_write=rand()%2;if(instructions[k].page.read_or_write==0)instructions[k].page.flag_M=0;else instructions[k].page.flag_M=1;}}BLOCKLIST Init_block(){BLOCKLIST head=(BLOCKLIST)malloc(sizeof(BLOCK)) ;BLOCKLIST p;for(int i=1;i<=N;i++) {if(i==1) p=head;else {p->next=(BLOCKLIST)malloc(sizeof(BLOCK));p=p->next;}p->block_num=i;p->page.page_num=-1;p->page.flag_A=0;p->page.flag_M=0;}p->next=head;return head;}void display(INSTRUCTION instructions){BLOCKLIST p=block_head;printf("The new page: (page_num==%d), (flag_M==%d), (address==%d)\n", instructions.page.page_num,instructions.page.flag_M,instructions.address);printf("block_num,page_num,flag_A,flag_M\n");do{printf(" %2d %10d%9d%8d\n",p->block_num,p->page.page_num,p->page.flag_A,p->page.flag_M);p=p->next;}while(p!=block_head);}void show_physical_address(BLOCKLIST &p,INSTRUCTION instructions){int address;printf("physical address:");address=p->block_num*1024+instructions.address%10;//页面大小为1kprintf("%d\n\n",address);}//查找四个块中是否有此页面int Find_page_in_block(INSTRUCTION instructions,BLOCKLIST &p){p=block_head;do{if(p->page.page_num==instructions.page.page_num){p->page.flag_A=1;if(p->page.flag_M==0)p->page.flag_M=instructions.page.flag_M;return 1;}p=p->next;}while(p!=block_head);return 0;}//先将四个块中装满void loadpage(PAGE page){BLOCKLIST p;p=block_head;while(p->page.page_num!=-1)p=p->next;p->page.page_num=page.page_num;p->page.flag_A=1;p->page.flag_M=page.flag_M;blockSize++;}//第一次循环扫描A=0 M=0int cscanf1(BLOCKLIST &p){p=block_head;do{if(p->page.flag_A==0 && p->page.flag_M==0)return 1;p=p->next;}while(p!=block_head);return 0;}//第二次循环扫描A=0 M=1int cscanf2(BLOCKLIST &p){p=block_head;do{ //把扫面过后的A=1,M=0 或A=1,M=1中的A置0if(p->page.flag_A==1 && (p->page.flag_M==0 || p->page.flag_M==1)){p->page.flag_A=0;p=p->next;continue;}if(p->page.flag_A==0 && p->page.flag_M==1)return 1;p=p->next;}while(p!=block_head);return 0;}//第三次扫描将所有的A置为0int cscanf3(BLOCKLIST &p){p=block_head;do{p->page.flag_A=0;p=p->next;}while(p!=block_head);return 1;}//用于换进页面void assignment(BLOCKLIST &p,INSTRUCTION instructions) {p->page.page_num=instructions.page.page_num;p->page.flag_A=1;p->page.flag_M=instructions.page.flag_M;}//NRU页面替换算法void replace_page(INSTRUCTION instructions,BLOCKLIST &p) {if(cscanf1(p)){assignment(p,instructions);}else if(cscanf2(p)){assignment(p,instructions);}else if(cscanf3(p)){if(cscanf1(p))assignment(p,instructions);else {cscanf2(p);assignment(p,instructions);}}}void main(){BLOCKLIST p;Init_Instructions();block_head=Init_block();for(int i=0;i<size;i++) {if(Find_page_in_block(instructions[i],p)){display(instructions[i]);show_physical_address(p,instructions[i]);getchar();continue;}else if(blockSize<N) {diseffect++;loadpage(instructions[i].page);}else {diseffect++;replace_page(instructions[i],p);}display(instructions[i]);if(diseffect>4)show_physical_address(p,instructions[i]);getchar();}printf("NRU %f\n",(float)diseffect/size);getchar();getchar();getchar();}。
6.3页面置换1.页面置换的发生时机如果增加多道程序运行,就会过度
6.3页面置换1. 页面置换的发生时机如果增加多道程序运行,就会过度分配(over-allocating)内存。
例如运行6个进程,且每个进程有10页大小但事实上只使用其中的5页,那么就获得了更高的CPU利用率和吞吐量,且有10帧可作备用。
然而,每个进程有可能会突然试图使用其所有的10页,从而产生共60帧的总需求,而实际物理内存只有40帧可用。
再者,还需要考虑到内存不是仅用于保存程序的页面。
I/O 缓存也需使用大量的内存。
这种使用会增加内存分配算法的压力。
在I/O缓存和程序页面之间平衡内存的分配是个棘手问题。
有的系统为I/O 缓存分配了一定比例的内存,而另一些系统则允许用户进程和I/O 与系统竞争使用所有系统内存。
内存的过度分配会导致以下问题:当一个用户进程执行时,发生一个缺页中断。
此时操作系统会确定所需页在磁盘上的位置,但是却发现空闲帧列表上并没有空闲帧,所有内存都正在使用(见图6.8) 。
图6.8 需要页置换的情况这时操作系统会有若干选择。
它可以终止用户进程。
然而,按需调页是操作系统试图改善计算机系统的使用率和吞吐量的技术。
用户并不关心其进程是否运行在调页系统上:调页对用户而言应是透明的。
因此,这种选项并不是最佳选择。
操作系统也可以交换出一个进程,以释放其所有帧,并降低多道程序的级别。
这种选择在有些环境下是好的,但更为常用的解决方法是页面置换(page replacement)。
在进程运行过程中,如果发生缺页,而此时内存中又无空闲块时,为了保证进程能正常运行,需要从内存中调出一页程序或数据送到磁盘的对换区。
这个操作叫做页面置换。
决定将哪个页面调出必须根据页面置换算法(replacement policy)来确定。
目标一般是将那些以后不再被访问或在较长时间内不会再被访问的页调出。
置换算法通常会在局部性原理指导下依据历史统计数据进行预测。
2. 基本页置换页置换采用如下方法。
如果没有空闲帧,那么就查找当前未使用的帧,并将其释放。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
return -1; }
int Max(Pro *page1)//寻找最近最长未使用的页面
{
Pro *page=new Pro[M];
page=page1;
int e=page[0].time,i=0;
while(i<M) 面
//找出离现在时间最长的页
{
if(e<page[i].time) e=page[i].time;
2.最近最久未使用算法:LRU 算法的提出,是基于这样一个事实: 在前面几条指令中使用频繁的页面很可能在后面的几条指令中 频繁使用。反过来说,已经很久没有使用的页面很可能在未来较 长的一段时间内不会被用到。这个,就是著名的局部性原理—— 比内存速度还要快的 cache,也是基于同样的原理运行的。因此, 我们只需要在每次调换时,找到最少使用的那个页面调出内存。 这就是 LRU 算法的全部内容。
if(t>=0)//如果已在内存块中
{
page[t].time=0;//把与它相同的内存块的时间置 0
for(a=0;a<M;a++)
if(a!=t)page[a].time++;//其它的时间加 1
cout<<p[i].num<<" ";
cout<<"不缺页"<<endl;
}
else
//如果不在内存块中《操作源自统》实验报告题目:页面置换算法 班级:网络工程 姓名:朱锦涛 学号:E31314037
一、实验目的
用代码实现页面置换算法,通过代码的具体实现,加深对两 个页面置换算法:先进先出页面置换算法和最近最久未使用算法 的核心的理解。
二、实验原理
1.先进先出页面置换算法:地址映射过程中,若在页面中发现所 要访问的页面不再内存中,则产生缺页中断。当发生缺页中断时 操作系统必须在内存选择一个页面将其移出内存,以便为即将调 入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换 算法。最简单的页面置换算法是先入先出(FIFO)法。
{
n++;
//缺页次数加 1
赋值给 t
t=Max(page);
//返回最近最久未使用的块号
page[t].num=p[i].num;
//进行替换
置为 0
page[t].time=0;
//替换后时间
cout<<p[i].num<<" ";
print(page);
for(a=0;a<M;a++)
if(a!=t)
间加 1
page[a].time++;
//其它的时
}
i++;
}
cout<<"缺页次数:"<<n<<" "<<n/20<<endl;
缺页率:
}
}while(c==1||c==2);
return 0; } 实验结果: FIFO 置换算法:
LRU 置换算法:
四.实验小结
本次试验,使用顺序表来存储包括内存页面和页面号引用串, struct Pro{int num,time;};其中 num 表示页面号,页面号引用 串用随机数循环 20 次来初始化 20 个页面号,同时物理块号可由 用户自己在 3~5 之间选择,初始化页面号全为 0。Time 为该页面 在内存的时间,这只在 LRU 算法有使用到。第一个页面进入物理 块时初始化为 0,以后每有新页面过来询问时,不管有没有替换 内存中的页面,都将其值加一。 当新页面进来时,若内存中有 该页面号,则将该块号重新置为 0,内存中其他页面的时间+1, 若没有该页面号,则替换内存中页面时间最长的。
cout<<" "<<endl;
FIFO 算法页面置换情况
cout<<endl;
cout<<" ****************************************** "<<endl;
while(i<20)
{
if(Search(p[i].num,page)>=0) //当前页面在内存中
Pro *page=new Pro[M];//动态结构体数组 do{
for(int i=0;i<M;i++)//初试化页面基本情况 {
page[i].num=0; page[i].time=20-1-i; }
cout<<"1:FIFO 页面置换"<<endl; cout<<"2:LRU 页面置换"<<endl;
cout<<endl;
cout<<" "<<endl;
LRU 算法页面置换情况如下:
cout<<endl;
cout<<" ****************************************** "<<endl;
while(i < 20) {
int a;
t=Search(p[i].num,page);
void print(Pro *page1)//打印当前的页面 {
Pro *page=new Pro[M]; page=page1; for(int i=0;i<M;i++) cout<<page[i].num<<" "; cout<<endl; } int Search(int e,Pro *page1 )//寻找内存块中与 e 相同的 块号 { Pro *page=new Pro[M]; page=page1; for(int i=0;i<M;i++) //遍历内存 if(e==page[i].num)
i++;
}
for( i=0;i<M;i++)if(e==page[i].time)return i;//找到 离现在时间最长的页面返回其块号
return -1; }
int Count(Pro *page1,int i,int t,Pro p[L])//记录当前内存 块中页面离下次使用间隔长度 {
Pro *page=new Pro[M]; page=page1;
//打印当前页面
print(page);
//下一个内存块
t++;
个页面
i++;
//指向下一
}
}
}
cout<<"缺页次数:"<<n<<" "<<n/20<<endl;
缺页率:
}
if(c==2)//LRU 页面置换
{
n=0;
cout<<" ****************************************** "<<endl;
int count=0; for(int j=i;j<L;j++) {
if(page[t].num==p[j].num )break;//当前页面再次 被访问时循环结束
else count++;//否则 count+1 } return count;//返回 count 的值
}
int main() {
p[i].time=0;
cout<<p[i].num<<" "; } cout<<endl;
cout<<"请输入可用内存页面数 m(3~5): "; do { cin>>M; if(M>5||M<3) cout<<"内存块 m 须在 3~5 之间,请重新输入 m: ";
else break; }while(1);
cout<<"按其它键结束程序;"<<endl; cin>>c; system("cls"); //清屏 if(c==1)//FIFO 页面置换 {
n=0;
cout<<" ****************************************** "<<endl;
cout<<endl;
如下:
int c,i; int t=0; float n=0; Pro p[L]; //20 个结构体
srand(time(NULL));//随机数发生器 cout<<"输出随机数: "; for(i=0;i<20;i++) //20 个随机数
{ p[i].num=rand( )%10+1;//产生 1 到 10 之间的随即数放到数 组p中
通过本次试验,我加深了对两个页面置换算法:先进先出页面 置换算法和最近最久未使用算法的核心的理解。
三、实验内容 源程序: #include<iostream.h> #include <stdlib.h> #include <time.h> #include <stdio.h>
#define L 20//页面走向长度最大为 20