常用页面置换算法模拟实验
实验5页面置换算法模拟实验ok

实验5 页面置换算法模拟实验一.实验目的1.进一步掌握虚拟存储器的实现方法。
2.掌握各种页面置换算法。
3.比较各种页面置换算法的优缺点。
二.实验内容模拟实现页面置换算法,步骤为:①使用产生随机数函数得到一个随机的数列,作为将要载入的页面序列。
②使用先进先出(FIFO)算法、最近最久未使用(LRU)置换算法和最佳(OPT)置换算法,列出所需淘汰的页面号序列。
③列出缺页中断次数。
三.参考源程序如下:#include <stdio.h>#include <stdlib.h>#include <time.h>#define N 10#define B 4/*------------------------------------------------------------------------函数名:IsInBuf(),返回某个数X在不在缓冲Buf[],如在,返回位置,否则返回-1--------------------------------------------------------------------------*/int IsInBuf(int buf[],int x){int i,j=-1;for(i=0;i<B;i++){if(buf[i]==x){ j=i;break; }else if(buf[i]==-1){ buf[i]=x;j=i;break; } }return j;}/*------------------------------------------------------------------------函数名:oldest(),返回最近最久未使用的页面位置--------------------------------------------------------------------------*/int oldest(int f[]){int i,j=0,max=-1;for(i=0;i<B;i++){if(f[i]>max){ max=f[i]; j=i; }f[i]++; }return j;}/*------------------------------------------------------------------------函数名:oldest2(),返回未来最久未使用的页面位置--------------------------------------------------------------------------*/int oldest2(int list[],int buf[],int f[],int start){int i,j;for(i=0;i<B;i++){for(j=start;j<N;j++){ if(buf[i]==list[j]) break; }f[i]=j; }return oldest(f);}int main(void){int list[N];int buf[B],f[B],i,j ;int old=0;int change=0;srand((int)time(NULL)); /*生成一系列随机数并初始化环境*/for(i=0;i<B;i++) {buf[i]=f[i]=-1;}printf("\nThe Random List:\n");for(i=0;i<N;i++){ list[i]=(int)rand()%10; printf("%2d",list[i]); } printf("\nFIFO\n");/*显示FIFO淘汰的页面序列*/change=0;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){printf("%2d",buf[old]);buf[old]=list[i];old=(old+1)%(int)B;change++;}else printf(" "); }printf("\n changes %2d\n",change); /*显示有多少个缺页中断*/printf("\nLRU\n");/*显示LRU淘汰的页面序列*/change=0;for(i=0;i<B;i++) {buf[i]=f[i]=-1;}for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);old=oldest(f);if(j==-1){printf("%2d",buf[old]);buf[old]=list[i];f[old]=0;change++;}else{ f[j]=0; printf(" "); } }printf("\n changes %2d\n",change); /*显示有多少个缺页中断*/printf("\nOPT\n");/*显示OPT淘汰的页面序列*/change=0;for(i=0;i<B;i++) {buf[i]=f[i]=-1;}for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){old=oldest2(list,buf,f,i);printf("%2d",buf[old]);buf[old]=list[i];f[old]=0;change++; }else{ f[j]=0; printf(" "); } }printf("\n changes %2d\n",change); /*显示有多少个缺页中断*/ getch();return 0; }(假设当前随机产生的页面序列为:7 1 0 4 2 5 8 6 9 1)四.填表题(1).在一个请求分页存储管理系统中,一个作业的页面走向为4、3、2、1、4、3、5、4、3、2、1、5,当分配给该作业的物理块数分别为4时,试计算采用先进先出淘汰算法时的缺页率(假设开始执行时主存中没有页面),并将所得结果填表。
页面置换算法实验报告

页面置换算法实验报告
一、实验内容
本次实验主要围绕页面置换算法进行,以实验课本的实例介绍,采用FIFO页面置换算法对后面提到的参数进行置换,最终得出页面置换的结果和比较所得结果。
二、实验步骤
(一) 熟悉FIFO算法
首先是要了解FIFO页面置换算法,FIFO全称(First In First Out),按页面进入内存的顺序来替换相应内存页面,先进先出,将先进入内存的页面先替换出去。
(二) 阅读实验课本
在阅读实验课本之前要先熟悉实验书上所介绍的FIFO算法,然后在实验书上找出需要做的实验,并对实验环境和表格进行观察,掌握实验的基本内容。
(三) 开始页面置换
在开始实验之前,熟悉实验环境,根据实验书上的参数,首先模拟进程分配内存,根据FIFO算法去进行计算,根据上表中的参数去比较,最后得出最终结果。
(四) 在本次实验的补充
这次实验中,可以把FIFO的概念应用到实际应用中,也可以模拟不同情况,例如改变页面的大小,观察不同页面置换算法的结果,实验出最合适的结果。
三、实验结论
本次实验是为了了解FIFO页面置换算法,实验出最终的结果,最后得出页面置换的结果及比较结果。
《操作系统》实验五:页面置换算法模拟

实验五. 请求页式存储管理的模拟[实验内容]:熟悉虚拟存储管理的各种页面置换算法,并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法(LRU),要求在每次产生置换时显示页面分配状态和缺页率。
[实验要求]:1、运行给出的实验程序,查看执行情况,进而分析算法的执行过程,在理解FIFO页面置换算法和最近最久未使用算法(LRU)置换算法后,给出最佳置换算法的模拟程序实现,并集成到参考程序中。
2、执行2个页面置换模拟程序,分析缺页率的情况。
最好页框数和访问序列长度可调节,在使用同一组访问序列数据的情况下,改变页框数并执行2个页面置换模拟程序,查看缺页率的变化。
3、在每次产生置换时要求显示分配状态和缺页率。
程序的地址访问序列通过随机数产生,要求具有足够的长度。
最好页框数和访问序列长度可调节。
实验的执行结果如下图所示(左下图为FIFO执行结果,右下图为LRU执行结果):程序源代码: #include <libio.h> #include "windows.h" #include <conio.h>#include <stdlib.h>#include <fstream.h>#include <io.h>#include <string.h>#include <stdio.h>void initialize(); //初始化相关数据结构void createps(); //随机生成访问序列void displayinfo(); //显示当前状态及缺页情况void fifo(); //先进先出算法int findpage(); //查找页面是否在内存void lru(); //最近最久未使用算法int invalidcount = 0; // 缺页次数int vpoint; //页面访问指针int pageframe[10]; // 分配的页框int pagehistory[10]; //记录页框中数据的访问历史int rpoint; //页面替换指针int inpflag; //缺页标志,0为不缺页,1为缺页struct PageInfo //页面信息结构{int serial[100]; // 模拟的最大访问页面数,实际控制在20以上int flag; // 标志位,0表示无页面访问数据int diseffect; // 缺页次数int total_pf; // 分配的页框数int total_pn; // 访问页面序列长度} pf_info;//////////////////////////////////////////////////////////////////////// //初始化相关数据结构void initialize(){int i,pf;inpflag=0; //缺页标志,0为不缺页,1为缺页pf_info.diseffect =0; // 缺页次数pf_info.flag =0; // 标志位,0表示无页面访问数据printf("\n请输入要分配的页框数:"); // 自定义分配的页框数scanf("%d",&pf);pf_info.total_pf =pf;for(i=0;i<100;i++) // 清空页面序列{pf_info.serial[i]=-1;}}///////////////////////////////////////////////////////////////////// 随机生成访问序列void createps(void ){int s,i,pn;initialize(); //初始化相关数据结构printf("\n请输入要随机生成访问序列的长度:"); //自定义随机生成访问序列的长度scanf("%d",&pn);srand(rand()); //初始化随机数队列的"种子"s=((float) rand() / 32767) * 50 + pn; // 随机产生页面序列长度pf_info.total_pn = s;for(i=0;i<s;i++) //产生随机访问序列{pf_info.serial[i]=((float) rand() / 32767) * 16 ; //随机数的大小在0-15之间}}////////////////////////////////////////////////////////////////////////// 显示当前状态及缺页情况void displayinfo(void){int i,n;if(vpoint==0){printf("\n=============页面访问序列=============\n");for(i=0; i<pf_info.total_pn; i++){printf("%4d",pf_info.serial[i]);if ((i+1) % 10 ==0) printf("\n"); //每行显示10个}printf("\n======================================\n"); }printf("访问%3d : 内存<",pf_info.serial[vpoint]);for(n=0;n<pf_info.total_pf;n++) // 页框信息{if (pageframe[n] >=0)printf("%3d",pageframe[n]);elseprintf(" ");}printf(" >");if(inpflag==1) //缺页标志,0为不缺页,1为缺页{printf(" ==>缺页");printf("缺页率%3.1f",(float)(pf_info.diseffect)*100.00/vpoint);}printf("\n");}//////////////////////////////////////////////////////////////////////// // 查找页面是否在内存,1为在内存,0为不在即缺页int findpage(int page){int n;for(n=0;n<pf_info.total_pf;n++){pagehistory[n] ++; // 访问历史加1}for(n=0;n<pf_info.total_pf;n++){if (pageframe[n]==page ){inpflag=0 ; //inpflag缺页标志,0为不缺页,1为缺页pagehistory[n]=0; //置访问历史为0return 1;}}inpflag=1; //页面不存在,缺页return 0;}//////////////////////////////////////////////////////////////////////// // FIFO页面置换算法void fifo(void){int n,count,pstate;rpoint=0; // 页面替换指针初始化为0invalidcount = 0; // 缺页数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满是所有的页框for(n=0;n<pf_info.total_pf;n++) // 清除页框信息{pageframe[n]=-1;}inpflag=0; //缺页标志,0为不缺页,1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0) // 页不存在则置换页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;pf_info.diseffect++; // 缺页次数加1 }}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束getch();return;}/////////////////////////////////////////////////////////////////// // LRU页面置换算法void lru(void){int n,count,pstate,max;rpoint=0; // 页面替换指针invalidcount = 0; // 缺页次数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满所有的页框for(n=0;n<pf_info.total_pf;n++){pageframe[n]=-1; // 清除页框信息pagehistory[n]=0; // 清除页框历史}inpflag=0; //缺页标志,0为不缺页,1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint]; //把要调入的页面放入一个空的页框里rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0)// 页不存在则置换页面{max=0;for(n=1;n<pf_info.total_pf;n++){if(pagehistory[n]>pagehistory[max]){max=n;}}rpoint=max;pageframe[rpoint]=pf_info.serial[vpoint];pagehistory[rpoint]=0;pf_info.diseffect++; // 缺页次数加1 }}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}/////////////////////最佳置换算法自己完成/////////////////////////////////////////////////////////////////// // 主函数int main(){char ch;system("cls") ;while ( true ){printf("*******************************************\n");printf(" 若要执行FIFO页面置算法请按1\n");printf(" 若要执行LRU 页面置算法请按2\n");printf(" 若要退出请按3\n") ;printf("*******************************************\n");printf( "Enter your choice (1 or 2 or 3): ");do{ //如果输入信息不正确,继续输入ch = (char)getch() ;}while(ch != '1' && ch != '2'&& ch != '3');printf("\n\n你按的是:%c ,现在为你执行对应操作。
页面置换算法模拟实验报告

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算法
实验五 请求页式存储管理中常用页面置换算法模拟

else { cout<<"---输入有误,物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:"; cin>>Nsize; } } break; case 2: cout<<"请输入分配的物理块数的大小: "; cin>>Nsize; while(1) { if(Nsize>0&&Nsize<=10) { Init(QString,Nsize); cout<<"页面号引用串: "; for(i=0;i<Psize;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"LRU算法结果如下:"<<endl; LRU(Nsize); BlockClear(Nsize); cout<<"----------------------"<<endl; system("pause"); system("cls");
void BlockClear(int Nsize) {//块清除 for(int i=0; i<Nsize; i++) { block[i].yemian = -1; block[i].biaoji = 0; } } /*主程序*/ void main(void) { int i,select,Nsize,QString[Psize]={0}; while(select) { cout<<"页面号引用串: "; for(i=0;i<20;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"+******************************+"<<endl; cout<<"+------------欢迎--------------+"<<endl; cout<<"+--------页面置换算法----------+"<<endl; cout<<"+-----选择<1>应用FIFO算法------+"<<endl; cout<<"+-----选择<2>应用LRU算法-------+"<<endl; cout<<"+-----选择<3>应用OPT算法-------+"<<endl; cout<<"+---选择<4>插入新的页面号引用串+"<<endl; cout<<"+-------选择<0>退出------------+"<<endl;
实验三页面置换算法模拟实验

计算机科学系实验报告书课程名:《操作系统》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求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值,表示该虚页的最后一次被访问时间。
常用页面置换算法模拟实验

目录一、摘要 (3)二、正文 (4)三、设计总结 (8)四、参考文献 (10)五、附录:源程序代码 (11)摘要Windows中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求(向CPU发出缺页中断),由系统将其所需页面调入内存。
这种页面调入方式叫请求调页,为实现请求调页,核心配置了四种数据结构:页表、页框号、访问位、修改位、有效位、保护位等。
此设计为了了解Windows XP的操作接口及系统调用方式,熟悉Windows XP常用操作的实现过程,练习并掌握Visual C++开发环境。
利用Windows SDK(System Development Kit)提供的API(应用程序接口)设计一个虚拟存储管理程序,并使用最佳淘汰算法(OPT)、先进先出算法(FIFO)、最近最久未使用算法(LRU)计算访问命中率。
(命中率=1-页面失效次数/页地址流长度)。
关键字Windows;请求调页;数据结构;存储管理正文一、设计思路页面置换算法:当CPU接收到缺页中断信号,中断处理程序先保存现场,分析中断原因,转入缺页中断处理程序。
该程序通过查找页表,得到该页所在外存的物理块号。
如果此时内存未满,能容纳新页,则启动磁盘I/O将所缺之页调入内存,然后修改页表。
如果内存已满,则须按某种置换算法从内存中选出一页准备换出,是否重新写盘由页表的修改位决定,然后将缺页调入,修改页表。
利用修改后的页表,去形成所要访问数据的物理地址,再去访问内存数据。
整个页面的调入过程对用户是透明的。
此设计为了了解Windows XP的操作接口及系统调用方式,熟悉Windows XP常用操作的实现过程,练习并掌握Visual C++开发环境。
利用Windows SDK(System Development Kit)提供的API(应用程序接口)设计一个虚拟存储管理程序,并使用最佳淘汰算法(OPT)、先进先出算法(FIFO)、最近最久未使用算法(LRU)计算访问命中率。
页面置换算法实验报告

页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中,页面置换算法是一种重要的内存管理策略。
当物理内存不足以容纳所有需要运行的进程时,操作系统需要根据一定的算法将部分页面从内存中换出,以便为新的页面腾出空间。
本实验旨在通过实际操作,对比不同的页面置换算法在不同场景下的性能表现。
二、实验背景在计算机系统中,每个进程都有自己的虚拟内存空间,而物理内存空间是有限的。
当进程需要访问某个页面时,如果该页面不在物理内存中,就会发生缺页中断,操作系统需要根据页面置换算法选择一个页面将其换出,然后将需要访问的页面换入。
常见的页面置换算法有先进先出(FIFO)、最近最久未使用(LRU)、时钟(Clock)等。
三、实验目的本实验旨在通过模拟不同的页面置换算法,比较它们在不同情况下的缺页率和效率。
通过实验结果,评估各个算法在不同场景下的优劣,为实际系统的内存管理提供参考。
四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较:FIFO、LRU和Clock。
我们使用C++编程语言模拟了一个简单的内存管理系统,并通过产生不同的访存序列来模拟不同的场景。
实验中,我们设置了不同的物理内存大小,访存序列长度和页面大小,以模拟不同的系统环境。
五、实验结果与分析在实验中,我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。
通过统计不同算法的缺页率和运行时间,得出以下结论:1. FIFO算法FIFO算法是最简单的页面置换算法,它按照页面进入内存的顺序进行置换。
实验结果表明,FIFO算法在缺页率方面表现一般,特别是在访存序列具有局部性的情况下,其性能明显下降。
这是因为FIFO算法无法区分不同页面的重要性,可能会将经常使用的页面换出,导致缺页率升高。
2. LRU算法LRU算法是一种基于页面访问时间的置换算法,它认为最近被访问的页面很可能在未来会被再次访问。
实验结果表明,LRU算法在缺页率方面表现较好,特别是在访存序列具有较强的局部性时,其性能明显优于FIFO算法。
实验三页面置换算法

操作系统实验报告班级:姓名:学号:实验三:页面置换算法一、实验目的1、熟悉内存分页管理策略。
2、编写OPT、FIFO、LRU,LFU四种置换算法并模拟实现。
3、锻炼知识的运用能力和实践能力。
二、实验内容设计主界面,输入一串系列模拟页面请求,实现以下算法:1) 最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO):淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)三、代码及运行结果分析#include <stdio.h>#include <stdlib.h>int mSIZE;int pSIZE;static int memery[10]={0};static int page[100]={0};static int temp[100][10]={0};void FIFO();void LRU();void OPT();void print(unsigned int t);void read();void mDelay(unsigned int Delay);int main(){int i,k,code;printf("请输入物理块的个数(M<=10):");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100):"); scanf("%d",&pSIZE);puts("请依次输入页面号引用串:");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);read();do{puts("输入的页面号引用串为:");for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}}printf("---------------------------------------------\n");printf("* 请选择页面置换算法:\t\t\t *\n");printf("* ----------------------------------------- *\n");printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n"); printf("* 3.最佳(OPT) 4.退出*\n");printf("--------------------------------------------\n");printf("请选择操作:[ ]\b\b");scanf("%d",&code);switch(code){case 1:FIFO();break;case 2:LRU();break;case 3:OPT();break;case 4:system("cls");exit(0);default:printf("输入错误,请重新输入:");}printf("按任意键重新选择置换算法:>>>"); getchar();}while (code!=4);getchar();}void read(){int i;for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++) {mDelay((pSIZE+mSIZE)/2);printf(">"); }printf("获取成功,按任意键进入置换算法选择界面:");getchar(); }void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}void print(unsigned int t) {int i,j,k,l;int flag;for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1))) printf("%d\n",page[i]);elseprintf(" %d ",page[i]);}for(j=0;j<mSIZE;j++){for(i=20*k;(i<mSIZE+20*k)&&(i<pSIZE);i++) {if(i>=j)printf(" |%d|",temp[i][j]);elseprintf(" | |");}for(i=mSIZE+20*k;(i<pSIZE)&&(i<20*(k+1));i++) { for(flag=0,l=0;l<mSIZE;l++)if(temp[i][l]==temp[i-1][l])flag++;if(flag==mSIZE)/*页面在物理块中*/printf(" ");elseprintf(" |%d|",temp[i][j]);}if(i%20==0)continue;printf("\n");}}printf("----------------------------------------\n");printf("缺页次数:%d\t\t",t+mSIZE);printf("缺页率:%d/%d\n",t+mSIZE,pSIZE);printf("置换次数:%d\t\t",t);printf("访问命中率:%d%%\n",(pSIZE-(t+mSIZE))*100/pSIZE); printf("----------------------------------------\n");}/*计算过程延迟*/void compute(){int i;printf("正在进行相关计算,请稍候");for(i=1;i<20;i++){mDelay(15);if(i%4==0)printf("\b\b\b\b\b\b \b\b\b\b\b\b"); elseprintf("...");}for(i=0;i++<30;printf("\b"));for(i=0;i++<30;printf(" "));for(i=0;i++<30;printf("\b"));}void FIFO(){int memery[10]={0};int time[10]={0};int i,j,k,m;int max=0;int count=0;for(i=0;i<mSIZE;i++){memery[i]=page[i];time[i]=i;for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++) {for(j=0,k=0;j<mSIZE;j++) {if(memery[j]!=page[i])k++;}if(k==mSIZE){count++;max=time[0]<time[1]?0:1; for(m=2;m<mSIZE;m++) if(time[m]<time[max]) max=m;memery[max]=page[i]; time[max]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}/*最近最久未使用置换算法*/void LRU(){int memery[10]={0};int flag[10]={0}; /*记录页面的访问时间*/ int i,j,k,m;int max=0;int count=0;for(i=0;i<mSIZE;i++){memery[i]=page[i];flag[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;elseflag[j]=i;}if(k==mSIZE){count++;max=flag[0]<flag[1]?0:1;for(m=2;m<mSIZE;m++)if(flag[m]<flag[max])max=m;memery[max]=page[i];flag[max]=i; /*记录该页的访问时间*/temp[i][j]=memery[j]; }else{for(j=0;j<mSIZE;j++) temp[i][j]=memery[j]; }}compute();print(count);}void OPT(){int memery[10]={0}; int next[10]={0};int i,j,k,l,m;int max;int count=0;for(i=0;i<mSIZE;i++) {memery[i]=page[i];temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++) {for(j=0,k=0;j<mSIZE;j++) {if(memery[j]!=page[i])k++;}if(k==mSIZE){count++;for(m=0;m<mSIZE;m++) {for(l=i+1;l<pSIZE;l++)if(memery[m]==page[l]) break;next[m]=l;}max=next[0]>=next[1]?0:1;for(m=2;m<mSIZE;m++) if(next[m]>next[max]) max=m;for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}else {for(j=0;j<mSIZE;j++) temp[i][j]=memery[j];}}compute();print(count);}四、实验心得。
页面置换算法实验报告

页面置换算法实验报告背景页面置换算法是计算机操作系统中的一个重要概念,它用于解决操作系统需要共享有限的物理内存资源给多个进程使用的问题。
在操作系统中,每个进程都有自己的虚拟地址空间,但实际的物理内存资源是有限的。
当物理内存不足时,操作系统需要根据一定的策略将一部分进程暂时从内存中移出,以便为其他进程让出空间,而后再从外存中将其重新加载到内存中。
这个过程就是页面置换。
页面置换算法有很多种,比如最优页面置换算法(Optimal)、先进先出页面置换算法(FIFO)、最近最久未使用页面置换算法(LRU)等等。
不同的算法对于系统性能、响应时间等指标有着不同的影响,因此在实际应用中需要选择合适的算法来平衡各种需求。
本实验旨在通过模拟页面置换算法,并对不同算法进行性能分析,以便了解各种算法的优缺点,为实际系统的选择提供依据。
分析在实验中,我们选择了三种常用的页面置换算法,分别是FIFO、LRU和Optimal。
下面对这三种算法进行详细的分析和说明。
先进先出页面置换算法(FIFO)FIFO算法是最简单和最直观的页面置换算法。
它按照页面进入内存的顺序来选择被淘汰的页面。
当内存不足时,选择最早进入内存的页面进行置换,即将其从内存中移出。
FIFO算法不需要进行进一步的页面访问计算,只需要维护一个页面进入内存的队列即可,因此实现起来比较简单。
然而,由于FIFO算法没有考虑页面的访问频率和重要性,所以可能会导致被频繁访问的页面被淘汰出内存,从而影响系统的性能。
最近最久未使用页面置换算法(LRU)LRU算法是一种基于”最近使用原则”的页面置换算法。
它根据页面最近被访问的时间来选择被淘汰的页面。
当内存不足时,选择最长时间未被访问的页面进行置换,即将其从内存中移出。
LRU算法需要维护一个页面访问时间的记录,以便在需要置换时能够快速找到最近最久未使用的页面。
相比于FIFO算法,LRU算法更加合理地利用了页面的访问情况,但实现起来相对复杂一些。
页面置换算法的模拟实现及命中率对比实验报告

页面置换算法的模拟实现及命中率对比实验报告一、问题描述课程设计目的(1)、通过请求页式管理方式中页面置换算法的模拟设计,了解虚拟存储术的特点,掌握请求页式存储管理中的页面置换算法。
(2)、课程设计内容模拟实现OPT(最佳置换)、FIFO和LRU算法,并计算命中率。
(3)、课程设计要求:a)首先用随机数生成函数产生“指令”序列,然后将指令序列变换成相应的页地址流,再计算不同算法下的命中率。
b)通过随机数产生一个指令序列,共产生400条。
其中50%的指令是顺序执行的(灵位50%就是非顺序),且25%的指令分布在前半部分地址空间,25%的指令分布在后半部分地址空间。
c)将指令地址流变换成页地址流d)循环运行,使用户内存容量从4到40,。
计算每个内存容量下不同页面置换算法的命中率。
二、概要设计1.程序的数据结构:#define total_instruction 100 /*指令流长*/#define M 100 /*实际页数*/#define N 5 //可用页面数struct Pro{int num,time;};int a[total_instruction];int page[N];2.程序的主函数:int main(){Pro p[total_instruction];Pro *page=new Pro[N];char c;int t=0,i;float n=0;Input(p);do{for( i=0;i<N;i++)//初试化页面基本情况{page[i].num=-1;page[i].time=2-i;}printf("系统产生的随机数为:");for(int e=0;e<M;e++)cout<<p[e].num<<" ";cout<<endl;i=0;cout<<"f:FIFO页面置换"<<endl;cout<<"l:LRU页面置换"<<endl;cout<<"o:OPT页面置换"<<endl;cout<<"按其它键结束"<<endl;cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"页面置换情况: "<<endl;while( i< total_instruction){if(Search(p[i].num,page)>=0)i++;//找到相同的页面else{if(t==N)t=0;else{n++;//page[t].num=p[i].num;print(page);t++;}}}cout<<"缺页次数:"<<n<<" 命中率:"<<1-n/total_instruction<<endl; }if(c=='l')//LRU页面置换{n=0;cout<<"页面置换情况: "<<endl;while(i<total_instruction){int k;k=t=Search(p[i].num,page);if(t>=0)page[t].time=0;else{n++;t=Max(page);page[t].num=p[i].num;page[t].time=0;}for(int j=0;j<N;j++){if(j!=t)page[j].time++;}/*if(t==0){page[t+1].time++;page[t+2].time++;}if(t==1){page[2].time++;page[0].time++;}if(t==2){page[1].time++;page[0].time++;}*/if(k==-1) print(page);i++;}cout<<"缺页次数:"<<n<<" 命中率:"<<1-n/total_instruction<<endl; }if(c=='o')//OPT页面置换{n=0;while(i<total_instruction){if(Search(p[i].num,page)>=0)i++;else{if(page[N-1].num==-1){for(int g=0;g<N;g++)if(page[g].num==-1){page[g].num=p[i].num;i++;n++;print(page);break;}}else{int temp=-1,cn;for(t=0;t<N;t++){if(temp<Compfu(page,i,t,p)){temp=Compfu(page,i,t,p);cn=t;}}page[cn]=p[i];n++;print(page);i++;}}}cout<<"缺页次数:"<<n<<" 命中率:"<<1-n/total_instruction<<endl;}}while(c=='f'||c=='l'||c=='o');return 0;}三、详细设计程序代码如下:#include<stdlib.h>#include<iostream>#include<time.h>#include<stdio.h>using namespace std;#define total_instruction 100 /*指令流长*/#define M 100 /*实际页数*/#define N 5 //可用页面数struct Pro{int num,time;};int a[total_instruction];int page[N];void Input(Pro p[total_instruction]){int m,i,m1,m2;srand( (unsigned int )time(NULL));m=rand( )%400; //for(i=0;i<total_instruction;) /*产生指令队列*/{if(m<0||m>399){printf("When i==%d,Error,m==%d\n",i,m);exit(0);}a[i]=m; /*任选一指令访问点m*/ a[i+1]=a[i]+1;a[i+2]=a[i]+2; /*顺序执行两条指令*/int m1=rand( )%m; /*执行前地址指令m1 */a[i+3]=m1;a[i+4]=m1+1;a[i+5]=m1 + 2;/*顺序执行两条指令*/// s=(158-a[i+5])*rand( )/32767/32767/2+a[i+5]+2;m2 = rand()%(157-m1)+m1+3;a[i+6]=m2;if( (m2+2) > 159 ){a[i+7] = m2+1;i +=8;}else{a[i+7] = m2+1;a[i+8] = m2+2;i = i+9;}m = rand()%m2;}for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/ {p[i].num=a[i]/10;p[i].time = 0;}}void print(Pro *page1)//打印当前的页面{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)printf("%-4d",page[i].num);//cout<<page[i].num<<" ";cout<<endl;//free(page);}int Search(int e,Pro *page1 ){Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)if(e==page[i].num)return i;return -1;}int Max(Pro *page1){Pro *page=new Pro[N];page=page1;int e=page[0].time,i=0;while(i<N)//找出离现在时间最长的页面{if(e<page[i].time)e=page[i].time;i++;}for( i=0;i<N;i++)if(e==page[i].time)return i;return -1;}int Compfu(Pro *page1,int i,int t,Pro p[M]){Pro *page=new Pro[N];page=page1;int count=0;for(int j=i;j<M;j++){if(page[t].num==p[j].num )break;else count++;}return count;}int main(){Pro p[total_instruction];Pro *page=new Pro[N];char c;int t=0,i;float n=0;Input(p);do{for( i=0;i<N;i++)//初试化页面基本情况{page[i].num=-1;page[i].time=2-i;}printf("系统产生的随机数为:");for(int e=0;e<M;e++)cout<<p[e].num<<" ";cout<<endl;i=0;cout<<"f:FIFO页面置换"<<endl; cout<<"l:LRU页面置换"<<endl;cout<<"o:OPT页面置换"<<endl;cout<<"按其它键结束"<<endl; cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"页面置换情况: "<<endl;while( i< total_instruction){if(Search(p[i].num,page)>=0)i++;//找到相同的页面else{if(t==N)t=0;else{n++;//page[t].num=p[i].num;print(page);t++;}}}cout<<"缺页次数:"<<n<<" 命中率:"<<1-n/total_instruction<<endl”}if(c=='l')//LRU页面置换{n=0;cout<<"页面置换情况: "<<endl;while(i<total_instruction){int k;k=t=Search(p[i].num,page);if(t>=0)page[t].time=0;else{n++;t=Max(page);page[t].num=p[i].num;page[t].time=0;}for(int j=0;j<N;j++){if(j!=t)page[j].time++;}/*if(t==0){page[t+1].time++;page[t+2].time++;}if(t==1){page[2].time++;page[0].time++;}if(t==2){page[1].time++;page[0].time++;}*/if(k==-1) print(page);i++;}cout<<"缺页次数:"<<n<<" 命中率:"<<1-n/total_instruction<<endl;}if(c=='o')//OPT页面置换{n=0;while(i<total_instruction){if(Search(p[i].num,page)>=0)i++;else{if(page[N-1].num==-1){for(int g=0;g<N;g++)if(page[g].num==-1){page[g].num=p[i].num;i++;n++;print(page);break;}}else{int temp=-1,cn;for(t=0;t<N;t++){if(temp<Compfu(page,i,t,p)){temp=Compfu(page,i,t,p);cn=t;}}page[cn]=p[i];n++;print(page);i++;}}}cout<<"缺页次数:"<<n<<" 命中率:"<<1-n/total_instruction<<endl; }}while(c=='f'||c=='l'||c=='o');return 0;}四、调试与分析程序的主界面:这里测试用的数据是M=40,N=5,三种算法置换结果如以下的图:FIFO算法:LRU算法:OPT算法:多运行几次,产生不同的随机数组,查看对比结果。
模拟页面置换算法FIFO、LRU的实现

实验报告五实验名称:模拟页面置换算法FIFO、LRU的实现日期:2015-12-9 班级:13级计科学号:姓名:一、实验目的了解页面置换的概念,理解页面置换的算法加深对页面置换算法的理解。
二、实验内容Java编程语言实现FIFO和LUR页面算法。
三、项目要求与分析FIFO算法当需要置换页面时,主要通过置换最早进入内存的页面从而达到先进先出的目的。
LRU算法当需要置换页面时,主要通过置换进入内存中最久没有被访问的页面而达到最近最久未使用的目的。
程序中可以通过标志位进行记录。
四、具体实现1.FIFO算法实现代码以及运行结果:public class FIFO {/*** 内存块的个数*/public static int N ;/*** 内存块数组*/Object[] array = new Object[N];/*** 要访问的页面数组*/public static int[]visit;private int size;/*** 内存是非空为否* @return*/public boolean isEmpty() {if(0 == size)return true;elsereturn false;}/*** 内存是非空满* @return*/public boolean isFulled() {if(size >= N)return true;elsereturn false;}/*** 元素(页框)的个数* @return*/public int size() {return size;}/*** 查找元素o在数组中的位置* @param o* @return*/public int indexOfElement(Object o) { for(int i=0; i<N; i++) {if(o == array[i]) {return i;}}return -1;}/*** 页面转换* @param obj*/public Object trans(Object obj){Object e = null;int t = 0;if(indexOfElement(obj) != -1) {t = indexOfElement(obj);for(int i=t; i<size-1; i++) {array[i] = array[i+1];}array[size-1] = obj;} else {if(!isFulled()){array[size] = obj;size ++;} else {for(int i=0; i<size-1; i++) {array[i] = array[i+1];}array[size-1] = obj;}}if( -1 == t) {return null;} else {return array[t];}}/*** 输出内存区中的各数据*/public void showMemoryBlock() {for(int i=0; i<size; i++) {System.out.print(array[i] + " "); }}/*** 清空队列(页框)*/public void clear(){}/*** @param args*/public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.print("请输入内存块的数量:");N=sc.nextInt();System.out.print("请输入总页面数目:");int n=sc.nextInt();visit=new int[n];System.out.println("请输入各个页的页面号码:");for(int i=0;i<n;i++)visit[i]=sc.nextInt();FIFO fifo = new FIFO();for(int i=0; i<visit.length; i++) {fifo.trans(visit[i]);fifo.showMemoryBlock();System.out.println();}运行结果:2.LUR算法实现代码以及运行结果:public class LRU {static int volum;// 栈的容量static List<Integer>list=new LinkedList<Integer>();//链表用来模拟栈存放页面static int[]visit;//要访问的页面数组static int count=0;//记录缺页次数public static void main(String []args){Scanner sc = new Scanner(System.in);System.out.print("请输入栈的容量:");volum=sc.nextInt();System.out.print("请输入总页面数目:");int n=sc.nextInt();visit=new int[n];System.out.println("请输入各个页的页面号码:");for(int i=0;i<n;i++)visit[i]=sc.nextInt();sLRU();//调用最近最久未使用算法System.out.println("置换页面的数目为:"+count);}public static void sLRU(){int index=0;while(index<visit.length){boolean flag=false;if(list.size()<=volum){for(int i=0;i<list.size();i++){if((int)(list.get(i))==visit[index]){list.remove(i);//先删除list.add(visit[index]);//再添加到尾部flag=true;break;}}if(!flag){if(list.size()<volum){//如果栈未满,而且此页面没有在栈中,就将它入栈list.add(visit[index]);}else{//如果栈已经满了,且该页面号码没有在栈中,就把栈底元素删除,将新页插入int temp=list.get(0);list.remove(0);//最开始一个换出list.add(visit[index]);//加到末尾count++;System.out.println("开始换页了,将栈底的"+temp+"换出"); System.out.println("这也是没有办法的事情,毕竟栈是有限的");}}System.out.print("经过第"+(index+1)+"个页面的栈内容为");for(int k=0;k<list.size();k++)System.out.print(list.get(k)+" ");System.out.println();index++;}运行结果:五、所遇问题与解决方法问题:针对于FIFO算法定义选择在内存中驻留时间最久的页面予以淘汰,对于内存中的驻留时间理解复杂了不知道如何下手。
常用页面置换算法模拟实验

操作系统课程实验报告代码:#i nclude <stdio.h>#i nclude <stdlib.h>#include <string.h>#defi ne page_frame_ nu mber 4 // 页框数#defi ne virtual_page_ nu mber 8 // 虚拟页面数int page_id, counter= 0;// 输入id 和计数器char algorithm[20];〃算法选择int page_i nterrupt_ nu mber = 0;struct Page_table{int page_id; // 页号int load_time; // 装入时间int last_visit_time; // 最后访问时间}page_table[page_frame_ nu mber];int cmp(c onst void *p,c onst void *q){(*(struct int c = (*(struct Page_table*)p).load_time Pagetable*)q).load time;if(c > 0)return 1;elsereturn -1;}int cmp1(c onst void *p,c onst void *q){(*(struct int c = (*(struct Page_table*)p).last_visit_timePage_table*)q).last_visit_time;if(c > 0)return 1;elsereturn -1;}void in it(){// 初始化int i;for(i = 0; i < page_frame_number; i++){page_table[i].page_id = -1; page_table[i].load_time = -1;page_table[i].last_visit_time = -1;} }打印信息void prin t(i ntx){// int i,j;switch(x){ case0: for(i = 0; i < 80; i++)prin tf("-"); prin 试验七常用页面置换算法模拟头验\n");for(i = 0; i < 80; i++)prin tf("-");prin tf("\n");printf(" 选择算法:F/L (FIFO算法/LRU 算法)\n");break;case 1:printf(" 请输入访问页面的顺序,以“-1 ”结束:\n");break;case 2: printf(" 页表信息:\n页号页框号装入时间最近访问时间\n");for(j = 0; j < page_frame_ nu mber; j++){printf("%4d%8d%7d%7d\n",page_table[j].page_id,j,page_table[j].load_time,page_table[j].last_visit_time);};break;case 3:for(i = 0; i < 80; i++)prin tf("-");printf("\t\tFIFO 算法模拟过程\n"); for(i = 0; i < 80; i++)prin tf("-");prin tf("\n");break;case 4:for(i = 0; i < 80; i++)prin tf("-");printf("\t\tLRU 算法模拟过程\n");for(i = 0; i < 80; i++)prin tf("-");prin tf("\n");}}int judge(){int i;for(i = 0; i < page_frame_ nu mber;i++){ if(page_table[i].page_id == -1||page_table[i].page_idreturn i;}return -1;}void fifo(){int j;prin t(3);prin t(1);while(1){scan f("%d",&page_id);if(page_id == -1)break;j = judge();if(j == -1){qsort(page_table, page_frame_ nu mber,Page_table), cmp);// 按照最后访问时间从小到大排序page_table[O].page_id = page_id;page_table[0].load_time = coun ter;page_table[O].last_visit_time = coun ter;page_i nterrupt_ nu mber++;}else{if(page_table[j].page_id == -1){ page_table[j].page_id = page_id; page_table[j].load_time = coun ter;page_table[j].last_visit_time = coun ter; page_interrupt_ nu mber++;} 一一else{page_table[j].last_visit_time = coun ter;k==page_id)sizeof(struct评阅教师:日期:。
实验四+页面置换算法

页面置换算法模拟实验【实验目的】1 )进一步掌握虚拟存储器的工作原理。
2)通过实验理解和掌握FIFO, LRU,OPT三种页面置换算法。
3)比较各种页面置换算法的优缺点。
【实验要求】1)认真阅读和掌握预备知识。
2)上机操作。
【预备知识】在采用请求分页机制的操作系统中,当运行一个进程的时侯,若所要访问的页面不在内存中而需要把它们调入内存,但此时内存已无空闲空间,为了保证该进程能正常运行,需选择内存中暂时不用的一个页面调出到磁盘交换区。
选择调出哪个页面,由页面置换算法决定。
页面置换算法的好坏,直接影响着系统的性能。
一个好的页面置换算法,应尽可能选择调出较长时间内不会再访问的页面,以保证较低的缺页率。
常见的页面置换算法有OPT (最佳置换算法),FIFO (先进先出算法)及LRU (最近最久未使用算法)。
一、OPT算法1. 原理简述1)在分配内存页面数(B)小于进程页面数(P)时,最先用到的B个页面依次放入内存;2)这时若需要处理新的页面,而当前分配的内存页面全部不空闲时,选择换出以后永远不再使用的页。
如没有这样的页面存在,则应选择下次访问距离现在最久的页换出,以空出内存来放置新调入的页面;3)以后如果有新页面需要调入,按“2)”之规则进行。
该算法能保证有最低的缺页率,所以称为最佳置换算法。
但是该算法仅仅是一种理想状况下的算法,因为在进程实际运行过程中,将来会执行到哪个页是不可预知的,所以无法选择该置换哪个页出去。
因此,本算法在实际中无法使用,只能作为一种标准来衡量其他算法的性能。
2. 图表描述假设某个进程在交换区被分为5个页面(P=5 ),分别以1,2,3,4,5表示。
在该进程运行过程中,处理机调用它们的顺序即页地址流为:而系统分配给该进程的内存空间只有 3 (B= 3 )个页面,那么在使用OPT算法时,这3个页面的内存使用情况应该是:为了便于比较学习,例子和前面的一样。
在使用FIFO 算法时,这3个页面的内存使用523355 42(f)、FIFO 算法1. 原理简述1) 在分配内存页面数(B )小于进程页面数(P )时,最先用到的 B 个页面依次放入内 存; 2) 这时若需要处理新的页面,则从当前内存中的 B 个页面中选择调出最先进入的那个页(所以称为FIFO ),然后放入新页面;3) 以后如果有新页面需要调入,按“ 2)”之规则进行。
页面置换算法模拟 实验报告

int select;
PRA test;
while(select)
{
cin>>select;
switch(select)
{
case 0:
break;
case 1:
cout<<"LRU算法结果如下:"<<endl;
test.LRU();
test.BlockClear();
3、实验要求
编程实现页面置换算法,最少实现两种算法,比较算法的优劣,并将调试结果显示在计算机屏幕上,并检测机算和笔算的一致性。
(1)采用页式分配存储方案,通过分别计算不同算法的命中率来比较算法的优劣,同时也考虑页面大小及内存实际容量对命中率的影响;
(2)实现OPT算法(最优置换算法)、LRU算法(Least Recently)、FIFO算法(First IN First Out)的模拟;
}
}
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)
{
for(int i=0; i<Bsize; i++)
{
block[i].content = -1;
block[i].timer = 0;
}
page = new pageInfor[Psize];
页面置换算法模拟

实验四页面置换算法模拟(1)一、实验目的1、理解虚拟存储器概念。
2、掌握分页式存储管理地址转换和缺页中断。
二、实验内容与基本要求1、模拟分页式存储管理中硬件的地址转换和产生缺页中断。
2、用先进先出页面调度算法处理缺页中断。
三、实验报告内容1、分页式存储管理和先进先出页面调度算法原理。
a.分页式存储管理原理在存储器管理中,连续分配方式会形成许多“碎片”,虽然可通过“紧凑”方法将许多碎片拼接成可用的大块空间,但须为之付出很大开销。
如果允许将一个进程直接分散地装入到许多不相邻的分区中,则无须再进行“紧凑”。
基于这一思想而产生了离散分配方式。
如果离散分配的基本单位是页,则称为分页存储管理方式。
在分页存储管理方式中,如果不具备页面对换功能,则称为基本分页存储管理方式,或称为纯分页存储管理方式,它不具有支持实现虚拟存储器的功能,它要求把每个作业全部装入内存后方能运行。
请求式分页系统是建立在基本分页基础上的,为了能支持虚拟存储器功能,而增加了请求调页功能和页面置换功能。
b.先进先出页面调度算法原理优先淘汰最早进入内存的页面,亦即在内存中驻留时间最久的页面。
该算法实现简单,只需把调入内存的页面根据先后次序链接成队列,设置一个指针总指向最早的页面。
但该算法与进程实际运行时的规律不适应,因为在进程中,有的页面经常被访问。
2、程序流程图。
3、程序及注释。
(完善程序:数据能动态的,少了越界错误的判断(页号小于页长,页内地址小于页的大小))#include<cstdio>#include<cstring>#define SizeOfPage 128#define SizeOfBlock 128#define M 4struct info//页表信息结构体{bool flag; //页标志,1表示该页已在主存,0表示该页不在主存long block;//块号long disk;//在磁盘上的位置bool dirty;//更新标志}pagelist[SizeOfPage];long po;//队列标记long P[M];//假设内存中最多允许M=4个页面void init_ex1() //内存空间初始化。
操作系统 七次实验报告 常用页面置换算法模拟实验..(推荐文档)

{
case 1:
FIFO();
break;
case 2:
LRU();
break;
case 3:
system("cls");
system("color 0A");
exit(0);
default:
printf("输入错误,请重新输入:");
}
printf("按任意键重新选择置换算法:>>>");
getch();
system("cls");
}while (code!=3);
getch();
}
void print(unsigned int t)
{
int i,j,k,l;
int flag;
for(k=0;k<=(pSIZE-1)/20;k++)
{
for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++)
1、第二次机会算法(Second Chance)
2、最近最少使用算法(Least Recently Used,LRU)
3、最不常用算法(Not Frequently Used,NFU)
4、最近未使用算法(Not Recently Used,NRU)
5、时钟页面置换算法
6、老化算法(aging)
页框的数量固定为4,虚拟页面数为8。实验输入为访问页面序列,比如0,1,3,2,7,1
printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n");
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
存储管理常用页面置换算法模拟实验实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟存储技术的特点,掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程,并比较它们的效率。
实验内容设计一个虚拟存储区和内存工作区,并使用下述算法计算访问命中率。
1、最佳淘汰算法(OPT)2、先进先出的算法(FIFO)3、最近最久未使用算法(LRU)4、最不经常使用算法(LFU)5、最近未使用算法(NUR)命中率=1-页面失效次数/页地址流长度实验准备本实验的程序设计基本上按照实验内容进行。
即首先用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。
在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第 0 条-第 9 条指令为第0页(对应虚存地址为[0,9])第10条-第19条指令为第1页(对应虚存地址为[10,19])………………………………第310条-第319条指令为第31页(对应虚存地址为[310,319])按以上方式,用户指令可组成32页。
实验指导一、虚拟存储系统UNIX中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求(向CPU发出缺中断),由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页,核心配置了四种数据结构:页表、页框号、访问位、修改位、有效位、保护位等。
二、页面置换算法当CPU接收到缺页中断信号,中断处理程序先保存现场,分析中断原因,转入缺页中断处理程序。
该程序通过查找页表,得到该页所在外存的物理块号。
如果此时内存未满,能容纳新页,则启动磁盘I/O将所缺之页调入内存,然后修改页表。
如果内存已满,则须按某种置换算法从内存中选出一页准备换出,是否重新写盘由页表的修改位决定,然后将缺页调入,修改页表。
利用修改后的页表,去形成所要访问数据的物理地址,再去访问内存数据。
整个页面的调入过程对用户是透明的。
常用的页面置换算法有1、最佳置换算法(Optimal)2、先进先出法(Fisrt In First Out)3、最近最久未使用(Least Recently Used)4、最不经常使用法(Least Frequently Used)5、最近未使用法(No Used Recently)三、参考程序:#define TRUE 1#define FALSE 0#define INVALID -1#define NULL 0#define total_instruction 320 /*指令流长*/#define total_vp 32 /*虚页长*/#define clear_period 50 /*清0周期*/typedef struct /*页面结构*/{int pn,pfn,counter,time;}pl_type;pl_type pl[total_vp]; /*页面结构数组*/struct pfc_struct{ /*页面控制结构*/int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_typepfc[total_vp],*freepf_head,*busypf_head,*busy pf_tail;int diseffect, a[total_instruction];int page[total_instruction],offset[total_instruction];int initialize(int);int FIFO(int);int LRU(int);int LFU(int);int NUR(int);int OPT(int);int main( ){int s,i,j;srand(10*getpid()); /*由于每次运行时进程号不同,故可用来作为初始化随机数队列的“种子”*/s=(float)319*rand( )/32767/32767/2+1; //for(i=0;i<total_instruction;i+=4) /*产生指令队列*/{if(s<0||s>319){printf("When i==%d,Error,s==%d\n",i,s); exit(0);}a[i]=s; /*任选一指令访问点m*/a[i+1]=a[i]+1; /*顺序执行一条指令*/a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m' */a[i+3]=a[i+2]+1; /*顺序执行一条指令*/s=(float)(318-a[i+2])*rand( )/32767/32767/2+a [i+2]+2;if((a[i+2]>318)||(s>319))printf("a[%d+2],a number which is :%d and s==%d\n",i,a[i+2],s);}for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/{page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++) /*用户内存工作区从4个页面到32个页面*/{printf("---%2d page frames---\n",i);FIFO(i);LRU(i);LFU(i);NUR(i);OPT(i);}return 0;}int initialize(total_pf) /*初始化相关数据结构*/int total_pf; /*用户进程的内存页面数*/{int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; /*置页面控制结构中的页号,页面为空*/pl[i].counter=0;pl[i].time=-1; /*页面控制结构中的访问次数为0,时间为-1*/}for(i=0;i<total_pf-1;i++){pfc[i].next=&pfc[i+1];pfc[i].pfn=i;} /*建立pfc[i-1]和pfc[i]之间的链接*/pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; /*空页面队列的头指针为pfc[0]*/return 0;}int FIFO(total_pf) /*先进先出算法*/int total_pf; /*用户进程的内存页面数*/{int i,j;pfc_type *p;initialize(total_pf); /*初始化相关页面控制用数据结构*/busypf_head=busypf_tail=NULL; /*忙页面队列头,队列尾链接*/for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect+=1; /*失效次数*/if(freepf_head==NULL) /*无空闲页面*/{p=busypf_head->next;pl[busypf_head->pn].pfn=INVALID;freepf_head=busypf_head; /*释放忙页面队列的第一个页面*/freepf_head->next=NULL;busypf_head=p;}p=freepf_head->next; /*按FIFO方式调新页面入内存页面*/freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head; else{busypf_tail->next=freepf_head; /*free 页面减少一个*/busypf_tail=freepf_head;}freepf_head=p;}}printf("FIFO:%6.4f\n",1-(float)diseffect/320) ;return 0;}int LRU (total_pf) /*最近最久未使用算法*/int total_pf;{int min,minj,i,j,present_time;initialize(total_pf);present_time=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect++;if(freepf_head==NULL)/*无空闲页面*/{min=32767;for(j=0;j<total_vp;j++)/*找出time的最小值*/if(min>pl[j].time&&pl[j].pfn!=INVALID){min=pl[j].time;minj=j;}freepf_head=&pfc[pl[minj].pfn]; //腾出一个单元pl[minj].pfn=INVALID;pl[minj].time=-1;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,改为有效pl[page[i]].time=present_time;freepf_head=freepf_head->next; //减少一个free 页面}elsepl[page[i]].time=present_time; //命中则增加该单元的访问次数present_time++;}printf("LRU:%6.4f\n",1-(float)diseffect/320); return 0;}int NUR(total_pf) /*最近未使用算法*/int total_pf;{ int i,j,dp,cont_flag,old_dp;pfc_type *t;initialize(total_pf);dp=0;for(i=0;i<total_instruction;i++){ if (pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect++;if(freepf_head==NULL) /*无空闲页面*/{ cont_flag=TRUE;old_dp=dp;while(cont_flag)if(pl[dp].counter==0&&pl[dp].pfn!=INVALID)cont_flag=FALSE;else{dp++;if(dp==total_vp)dp=0;if(dp==old_dp)for(j=0;j<total_vp;j++) pl[j].counter=0;}freepf_head=&pfc[pl[dp].pfn];pl[dp].pfn=INVALID;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn; freepf_head=freepf_head->next;}elsepl[page[i]].counter=1;if(i%clear_period==0)for(j=0;j<total_vp;j++)pl[j].counter=0;}printf("NUR:%6.4f\n",1-(float)diseffect/320); return 0;}int OPT(total_pf) /*最佳置换算法*/int total_pf;{int i,j, max,maxpage,d,dist[total_vp];pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){ //printf("In OPT for 1,i=%d\n",i);//i=86;i=176;206;250;220,221;192,193,194;258; 274,275,276,277,278;if(pl[page[i]].pfn==INVALID) /*页面失效*/{diseffect++;if(freepf_head==NULL) /*无空闲页面*/{for(j=0;j<total_vp;j++)if(pl[j].pfn!=INVALID)dist[j]=32767; /* 最大"距离" */else dist[j]=0;d=1;for(j=i+1;j<total_instruction;j++) {if(pl[page[j]].pfn!=INVALID)dist[page[j]]=d;d++;}max=-1;for(j=0;j<total_vp;j++)if(max<dist[j]){max=dist[j];maxpage=j;}freepf_head=&pfc[pl[maxpage].pfn]; freepf_head->next=NULL;pl[maxpage].pfn=INVALID;}pl[page[i]].pfn=freepf_head->pfn;freepf_head=freepf_head->next;}}printf("OPT:%6.4f\n",1-(float)diseffect/320); return 0;}int LFU(total_pf) /*最不经常使用置换法*/int total_pf;{int i,j,min,minpage;pfc_type *t;initialize(total_pf);for(i=0;i<total_instruction;i++){ if(pl[page[i]].pfn==INVALID) /*页面失效*/{ diseffect++;if(freepf_head==NULL) /*无空闲页面*/{ min=32767;for(j=0;j<total_vp;j++){if(min>pl[j].counter&&pl[j].pfn!=INVALID){min=pl[j].counter;minpage=j;}pl[j].counter=0;}freepf_head=&pfc[pl[minpage].pfn];pl[minpage].pfn=INVALID;freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,改为有效pl[page[i]].counter++;freepf_head=freepf_head->next; //减少一个free 页面}elsepl[page[i]].counter++;}printf("LFU:%6.4f\n",1-(float)diseffect/320); return 0;}四、运行结果4 page framsFIFO: 0.7312LRU: 0.7094LFU: 0.5531NUR: 0.7688OPT: 0.97505 page frams…………五、分析1、从几种算法的命中率看,OPT最高,其次为NUR相对较高,而FIFO与LRU相差无几,最低的是LFU。