页面置换算法实验报告
页面置换算法实验报告_4
页面置换算法实验报告院系:****************学院班级:***********姓名:***学号:************一、实验题目: 页面置换算法二. 实验目的:1.用C语言编写OPT、FIFO、LRU三种置换算法。
2.熟悉内存分页管理策略。
3.了解页面置换的算法。
4.掌握一般常用的调度算法。
5.根据方案使算法得以模拟实现。
6.锻炼知识的运用能力和实践能力。
三. 实验内容及要求:设计一个虚拟存储区和内存工作区, 编程序演示下述算法的具体实现过程, 并计算访问命中率:要求设计主界面以灵活选择某算法, 且以下算法都要实现1) 最佳置换算法(OPT): 将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO):淘汰最先进入内存的页面, 即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU): 淘汰最近最久未被使用的页面。
四、实验结果初始化结果1, 先进先出(FIFO)算法实验结果:2, 最近最久未使用(LRU)算法实验结果: 3, 最佳使用法(OPT)实验结果:五、实验总结选择置换算法, 先输入所有页面号, 为系统分配物理块, 依次进行置换:OPT基本思想:是用一维数组page[]存储页面号序列, memery[]是存储装入物理块中的页面。
数组next[]记录物理块中对应页面的最后访问时间。
每当发生缺页时, 就从物理块中找出最后访问时间最大的页面, 调出该页, 换入所缺的页面。
若物理块中的页面都不再使用, 则每次都置换物理块中第一个位置的页面。
FIFO基本思想:是用队列存储内存中的页面, 队列的特点是先进先出, 与该算法是一致的, 所以每当发生缺页时, 就从队头删除一页, 而从队尾加入缺页。
或者借助辅助数组time[]记录物理块中对应页面的进入时间, 每次需要置换时换出进入时间最小的页面。
LRU基本思想:是用一维数组page[]存储页面号序列, memery[]是存储装入物理块中的页面。
页面置换算法实验报告
页面置换算法实验报告
一、实验内容
本次实验主要围绕页面置换算法进行,以实验课本的实例介绍,采用FIFO页面置换算法对后面提到的参数进行置换,最终得出页面置换的结果和比较所得结果。
二、实验步骤
(一) 熟悉FIFO算法
首先是要了解FIFO页面置换算法,FIFO全称(First In First Out),按页面进入内存的顺序来替换相应内存页面,先进先出,将先进入内存的页面先替换出去。
(二) 阅读实验课本
在阅读实验课本之前要先熟悉实验书上所介绍的FIFO算法,然后在实验书上找出需要做的实验,并对实验环境和表格进行观察,掌握实验的基本内容。
(三) 开始页面置换
在开始实验之前,熟悉实验环境,根据实验书上的参数,首先模拟进程分配内存,根据FIFO算法去进行计算,根据上表中的参数去比较,最后得出最终结果。
(四) 在本次实验的补充
这次实验中,可以把FIFO的概念应用到实际应用中,也可以模拟不同情况,例如改变页面的大小,观察不同页面置换算法的结果,实验出最合适的结果。
三、实验结论
本次实验是为了了解FIFO页面置换算法,实验出最终的结果,最后得出页面置换的结果及比较结果。
页面置换算法模拟实验报告
if(block[i].timer >= block[pos].timer)
pos = i;//找到应予置换页面,返回BLOCK中位置
return pos;
}
void PRA::display(void)
{
for(int i=0; i<Bsize; i++)
}
}
int PRA::findSpace(void)
{
for(int i=0; i<Bsize; i++)
if(block[i].content == -1)
return i;//找到空闲内存,返回BLOCK中位置
return -1;
}
int PRA::findExist(int curpage)
{
if(exist != -1)
{
cout<<"不缺页"<<endl;
}
else
{
space = findSpace();
if(space != -1)
{
block[space] = page[i];
display();
}
else
{
for(int k=0; k<Bsize; k++)
for(int j=i; j<Psize; j++)
int findReplace(void); //查找应予置换的页面
void display(void); //显示
void FIFO(void);//FIFO算法
页面置换 操作系统实验报告
实验二页面置换算法实现一、实验目的(1)了解内存分页管理策略(2)掌握调页策略(3)掌握一般常用的调度算法(4)学会各种存储分配算法的实现方法。
(5)了解页面大小和内存实际容量对命中率的影响。
二、实验内容采用页式分配存储方案,通过分别计算不同算法的命中率来比较算法的优劣,同时也考虑页面大小及内存实际容量对命中率的影响,设计一个虚拟存储区和内存工作区,并使用下述算法来模拟实现页面的置换:1. 先进先出的算法(FIFO)2. 最近最久未使用算法(LRU)3. 最佳置换算法(OPT)实验分析在进程运行过程中,若其所访问的页面不存在内存而需要把它们调入内存,但内存已无空闲时,为了保证该进程能够正常运行,系统必须从内存中调出一页程序或数据送磁盘的对换区中。
但应调出哪个页面,需根据一定的算法来确定,算法的好坏,直接影响到系统的性能。
一个好的页面置换算法,应该有较低的页面更换频率。
2.1 先进先出(FIFO )页面置换算法当需要访问一个新的页面时,首先查看物理块中是否就有这个页面,若要查看的页面物理块中就有,则直接显示,不需要替换页面;如果要查看的页面物理块中没有,就需要寻找空闲物理块放入,若存在有空闲物理块,则将页面放入;若没有空闲物理块,则替换页面。
并将物理块中所有页面 timer++。
2.2 最近久未使用 (LRU) 置换算法的思路最近久未使用置换算法的替换规则,是根据页面调入内存后的使用情况来进行决策的。
该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间,当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。
2.3 最佳(OPT)置换算法的思路其所选择的被淘汰的页面,是以后不使用的,或者是在未来时间内不再被访问的页面,采用最佳算法,通常可保证获得最低的缺页率。
三、实验流程3.1 系统功能图图3-1 系统功能图3.2 算法流程图1)先进先出(FIFO )页面置换算法流程图图3-2 先进先出页面置换算法流程图2)最近久未使用 (LRU) 置换算法图3-3 最近久未使用置换算法流程图3)最佳( OPT )置换算法图3-4 最佳置换算法流程图四、源程序#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20 //页面长度最大为20int M; //内存块struct Pro//定义一个结构体{int num,time;};Input(int m,Pro p[L])//打印页面走向状态{cout<<"请输入页面长度(10~20):";do{cin>>m;if(m>20||m<10){ cout<<endl;cout<<"页面长度必须在10~20之间"<<endl<<endl;cout<<"请重新输入L:";}else break;}while(1);int i,j;j=time(NULL);//取时钟时间srand(j);//以时钟时间j为种子,初始化随机数发生器cout<<endl;cout<<"输出随机数: "<<endl;cout<<endl;for(i=0;i<m;i++){p[i].num=rand( )%10;//产生0到9之间的随机数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl<<endl;return m;}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)return i;//返回i值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;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;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(){int c;int m=0,t=0;float n=0;Pro p[L];m=Input(m,p);//调用input函数,返回m值cout<<"请输入分配的物理块m(2~6): ";cout<<endl<<endl;do{cin>>M;if(M>6||M<2){ cout<<endl;cout<<"物理块m必须在2~6之间"<<endl<<endl;cout<<"请重新输入m: ";}else break;}while(1);Pro *page=new Pro[M];do{for(int i=0;i<M;i++)//初始化页面基本情况{ page[i].num=0;page[i].time=m-1-i;}i=0;cout<<endl;cout<<"1:FIFO页面置换2:LRU页面置换"<<endl;cout<<"3:OPT页面置换4:退出"<<endl;cout<<"请选择页面置换算法:"<<endl;cin>>c;if(c==1)//FIFO页面置换{n=0;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0) //当前页面在内存中{cout<<p[i].num<<" "; //输出当前页p[i].numcout<<"不缺页"<<endl;i++; //i加1}else //当前页不在内存中{if(t==M)t=0;else{n++; //缺页次数加1page[t].num=p[i].num; //把当前页面放入内存中cout<<p[i].num<<" ";print(page); //打印当前页面t++; //下一个内存块i++; //指向下一个页面}}}cout<<endl;cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl<<endl; }if(c==2)//LRU页面置换{n=0;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){int a;t=Search(p[i].num,page);if(t>=0)//如果已在内存块中{ page[t].time=0;//把与它相同的内存块的时间置0 for(a=0;a<M;a++)if(a!=t)page[a].time++;//其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else //如果不在内存块中{n++; //缺页次数加1t=Max(page); //返回最近最久未使用的块号赋值给tpage[t].num=p[i].num; //进行替换page[t].time=0; //替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0;a<M;a++)if(a!=t) page[a].time++; //其它的时间加1 }i++;}cout<<endl;cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl<<endl; }if(c==3)//OPT页面置换{n=0;cout<<" OPT算法置换情况如下:"<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0)//如果已在内存块中{cout<<p[i].num<<" ";cout<<"不缺页"<<endl;i++;}else//如果不在内存块中{int a=0;for(t=0;t<M;t++)if(page[t].num==0)a++;//记录空的内存块数if(a!=0) //有空内存{int q=M;for(t=0;t<M;t++)if(page[t].num==0&&q>t)q=t;//把空内存块中块号最小的找出来page[q].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}else{int temp=0,s;for(t=0;t<M;t++)//寻找内存块中下次使用离现在最久的页面if(temp<Count(page,i,t,p)){temp=Count(page,i,t,p);s=t; }//把找到的块号赋给spage[s].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}}}cout<<endl;cout<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl<<endl;}if(c == 4) break;}while(c==1||c==2||c==3);return 0;}五、实验结果5.1 程序主界面运行程序后,将会提示用户输入页面长度,长度在10到20之间。
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法,并实现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算法的实现需要维护一个记录页面使用时间的链表或队列。
操作系统实验五报告 页面置换算法
四、程序流程图
(1)程序流程
父进程: ①随机产生内存访问页面序列,存于数组 Acess_Series[total_instruction]中 ②数据结构 M_Frame 的初始化 ③分别创建两个子进程。 ④等待子进程执行结束,退出。 子进程: ①读序列 Acess_Series[],若序列中已无下一个元素,转 5) ;否则,取出页面序列中的下 一个元素作为下次要访问的页面; ②如果待访问的页面在内存中 (即在 M_Frame[]中找到) , 则不发生缺页, 命中率加 1, 转① , 注意 LRU 算法中要调整该页在数组中的位置; ③否则就 要将这页调入 内存,通过修 改相应的数据 结构 M_Frame[]反映出 来。首先看 M_Frame[]中有无空闲页面,如果有,将待访问页面的页号以及被占用的信息写入数组中适 当位置,并统计缺页情况,缺页次数 diseffect 加 1,返回① ; ④如果 M_Frame[]中的所有页面均被占满,则淘汰 M_Frame[0],装入待访问页,重新调整各
页面在数组中的位置。并统计缺页情况,缺页次数 diseffect 加 1,返回① ; ⑤所有页面均已访问完成,统计命中率或缺页率;
(2)程序流程图
五、数据结构
数组 Acess_Series[]中存放内存页面访问的序列:int Acess_Series[10]; 结构数组 M_Frame[]记录为进程分配的内存页面的使用情况,在 M_Frame[]中 page_no 记录页面号,flag 记录页面是否缺页。 struct one_frame { int page_no; char flag; };
程之间的关系及其并发执行。 (2)理解内存页面调度的机理。 (3)掌握页面置换算法及其实现方法。 (4)培养综合运用所学知识的能力。 (5)页面置换算法是虚拟存储管理实现的关键,通过本次试验理解内存页面调度的机制, 在模拟实现 FIFO、LRU 等经典页面置换算法的基础上,理解虚拟存储实现的过程。 (6)将不同的置换算法放在不同的子进程中加以模拟,培养综合运用所学知识的能力。
页面置换实验报告
计算机科学系实验报告书课程名:《操作系统》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求1.目的:请求页式虚存管理是常用的虚拟存储管理方案之一。
通过请求页式虚存管理中对页面置换算法的模拟,有助于理解虚拟存储技术的特点,并加深对请求页式虚存管理的页面调度算法的理解。
2.要求:本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。
其中虚页的个数可以事先给定(例如10个),对这些虚页访问的页地址流(其长度可以事先给定,例如20次虚页访问)可以由程序随机产生,也可以事先保存在文件中。
要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。
程序应允许通过为该进程分配不同的实页数,来比较两种置换算法的稳定性。
二、实验说明1.设计中虚页和实页的表示本设计利用C语言的结构体来描述虚页和实页的结构。
在虚页结构中,pn代表虚页号,因为共10个虚页,所以pn的取值范围是0—9。
pfn 代表实页号,当一虚页未装入实页时,此项值为-1;当该虚页已装入某一实页时,此项值为所装入的实页的实页号pfn。
time项在FIFO算法中不使用,在LRU中用来存放对该虚页的最近访问时间。
在实页结构中中,pn代表虚页号,表示pn所代表的虚页目前正放在此实页中。
pfn代表实页号,取值范围(0—n-1)由动态指派的实页数n所决定。
next是一个指向实页结构体的指针,用于多个实页以链表形式组织起来,关于实页链表的组织详见下面第4点。
2.关于缺页次数的统计为计算命中率,需要统计在20次的虚页访问中命中的次数。
为此,程序应设置一个计数器count,来统计虚页命中发生的次数。
每当所访问的虚页的pfn项值不为-1,表示此虚页已被装入某实页内,此虚页被命中,count加1。
最终命中率=count/20*100%。
3.LRU算法中“最近最久未用”页面的确定为了能找到“最近最久未用”的虚页面,程序中可引入一个时间计数器countime,每当要访问一个虚页面时,countime的值加1,然后将所要访问的虚页的time项值设置为增值后的当前countime值,表示该虚页的最后一次被访问时间。
页面置换算法实验报告
一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟存储技术的特点,掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程,并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区,设计下述算法并计算访问命中率。
1、最佳淘汰算法(OPT)2、先进先出的算法(FIFO)3、最近最久未使用算法(LRU)4、简单时钟(钟表)算法(CLOCK)命中率=1-页面失效次数/页地址流(序列)长度三、实验原理UNIX中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求(向CPU发出缺中断),由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页,核心配置了四种数据结构:页表、页帧(框)号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号,中断处理程序先保存现场,分析中断原因,转入缺页中断处理程序。
该程序通过查找页表,得到该页所在外存的物理块号。
如果此时内存未满,能容纳新页,则启动磁盘I/O将所缺之页调入内存,然后修改页表。
如果内存已满,则须按某种置换算法从内存中选出一页准备换出,是否重新写盘由页表的修改位决定,然后将缺页调入,修改页表。
利用修改后的页表,去形成所要访问数据的物理地址,再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列,然后将指令序列变换成相应的页地址流,并针对不同的算法计算出相应的命中率。
(1)通过随机数产生一个指令序列,共320条指令。
指令的地址按下述原则生成:A:50%的指令是顺序执行的B:25%的指令是均匀分布在前地址部分C:25%的指令是均匀分布在后地址部分具体的实施方法是:A:在[0,319]的指令地址之间随机选取一起点mB:顺序执行一条指令,即执行地址为m+1的指令C:在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m’D:顺序执行一条指令,其地址为m’+1E:在后地址[m’+2,319]中随机选取一条指令并执行F:重复步骤A-E,直到320次指令(2)将指令序列变换为页地址流设:页面大小为1K;用户内存(页帧)容量为4页~32页;用户虚存容量为32K。
页面置换实习报告
页面置换实习报告在计算机系统中,页面置换是一项至关重要的内存管理技术。
为了更深入地理解和掌握这一技术,我进行了相关的实习。
一、实习目的页面置换的目的在于当内存空间不足时,将一些暂时不使用的页面换出到外存,以腾出空间给当前需要的页面。
通过这次实习,我希望能够:1、深入理解页面置换算法的工作原理和特点。
2、掌握不同算法在实际应用中的性能差异。
3、提高自己的编程能力和问题解决能力。
二、实习环境本次实习使用的编程语言为 Python,开发环境为 PyCharm。
操作系统为 Windows 10。
三、页面置换算法简介1、先进先出(FIFO)算法FIFO 算法是最简单的页面置换算法之一。
它总是淘汰最先进入内存的页面。
这种算法实现简单,但可能会导致一些频繁使用的页面被过早置换出去。
2、最近最久未使用(LRU)算法LRU 算法根据页面最近的使用情况来决定置换。
即淘汰最长时间未被使用的页面。
该算法性能较好,但实现相对复杂,需要记录页面的使用时间。
3、最优置换(OPT)算法OPT 算法是一种理论上的最优算法,它淘汰未来最长时间内不会被使用的页面。
然而,由于在实际中无法准确预测未来的页面使用情况,所以该算法更多地用于理论分析。
四、实习过程1、算法实现首先,我使用 Python 实现了上述三种页面置换算法。
在实现过程中,我使用了数据结构来存储页面的相关信息,并通过模拟页面的调入和调出过程来计算缺页次数。
以 FIFO 算法为例,我使用一个队列来存储页面进入内存的顺序。
当需要置换页面时,将队首的页面淘汰。
2、性能测试为了比较不同算法的性能,我设计了一系列的测试用例。
测试用例包括不同的页面访问序列和不同的内存大小。
通过运行测试用例,我记录了每种算法在不同情况下的缺页次数。
3、结果分析对测试结果进行分析是实习的重要环节。
我发现,在不同的页面访问模式下,不同算法的表现差异较大。
例如,当页面访问序列具有局部性时,LRU 算法的表现通常优于FIFO 算法。
实验报告页面置换算法(c语言实现)
实验三页面置换算法#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20int M; struct Proi nt num,time;};I nput(int m,Pro p[L]){i nt i,j,c;c out<<"请输入实际页面走向长度L(15<=L<=20):";d o{c in>>m;i f(m>20||m<15)cout<<"实际页面长度须在15~20之间;请重新输入L:";e lse break;}while(1);j=time(NULL);s rand(j);c out<<"输出随机数: ";f or(i=0;i<m;i++){p[i].num=rand( )%10+1;p[i].time=0;c out<<p[i].num<<" ";}c out<<endl;r eturn m;}v oid print(Pro *page1){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++)i f(page[i].num==-1)c out<<" ";e lsec out<<page[i].num<<" ";c out<<"√"<<endl;}i nt Search(int e,Pro *page1 ){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++) if(e==page[i].num) return i; r eturn -1;}i nt Max(Pro *page1){}i nt Count(Pro *page1,int i,int t,Pro p[L]){}i nt main(){i nt c;i nt m=0,t=0;f loat n=0;P ro p[L];c out<<"********************************************* "<<endl;c out<<" * 页式存储管理*"<<endl;c out<<"********************************************* "<<endl;c out<<"请输入可用内存页面数m(3~5): ";d o{c in>>M;i f(M>5||M<3)c out<<"内存块M须在3~5之间,请重新输入M:";e lse break;}while(1);m=Input(m,p);P ro *page=new Pro[M];c out<<"^-^欢迎进入操作系统界面^-^"<<endl;c out<<"1:FIFO页面置换"<<endl;c out<<"2:LRU页面置换"<<endl;c out<<"3:OPT页面置换"<<endl;c out<<"4:退出"<<endl;d o{c out<<"按1~4键操作:"<<endl;c in>>c;s ystem("cls");f or(int i=0;i<M;i++){p age[i].num=-1;p age[i].time=m-1-i;}i=0;i f(c==1){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0) {cout<<p[i].num<<" "; p[i].numc out<<"不缺页"<<endl;i++;}e lse {i f(t==M)t=0;e lse{n++;p age[t].num=p[i].num;c out<<p[i].num<<" ";p rint(page);t++;i++;}}}c out<<"缺页次数:"<<n<<" }i f(c==2){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" LRU算法页面置换情况如下: "<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i nt a;t=Search(p[i].num,page);i f(t>=0){p age[t].time=0;for(a=0;a<M;a++)i f(a!=t)page[a].time++;cout<<p[i].num<<" ";c out<<"不缺页"<<endl;}e lse{n++; t=Max(page);page[t].num=p[i].num; page[t].time=0;cout<<p[i].num<<" ";p rint(page);f or(a=0;a<M;a++)i f(a!=t)page[a].time++;}i++;}c out<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}i f(c==3){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" OPT算法置换情况如下:"<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0){c out<<p[i].num<<" ";c out<<"不缺页"<<endl;i++;}e lse{i nt a=0;f or(t=0;t<M;t++)i f(page[t].num==0)a++;if(a!=0) {i nt q=M;f or(t=0;t<M;t++)i f(page[t].num==0&&q>t)q=t;p age[q].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}e lse{i nt temp=0,s;f or(t=0;t<M;t++)i f(temp<Count(page,i,t,p)){t emp=Count(page,i,t,p);s=t;}page[s].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}}}c out<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}i f(c==4){c out<<" ^-^再见!^-^ "<<endl;}}while(c==1||c==2||c==3||c==4);r eturn 0;}结果:完成相关实验并且获得预期结果.。
操作系统页面置换算法实验报告
学生实验报告姓名:年级专业班级学号成绩【实验结果或总结】(对实验结果进行相应分析,或总结实验的心得体会,并提出实验的改进意见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 年月日【备注】。
页面置换算法实验报告
页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中,页面置换算法是一种重要的内存管理策略。
当物理内存不足以容纳所有需要运行的进程时,操作系统需要根据一定的算法将部分页面从内存中换出,以便为新的页面腾出空间。
本实验旨在通过实际操作,对比不同的页面置换算法在不同场景下的性能表现。
二、实验背景在计算机系统中,每个进程都有自己的虚拟内存空间,而物理内存空间是有限的。
当进程需要访问某个页面时,如果该页面不在物理内存中,就会发生缺页中断,操作系统需要根据页面置换算法选择一个页面将其换出,然后将需要访问的页面换入。
常见的页面置换算法有先进先出(FIFO)、最近最久未使用(LRU)、时钟(Clock)等。
三、实验目的本实验旨在通过模拟不同的页面置换算法,比较它们在不同情况下的缺页率和效率。
通过实验结果,评估各个算法在不同场景下的优劣,为实际系统的内存管理提供参考。
四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较:FIFO、LRU和Clock。
我们使用C++编程语言模拟了一个简单的内存管理系统,并通过产生不同的访存序列来模拟不同的场景。
实验中,我们设置了不同的物理内存大小,访存序列长度和页面大小,以模拟不同的系统环境。
五、实验结果与分析在实验中,我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。
通过统计不同算法的缺页率和运行时间,得出以下结论:1. FIFO算法FIFO算法是最简单的页面置换算法,它按照页面进入内存的顺序进行置换。
实验结果表明,FIFO算法在缺页率方面表现一般,特别是在访存序列具有局部性的情况下,其性能明显下降。
这是因为FIFO算法无法区分不同页面的重要性,可能会将经常使用的页面换出,导致缺页率升高。
2. LRU算法LRU算法是一种基于页面访问时间的置换算法,它认为最近被访问的页面很可能在未来会被再次访问。
实验结果表明,LRU算法在缺页率方面表现较好,特别是在访存序列具有较强的局部性时,其性能明显优于FIFO算法。
页面置换算法实验报告
页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程,了解不同算法的优缺点,掌握算法的实现方法,以及对算法的性能进行评估。
二、实验原理页面置换算法是操作系统中的一个重要概念,它是为了解决内存不足的问题而产生的。
当系统中的进程需要使用内存时,如果内存已经被占满,就需要将一些页面从内存中置换出去,以便为新的页面腾出空间。
页面置换算法就是用来决定哪些页面应该被置换出去的算法。
常见的页面置换算法有以下几种:1. 最佳置换算法(OPT)最佳置换算法是一种理论上的最优算法,它总是选择最长时间内不会被访问的页面进行置换。
但是,由于无法预测未来的页面访问情况,因此最佳置换算法无法在实际中使用。
2. 先进先出置换算法(FIFO)先进先出置换算法是一种简单的置换算法,它总是选择最先进入内存的页面进行置换。
但是,这种算法容易出现“抖动”现象,即频繁地将页面置换出去,然后再将其置换回来。
3. 最近最久未使用置换算法(LRU)最近最久未使用置换算法是一种比较常用的置换算法,它总是选择最长时间未被访问的页面进行置换。
这种算法可以避免“抖动”现象,但是实现起来比较复杂。
4. 时钟置换算法(Clock)时钟置换算法是一种改进的FIFO算法,它通过维护一个环形链表来实现页面置换。
当需要置换页面时,算法会从当前位置开始扫描链表,如果找到一个未被访问的页面,则将其置换出去。
如果扫描一圈后都没有找到未被访问的页面,则将当前位置的页面置换出去。
三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序,可以模拟上述四种算法的过程,并输出算法的性能指标。
程序的主要流程如下:1. 读取输入文件,获取页面访问序列和内存大小等参数。
2. 根据选择的算法,初始化相应的数据结构。
3. 遍历页面访问序列,模拟页面置换的过程。
4. 输出算法的性能指标,包括缺页率、页面置换次数等。
下面分别介绍四种算法的实现方法。
1. 最佳置换算法(OPT)最佳置换算法需要预测未来的页面访问情况,因此需要遍历整个页面访问序列,找到最长时间内不会被访问的页面。
页面置换算法实验报告实验心得
页面置换算法实验报告实验心得
1. 实验背景
页面置换算法是操作系统中的重要概念,主要用于解决内存不足的问题。
它通过将当前不需要的页面从内存中移出,以腾出空间给即将到来的页面。
本次实验主要是通过模拟不同页面置换算法的过程,来更好地了解和掌握这些算法的实现原理及其优缺点。
2. 实验过程
本次实验中,我们使用了三种页面置换算法,分别是最优页面置换算法(OPT)、先进先出页面置换算法(FIFO)和最近最久未使用页面置换算法(LRU)。
在模拟的过程中,我们需要先给每个页面设置一个访问时间,然后根据不同算法的实现原理来决定哪个页面被置换出去。
通过实验,我们发现不同的算法在不同情况下的效果也会不同。
比如,当页面访问时间相对均匀分布时,FIFO算法的效果会比较好,而当页面访问时间存在一定规律性时,LRU算法的效果则会更好。
而OPT 算法则需要未来时间的信息,一般情况下难以实现,但是在某些特殊情况下,它也可以发挥出比较好的效果。
3. 实验心得
通过本次实验,我更深入地了解了页面置换算法的实现原理,学会了如何根据不同算法的特点来选择合适的算法来解决内存不足的问题。
在实验过程中,我也学会了如何使用Python编程语言来模拟不同算法的过程,提高了我的编程能力。
通过不断地调试和实验,我还学会了如何发现问题和解决问题的方法,这对我今后的学习和工作都大有裨益。
总之,本次实验不仅加深了我对操作系统中重要概念的理解,也提高了我的编程和分析问题的能力,让我对未来的学习和工作充满信心和热情。
页面置换算法实验报告
页面置换算法实验报告背景页面置换算法是计算机操作系统中的一个重要概念,它用于解决操作系统需要共享有限的物理内存资源给多个进程使用的问题。
在操作系统中,每个进程都有自己的虚拟地址空间,但实际的物理内存资源是有限的。
当物理内存不足时,操作系统需要根据一定的策略将一部分进程暂时从内存中移出,以便为其他进程让出空间,而后再从外存中将其重新加载到内存中。
这个过程就是页面置换。
页面置换算法有很多种,比如最优页面置换算法(Optimal)、先进先出页面置换算法(FIFO)、最近最久未使用页面置换算法(LRU)等等。
不同的算法对于系统性能、响应时间等指标有着不同的影响,因此在实际应用中需要选择合适的算法来平衡各种需求。
本实验旨在通过模拟页面置换算法,并对不同算法进行性能分析,以便了解各种算法的优缺点,为实际系统的选择提供依据。
分析在实验中,我们选择了三种常用的页面置换算法,分别是FIFO、LRU和Optimal。
下面对这三种算法进行详细的分析和说明。
先进先出页面置换算法(FIFO)FIFO算法是最简单和最直观的页面置换算法。
它按照页面进入内存的顺序来选择被淘汰的页面。
当内存不足时,选择最早进入内存的页面进行置换,即将其从内存中移出。
FIFO算法不需要进行进一步的页面访问计算,只需要维护一个页面进入内存的队列即可,因此实现起来比较简单。
然而,由于FIFO算法没有考虑页面的访问频率和重要性,所以可能会导致被频繁访问的页面被淘汰出内存,从而影响系统的性能。
最近最久未使用页面置换算法(LRU)LRU算法是一种基于”最近使用原则”的页面置换算法。
它根据页面最近被访问的时间来选择被淘汰的页面。
当内存不足时,选择最长时间未被访问的页面进行置换,即将其从内存中移出。
LRU算法需要维护一个页面访问时间的记录,以便在需要置换时能够快速找到最近最久未使用的页面。
相比于FIFO算法,LRU算法更加合理地利用了页面的访问情况,但实现起来相对复杂一些。
虚拟内存页面置换算法实训报告
虚拟内存页面置换算法实训报告1. 介绍虚拟内存页面置换算法的概念和作用- 虚拟内存是计算机操作系统中的一种技术,它允许程序访问比物理内存更大的地址空间。
- 页面置换算法是虚拟内存管理的一种重要策略,它用于在物理内存不足时将一部分页面移出物理内存,以便为新的页面腾出空间。
2. 算法分类- 最优页面置换算法(OPT):根据未来的访问情况,选择最长时间内不再被访问的页面进行置换。
- 先进先出页面置换算法(FIFO):选择最早进入物理内存的页面进行置换。
- 最近最少使用页面置换算法(LRU):选择最长时间内未被访问的页面进行置换。
- 时钟页面置换算法(CLOCK):使用一个指针指向当前页面,选择指针指向的页面进行置换。
3. 算法比较- OPT算法是最理想的页面置换算法,但实际上很难实现,因为需要预测未来的页面访问情况。
- FIFO算法简单易实现,但可能会出现“抖动”现象,即频繁地将同一页面置换出去再置换回来。
- LRU算法性能较好,但实现较为复杂,需要维护一个访问时间戳。
- CLOCK算法是对LRU算法的一种改进,实现较为简单,但在某些情况下可能会出现性能问题。
4. 实验设计- 使用C++语言实现了FIFO、LRU和CLOCK三种页面置换算法。
- 使用随机生成的页面序列进行测试,记录每种算法的缺页率和执行时间。
- 分析实验结果,比较各种算法的优缺点。
5. 实验结果- 在测试中,FIFO算法的缺页率最高,CLOCK算法的缺页率最低,LRU 算法的缺页率居中。
- 在执行时间方面,CLOCK算法最快,FIFO算法最慢,LRU算法居中。
- 综合考虑,可以根据具体的应用场景选择适合的页面置换算法。
6. 结论- 虚拟内存页面置换算法是操作系统中的重要技术,对系统性能有着重要影响。
- 不同的页面置换算法有着各自的优缺点,需要根据具体情况进行选择。
- 实验结果表明,CLOCK算法在缺页率和执行时间方面都表现较好,可以作为一种较为通用的页面置换算法。
页面置换算法实践报告
页面置换算法实践报告页面置换算法(Page Replacement Algorithm)是操作系统中用于管理虚拟内存的重要算法之一。
其目的是在有限的物理内存空间中,将进程所需的页面加载到内存中,并根据一定的策略替换掉不再被使用的页面,以提高内存利用率和系统性能。
在本次实践报告中,我将重点介绍三种常见的页面置换算法:先进先出(FIFO)、最近最久未使用(LRU)和最不经常使用(LFU)。
先进先出(FIFO)算法是最简单的页面置换算法之一。
它根据页面进入内存的先后顺序进行页面置换。
当一个页面需要被替换时,选择最早进入内存的页面进行替换。
虽然FIFO算法的实现简单,但它无法很好地反映页面的使用频率和重要性,容易发生“缺页率抖动”的问题。
缺页率抖动指的是在某些场景下,缺页率会频繁地快速上升,然后又快速下降。
最近最久未使用(LRU)算法是一种基于页面历史访问记录的页面置换算法。
它认为最近被访问过的页面是最有可能在未来被访问的,因此选择最近最久未使用的页面进行替换。
LRU算法可以较为准确地反映页面的使用频率,避免了FIFO算法的缺点。
但由于需要记录页面的访问历史,因此实现相对复杂,需要额外的开销。
最不经常使用(LFU)算法是一种基于页面使用频率的页面置换算法。
它认为使用频率最低的页面是最不重要的,因此选择最不经常使用的页面进行替换。
LFU算法可以较好地反映页面的使用频率,对于一些热点页面和冷门页面的处理较为准确。
但由于需要记录页面的使用次数,因此实现相对复杂,需要额外的开销。
根据实际情况选择合适的页面置换算法对于系统的性能影响非常重要。
一般来说,FIFO算法比较适用于缺页率较低的情况,而LRU算法则适用于需要较高精确度的场景,而LFU算法则适用于需要特别关注页面使用频率的场景。
在实践中,我们可以使用模拟算法来进行页面置换算法的实验。
通过构造不同的页面访问序列,我们可以测试不同算法的效果并进行比较。
在实验过程中,我们可以观察不同算法的缺页率、替换次数、访问延迟等指标,以评估算法的性能。
页面置换算法实验报告实验心得
页面置换算法实验报告实验心得
一、实验背景
页面置换算法是操作系统中的一个重要概念,是内存管理机制的核心内容之一。
页面置换算法是为了解决内存有限的问题,通过将不常用的页面换出,腾出空间给新的页面使用。
页面置换算法有多种,如LRU、FIFO、Clock等。
本次实验主要研究这几种置换算法的实现原理并通过编程实现。
二、实验过程
本次实验首先通过查阅相关资料了解了LRU、FIFO、Clock等页面置换算法的实现原理。
在了解了原理之后,我们通过使用Python语言编写程序来模拟这些算法的实现。
实验中,我们首先编写了一段程序来生成一个不同大小的访问页面序列,并将生成的页面序列分别输入到LRU、FIFO、Clock算法的模拟程序中,观察算法的置换效果,并通过比较不同算法的置换效果来评估各个算法的优劣。
三、实验结果
通过实验,我们观察到在不同的访问页面序列下,各个算法的置换效果都有所不同。
在某些情况下,FIFO算法的置换效果最好,而在
其他情况下,LRU算法的置换效果最佳。
同时,在一些场景下,Clock算法的置换效果也不错。
这说明不同的页面置换算法对于不同的内存使用情况有着不同的适用性。
四、实验心得
通过本次实验,我们深入了解了页面置换算法的实现原理,并通过编程实现了这些算法。
通过实验,我们发现在不同的场景下,不同的页面置换算法的效果会有所不同。
因此,在实际应用中,我们需要考虑内存使用情况,选择最适合的页面置换算法来提高内存利用率和程序性能。
同时,通过这次实验,我们也了解了Python编程的基本语法和常用库的使用方法,对我们的编程能力有了一定的提高。
页面置换算法实验总结
页面置换算法实验总结
在操作系统中,页面置换算法是为了解决内存不足的问题,当内存中的页面不足时,需要选择一些页面进行置换,将其换出到磁盘上,从而为新的页面腾出空间。
在本次实验中,我实现了三种页面置换算法,分别是FIFO(先进先出)、LRU(最近最少使用)和OPT(最佳置换)。
下面是对这三种算法的总结:
1. FIFO算法:FIFO算法是最简单的页面置换算法,它按照页面进入内存的顺序进行置换。
实验结果显示,FIFO算法在某些情况下可能会导致“抖动”现象,即不断发生页面置换,性能较差。
2. LRU算法:LRU算法是根据页面的使用历史进行置换,将最长时间没有被使用的页面置换出去。
实验结果显示,LRU算法相比于FIFO算法在减少页面抖动方面表现更好,但是实现起来较为复杂,需要维护一个访问历史记录的数据结构。
3. OPT算法:OPT算法是一种理想情况下的页面置换算法,它通过预测未来的页面访问情况来选择最佳的页面进行置换。
实验结果显示,OPT算法在减少页面抖动方面表现最好,但是实现起来较为困难,需要对未来的页面访问情况进行预测。
综上所述,不同的页面置换算法在不同的场景下有着不同的表现。
FIFO算法简单易实现,但性能较差;LRU算法在某些情况下能够较好地减少页面抖动;OPT算法在理论上是最佳的页面置换算法,但实现起来较为困难。
实际中的选择需要根据具体的应用场景
和系统需求来确定。
页面置换算法 实验报告
一个周期内访问该页面的次数,time为访问时间;pl[total_vp]为页面 结构数组,由于共有320条指令,每页可装入10条指令,因此虚页长 total_vp的值为32。
可为每个页面设置一个步长变量其初值为一足够大的数对于不在内存的页面将其值重置为零对于位于内存的页面其值重置为当前访问页面与之后首次出现该页面时两者之间的距离因此该值越大表示该页是在最长时间内不再被访问的页面可以选择其作为换出页面
综合性实验报告
专业 年级 课程名称 操作系统 学号姓名 实验地点
班级:
项目名称 页面置换算法
为有效
pl[page[i]].time=present_time; //修改页面的访问时
间
freepf_head=freepf_head->next; //减少一个free 页
面
}
else
pl[page[i]].time=present_time; //命中则修改该单元
的访问时间
present_time++;
}
printf("LRU:%6.4f ",1-(float)diseffect/320);
}
void OPT(int total_pf) /* 最佳页面置换算法 */
{
int i,j,max,maxpage,d,dist[total_vp];
initialize(total_pf);
for(i=0;i<total_instruction;i++)
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
页面置换算法实验报告
一、实验目的:
设计和实现最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Clock置换算法;通过支持页面访问序列随机发生实现有关算法的测试及性能比较。
二、实验内容:
●虚拟内存页面总数为N,页号从0到N-1
●物理内存由M个物理块组成
●页面访问序列串是一个整数序列,整数的取值范围为0到N - 1。
页面访问序
列串中的每个元素p表示对页面p的一次访问
●页表用整数数组或结构数组来表示
❑符合局部访问特性的随机生成算法
1.确定虚拟内存的尺寸N,工作集的起始位置p,工作集中包含的页
数e,工作集移动率m(每处理m个页面访问则将起始位置p +1),
以及一个范围在0和1之间的值t;
2.生成m个取值范围在p和p + e间的随机数,并记录到页面访问序
列串中;
3.生成一个随机数r,0 ≤r ≤1;
4.如果r < t,则为p生成一个新值,否则p = (p + 1) mod N;
5.如果想继续加大页面访问序列串的长度,请返回第2步,否则结束。
三、实验环境:
操作系统:Windows 7
软件:VC++6.0
四、实验设计:
本实验包含六种算法,基本内容相差不太,在实现方面并没有用统一的数据结构实现,而是根据不同算法的特点用不同的数据结构来实现:
1、最佳置换和随机置换所需操作不多,用整数数组模拟内存实现;
2、先进先出置换和最近最久未使用置换具有队列的特性,故用队列模拟内
存来实现;
3、CLOCK置换和改进的CLOCK置换具有循环队列的特性,故用循环队
列模拟内存实现;
4、所有算法都是采用整数数组来模拟页面访问序列。
五、数据结构设计:
//页面访问序列数组:
int ref[ref_size];
//内存数组:
int phy[phy_size];
//队列数据结构定义:
typedef struct QNode //定义队列数据结构
{
int data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
QueuePtr front; //头指针
QueuePtr rear; //尾指针}LinkQueue;
//定义链表数据结构
typedef struct LNode //定义循环链表数据结构{
int data;
int flag; //访问位
int modify; //修改位
struct LNode *next;
}LNode,*LinkList;
六、主要函数说明:
1、void set_rand_num() //产生具有局部特性的随机数列;
2、int Exchange_LNode(LinkList &L,int e,int i)//将链表L中序号为i的结点替换为内容
为e的结点;
3、bool Search_LinkList(LinkList &L,int e,int &i)//找到链表L中内容为e的结点,并用
i返回其位置,i=1表示第一个非头结点,依次类推;
4、void Search_LL_Flag(LinkList &L,int &i)//用i返回第一个flag为0的结点的位置,i=1
表示第一个非头结点,以此类推;
5、void Set_LL_Flag(LinkList &L,int i) //设置链表L中的序号为i的结点的flag标志
为1;
6、int Search_LL_ModifyClock(LinkList &L,int &modify_num)//找到改进的CLOCK算
法所需要淘汰的页,用modify_num返回其位置;
此函数根据书上给的思路,第一遍扫描A=0且M=0的页面予以淘汰,若失败,则
进行第二轮扫描A=0且M=1的页面,第二轮扫描时将所有访问过的页面的访问位
A置0;若失败则重复上述两部;
7、void Set_LL_modify(LinkList &L,int i) //设置链表L中的序号为i的结点的modify标
志为1;
8、bool SearchQueue(LinkQueue &Q,int e,int &i) //寻找队列Q中结点data域等于e的
结点,并用i返回其在Q中的位置;
9、int getnum(int a,int b) //用b返回元素a在被引用数列中的下一个位置
10、void ORA() //实现最佳置换算法,包括判断页面是否在内存中、页面进内存、输
出内存状态等内容;
11、void RAND() //随机置换算法
12、void FIFO() //先进先出算法
13、void LRU() //最近最久未使用算法
实现最近最久未使用算法的思想是:判断待进入内存的页面,如果与内存中的第一
个页面相同,则将它移到最后一个,即标志为最近使用的页;如果与内存中的第二
个页面相同,则将它删除,并在队列尾部添加相同元素,即标志为最近使用的页;
14、void CLOCK() //实现CLOCK算法
15、void Modified_Clock() //实现改进的CLOCK算法
16、int main() //主函数,调用实现各算法的6个主要函数,并输出各算法的缺页率。
七、实验问题回答:
1、FIFO算法是否比随机置换算法优越?
答:FIFO算法比随机置换算法优越,但优势并不明显。
2、LRU算法比FIFO 算法优越多少?
答:LRU算法FIFO算法的效率要高5%-10%,有理论知识可知,页面访问序列具有局部性,而FIFO 算法并不符合实际情况。
3、LRU算法和Optimal算法有何差距?
答:LRU算法是所有算法中效率最接近Optimal算法的算法,由理论知识可知,Optimal算法是理想的算法,现实中几乎不可能实现,只能作为一种测评标准,LRU算法是效率较高的可实现置换算法,但其硬件要求较高,如果规模较小,则略显麻烦。
4、Clock算法和LRU算法有何差距?
答:Clock算法和LRU算法从结果看来差距不大,Clock算法是使用软件的方式实现LRU算法中硬件的功能,从而在执行效率上会稍逊色些。
八、实验过程结果截图:
实验结果截图
测评一:
测评二:
测评三:
实验过程截图
(注:只截取第三次测评,蓝色字体表示产生缺页中断)。