《操作系统》实验五页面置换算法模拟

合集下载

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

实验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时,试计算采用先进先出淘汰算法时的缺页率(假设开始执行时主存中没有页面),并将所得结果填表。

页面置换算法模拟实验报告材料

页面置换算法模拟实验报告材料

实验编号4名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计,以便:1、了解虚拟存储技术的特点2、掌握请求页式存储管理中页面置换算法实验内容与步骤设计一个虚拟存储区和内存工作区,并使用FIFO和LRU算法计算访问命中率。

<程序设计>先用srand()函数和rand()函数定义和产生指令序列,然后将指令序列变换成相应的页地址流,并针对不同的算法计算相应的命中率。

<程序1>#include <windows.h> //Windows版,随机函数需要,GetCurrentProcessId()需要//#include <stdlib.h>//Linux版,随机函数srand和rand需要#include <stdio.h> //printf()需要#define TRUE 1#define FALSE 0#define INV ALID -1#define NULL 0#define total_instruction 320 //共320条指令#define total_vp 32 //虚存页共32页#define clear_period 50 //访问次数清零周期typedef struct{//定义页表结构类型〔页面映射表PMT〕int pn, pfn, counter, time;//页号、页框号(块号)、一个周期内访问该页面的次数、访问时间}PMT;PMT pmt[32];typedef struct pfc_struct{//页面控制结构int pn, pfn;struct pfc_struct *next;}pfc_type;pfc_type pfc[32];pfc_type *freepf_head,*busypf_head,*busypf_tail;//空闲页头指针,忙页头指针,忙页尾指针int NoPageCount; //缺页次数int a[total_instruction];//指令流数组int page[total_instruction], offset[total_instruction];//每条指令的页和页内偏移void initialize( int );void FIFO( int );//先进先出void LRU( int );//最近最久未使用void NRU( int );//最近最不经常使用/****************************************************************************main()*****************************************************************************/ void main(){int i,s;//srand(10*getpid());//用进程号作为初始化随机数队列的种子//Linux版srand(10*GetCurrentProcessId());//用进程号作为初始化随机数的种子//Windows版s=rand()%320;//在[0,319]的指令地址之间随机选取一起点mfor(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。

实验五虚拟内存页面置换算法

实验五虚拟内存页面置换算法

实验五虚拟内存页⾯置换算法实验五虚拟内存页⾯置换算法⼀:实验⽬的通过这次实验,加深对虚拟内存页⾯置换概念的理解,进⼀步掌握先进先出FIFO、最佳置换OPI和最近最久未使⽤LRU页⾯置换算法的实现⽅法。

⼆:实验内容问题描述:设计程序模拟先进先出FIFO、最佳置换OPI和最近最久未使⽤LRU页⾯置换算法的⼯作过程。

假设内存中分配给每个进程的最⼩物理块数为m,在进程运⾏过程中要访问的页⾯个数为n,页⾯访问序列为P1, … ,P n,分别利⽤不同的页⾯置换算法调度进程的页⾯访问序列,给出页⾯访问序列的置换过程,计算每种算法缺页次数和缺页率。

程序要求:1)利⽤先进先出FIFO、最佳置换OPI和最近最久未使⽤LRU三种页⾯置换算法模拟页⾯访问过程。

2)模拟三种算法的页⾯置换过程,给出每个页⾯访问时的内存分配情况。

3)输⼊:最⼩物理块数m,页⾯个数n,页⾯访问序列P1, … ,P n,算法选择1-FIFO,2-OPI,3-LRU。

4)输出:每种算法的缺页次数和缺页率。

实现提⽰:⽤C++语⾔实现提⽰:1)程序中变量定义参考如下:int PageOrder[MaxNumber];int Time[MaxNumber];int Simulate[MaxNumber][MaxNumber];int PageCount[MaxNumber];int PageNum,LackNum,PageMin;double LackPageRate;bool found;2)页⾯置换的实现过程如下:变量初始化;接收⽤户输⼊最⼩物理块数m,页⾯个数n,页⾯序列P1, … ,P n,选择算法1-FIFO,2-OPI,3-LRU;根据⽤户选择的算法进⾏页⾯的分配和置换,输出页⾯置换算法的模拟过程;计算选择算法的缺页次数和缺页率;输出选择算法的缺页次数和缺页率。

三:概要设计输⼊函数void input()初始化函数void Initial()最佳置换算法的函数void OPI()最近最久未使⽤置换算法void LRU()主函数void main(){input();int s=0;while(s!=4){cout<<"请选择算法:"<cout<<"1:先进先出;2:最佳值换算法;3:最近最久未使⽤置换算法;4:退出"< cin>>s;switch(s){case 1:FIFO();show();break;case 2:OPI();show();break;case 3:LRU();show();break;case 4:return;default:cout<<"输⼊数字不对,请重新输⼊:";break;}}}页⾯数列7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1系统为进程分配的物理块:3输出结果如截图所⽰:先进先出算法:2.最佳置换算法3.LRU算法说明:—1表⽰的是物理块中没有页⾯。

操作系统实验5 页面置换算法

操作系统实验5   页面置换算法

操作系统实验报告计算机0703班200729实验5 页面置换算法一、实验题目:页面置换算法(请求分页)二、实验目的:进一步理解父子进程之间的关系。

1)理解内存页面调度的机理。

2)掌握页面置换算法的实现方法。

3)通过实验比较不同调度算法的优劣。

4)培养综合运用所学知识的能力。

页面置换算法是虚拟存储管理实现的关键,通过本次试验理解内存页面调度的机制,在模拟实现FIFO、LRU等经典页面置换算法的基础上,比较各种置换算法的效率及优缺点,从而了解虚拟存储实现的过程。

将不同的置换算法放在不同的子进程中加以模拟,培养综合运用所学知识的能力。

三、实验内容及要求这是一个综合型实验,要求在掌握父子进程并发执行机制和内存页面置换算法的基础上,能综合运用这两方面的知识,自行编制程序。

程序涉及一个父进程和两个子进程。

父进程使用rand()函数随机产生若干随机数,经过处理后,存于一数组Acess_Series[]中,作为内存页面访问的序列。

两个子进程根据这个访问序列,分别采用FIFO和LRU两种不同的页面置换算法对内存页面进行调度。

要求:1)每个子进程应能反映出页面置换的过程,并统计页面置换算法的命中或缺页情况。

设缺页的次数为diseffect。

总的页面访问次数为total_instruction。

缺页率= disaffect/total_instruction命中率= 1- disaffect/total_instruction2)将为进程分配的内存页面数mframe 作为程序的参数,通过多次运行程序,说明FIFO算法存在的Belady现象。

四、程序流程图开始创建子进程1创建子进程2结束读逻辑页面否是否已调入物理页面是当前物理页面表是否已满淘汰最先进入页是失效次数加1将读的页调入物理页面表是否已读完逻辑页面退出是否读逻辑页面否是否已调入物理页面当前物理页面表是否已满淘汰最先进入页是失效次数加1将读的页调入物理页面表是否已读完逻辑页面退出是否调整物理页面表中页的顺序是五、程序源代码、文档注释及文字说明#include<stdio.h> #include<sys/types.h> #include<stdlib.h> #include<sys/stat.h> #include<fcntl.h> #include<error.h>#include<wait.h>#include<unistd.h>main(){int p1,p2;int i,j,k,t,m,kk,r1,r2;int temp1,temp2,temp3;int diseffect1=0;int diseffect2=0;int k1=0;int k2=0; int f1=0;int f2=0;float f;int Access_series[8];struct one_frame{int page_no;char flag;};int mframe=5;struct one_frame M_Frame[5];for(i=0;i<mframe;i++) M_Frame[i].page_no=-1;printf("yemian: ");for(i=0;i<8;i++) //产生随机数{Access_series[i]=rand()%8+1;printf("%d ",Access_series[i]);}printf("\n");}while((p1=fork())==-1);if(p1==0){for(j=0;j<8;j++){r1=Access_series[j]; //读入一个逻辑页面for(k=0;k<k1;k++) //查找页面是否已存在于物理页面{if(r1!=M_Frame[k].page_no) continue;else{ printf("have found!\n");for(i=0;i<k1;i++) //存在则显示,并标记,返回读入逻辑页面printf("%d ",M_Frame[i]);printf("\n");f1=1;break;}}if(f1==0){diseffect1++; //若不存在,发生缺页,则失效率加1if(k1<mframe) //物理页面没有分配满{M_Frame[k1].page_no=r1; //分配一个空的物理页面M_Frame[k1].flag='Y';k1++;for(i=0;i<8;i++)printf("%d",Access_series[i]);printf("\n");printf("diseffect!");printf(" %d\n",diseffect1);for(i=0;i<k1;i++)printf("%d ",M_Frame[i]);printf("\n");}else{ temp1=M_Frame[0].page_no; //物理页面表已满for(i=1;i<5;i++)M_Frame[i-1]=M_Frame[i];M_Frame[4].page_no=r1; //淘汰最早进入的M_Frame[0]//并将所读的逻辑页面调入for(i=0;i<8;i++)printf("%d",Access_series[i]);printf("\n");printf("diseffect! %d\n",diseffect1);printf("lose %d\n",temp1);for(i=0;i<k1;i++)printf("%d ",M_Frame[i]);printf("\n");}}f1=0;}f=diseffect1/8.0; //统计缺页率printf("diseffect rate of FIFO %f\n",f);exit(0);}wait(0);for(i=0;i<mframe;i++) M_Frame[i].page_no=-1;while((p2=fork())==-1) ; //创建子进程2if(p2==0){for(m=0;m<8;m++){r2=Access_series[m]; //读入逻辑页for(kk=0;kk<k2;kk++){if(r2!=M_Frame[kk].page_no) //首先在物理页面中查找continue;else{printf("have found!\n"); //找到for(t=kk+1;t<k2;t++) //调整数组顺序,使刚被访问的页面在最后的位置M_Frame[t-1].page_no=M_Frame[t].page_no;M_Frame[t-1].page_no=r2;for(i=0;i<k2;i++)printf("%d ",M_Frame[i].page_no);printf("\n");f2=1;break;}}if(f2==0) //没有找到,发生缺页{diseffect2++; //缺页率加1if(k2<mframe) //物理页面还没有分配完{M_Frame[k2].page_no=r2; //选择空页面分配M_Frame[k2].flag='Y';k2++;for(i=0;i<8;i++)printf("%d ",Access_series[i]);printf("\n");printf("diseffect! %d\n",diseffect2);for(i=0;i<k2;i++)printf("%d ",M_Frame[i]);printf("\n");}else{ //淘汰最近最久未访问的M_Frame[0]temp3=M_Frame[0].page_no;for(i=1;i<mframe;i++)M_Frame[i-1].page_no=M_Frame[i].page_no;M_Frame[mframe-1].page_no=r2; //将当前页调入for(i=0;i<8;i++)printf("%d ",Access_series[i]);printf("\n");printf("diseffect %d\n",diseffect2);;printf("lose %d\n",temp3);for(i=0;i<k2;i++)printf("%d ",M_Frame[i]);printf("\n");}}f2=0;}f=diseffect2/8.0; //统计失效率printf("diseffect rate of LRU %f\n",f);exit(0);}}六、运行结果及其说明FIFO:8,7,2,4缺页调入,2,8命中,3缺页调入,5缺页淘汰8,调入5;LRU:8,7,2,4缺页调入,访问2,把2移到数组尾,访问8,把8移到数组尾,3缺页调入,5缺页,淘汰7,调入5。

操作系统课程设计报告--页面置换算法模拟程序设计

操作系统课程设计报告--页面置换算法模拟程序设计

操作系统课程设计报告题目:页面置换算法模拟程序设计专业:软件工程院系:信息管理学院目录第一部分概述第二部分设计的基本概念和原理第三部分总体设计3.1算法流程图3.2算法的简要实现方法3.2.1 OPT页面置换算法3.2.2 FIFO页面置换算法3.2.3 LRU页面置换算法3.2.4 LFU页面置换算法第四部分详细设计4.1 main函数4.2 OPT函数4.2 FIFO函数4.3 LRU函数4.5 LFU函数4.6辅助函数4.6.1 Designer函数4.6.2 mDelay函数4.6.3 Download函数4.6.4 Compute函数4.6.5 showTable函数第五部分实现源代码第六部分简要的使用说明及主要运行界面第七部分总结第八部分参考文献第一部分概述设计任务:页面置换算法是虚拟存储管理实现的关键,通过本次课程设计理解内存页面调度的机制,在模拟实现OPT、FIFO、LRU和LFU几种经典页面置换算法的基础上,比较各种置换算法的效率及优缺点,从而了解虚拟存储实现的过程。

第二部分设计的基本概念和原理(1).页面淘汰机制页面淘汰又称为页面置换。

若请求调页程序要调进一个页面,而此时该作业所分得的主存块已全部用完,则必须淘汰该作业已在主存中的一个页。

这时,就产生了在诸页面中淘汰哪个页面的问题,这就是淘汰算法(或称为置换算法)。

置换算法可描述为,当要索取一个页面并送入主存时,必须将该作业已在主存中的某一页面淘汰掉,用来选择淘汰哪一页的规则就叫做置换算法。

(2).各种页面置换算法的实现思想OPT算法是当要调入一新页而必须先淘汰一旧业时,所淘汰的那一页应是以后不要再用的或是以后很长时间才会用到的页。

FIFO算法的实质是,总是选择在主存中居留时间最长(即最老)的一页淘汰。

其理由是最先调入主存的页面,其不再被使用的可能性比最近调入主存的页的可能性大。

LRU算法的实质是,当需要置换一页时,选择最长时间未被使用的那一页淘汰。

操作系统页面置换算法_课程设计论文

操作系统页面置换算法_课程设计论文

操作系统页面置换算法_课程设计论文《操作系统》课程设计任务书题目:常用页面置换算法模拟实验学号: 学生姓名:班级:题目类型:软件工程,R,指导教师: 一、设计目的学生通过该题目的设计过程,掌握常用页面置换算法的原理、软件开发方法并提高解决实际问题的能力。

二、设计任务1、了解UNIX的命令及使用格式,熟悉UNIX/LINUX的常用基本命令,练习并掌握UNIX提供的vi编辑器来编译C程序,学会利用gcc、gdb编译、调试C程序。

2、设计一个虚拟存储区和内存工作区,并使用最佳淘汰算法,OPT,、先进先出算法,FIFO,、最近最久未使用算法,LRU,计算访问命中率。

,命中率,,,页面失效次数,页地址流长度,三、设计要求1、分析设计要求,给出解决方案,要说明设计实现所用的原理、采用的数据结构,。

2、设计合适的测试用例,对得到的运行结果要有分析。

3、设计中遇到的问题,设计的心得体会。

4、文档:课程设计打印文档每个学生一份,并装在统一的资料袋中。

5、光盘:每个学生的文档和程序资料建在一个以自己学号和姓名命名的文件夹下,刻录一张光盘,装入资料袋中。

四、提交的成果1. 设计说明书一份,内容包括:1) 中文摘要100字;关键词3-5个;2) 设计思想;3,各模块的伪码算法;4,函数的调用关系图;5,测试结果;6,源程序,带注释,;7,设计总结;8) 参考文献、致谢等。

2. 刻制光盘一张。

五、主要参考文献1. 汤子瀛,哲凤屏.《计算机操作系统》.西安电子科技大学学出版社.2. 王清,李光明.《计算机操作系统》.冶金工业出版社.3.,钟秀等. 操作系统教程. 高等教育出版社4.曾明. Linux操作系统应用教程. 陕西科学技术出版社.5. 张丽芬,刘利雄.《操作系统实验教程》. 清华大学出版社.6. 孙静, 操作系统教程,,原理和实例分析. 高等教育出版社7. 周长林,计算机操作系统教程. 高等教育出版社8. 张尧学,计算机操作系统教程,清华大学出版社9. 任满杰,操作系统原理实用教程,电子工业出版社10.张坤.操作系统实验教程,清华大学出版社六、各阶段时间安排,共2周,周次日期内容地点教师讲解设计要求教室星期一~二查找参考资料图书馆第1周星期三~五算法设计,编程实现教室星期一~三算法设计,编程实现教室第2周星期四~五检查程序,答辩教室2013年12月9日摘要操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源,控制程序运行改善人机界面,为其它应用软件提供支持等,使计算机系统所有资源最大限度地发挥作用,为用户提供方便的、有效的、友善的服务界面。

实验五 请求页式存储管理中常用页面置换算法模拟

实验五 请求页式存储管理中常用页面置换算法模拟

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;

页面置换算法模拟实验 操作系统大作业(含源文件)

页面置换算法模拟实验 操作系统大作业(含源文件)

“计算机操作系统”课程设计大作业页面置换算法模拟实验(含完整资料,可直接提交)一、题目: 页面置换算法模拟实验二、目的分别采用最佳(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中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。

操作系统课程设计--页面置换算法的模拟实现_

操作系统课程设计--页面置换算法的模拟实现_

操作系统课程设计--页面置换算法的模拟实现_ 题目: 页面置换算法的模拟实现_专业计算机科学与技术学生姓名班级学号指导教师发放日期信息工程学院目录1 概述 ..................................................................... .........................................................................12 设计原理 ..................................................................... .. (1)2.1 先进先出(FIFO)算法 ..................................................................... ...................................... 1 2.2 最近最久未使用(LRU)算法 ..................................................................... .......................... 1 3 详细设计与编码 ..................................................................... ..................................................... 2 3.1 模块设计 ..................................................................... .. (2)3.2 系统详细设计 ..................................................................... ...................................................... 2 4 结果与分析 ..................................................................... . (4)4.1 测试方案 ..................................................................... .. (4)4.2 测试结果 ..................................................................... .. (5)4.3测试结果分析 ..................................................................... . (8)5 设计小结 ..................................................................... .. (8)6 参考文献 ..................................................................... .. (9)附录程序代码 ..................................................................... (10)操作系统课程设计(2015)页面置换算法的模拟实现1 概述在进程运行过程中,若其所要访问的页面不在内存所需把他们调入内存,但内存已无空闲时,为了保证进程能够正常运行,系统必须从内存中调入一页程序或数据送磁盘的对换区中。

模拟操作系统的页面置换实验报告(模板)

模拟操作系统的页面置换实验报告(模板)

模拟操作系统的页面置换实验报告(模板)一、综设计实验题目:模拟操作系统的页面置换二、中文摘要:了解页面置换的概念。

理解页面置换的算法。

加深对页面置换算法的理解。

锻炼知识的运用能力和实践能力。

掌握用随机数生成满足一定条件的指令地址流的方法。

关键词:页面置换先进先出置换算法(FIFO)OPT 算法RLU算法C++三、前言实验目的1、掌握操作系统的页面置换过程,加深理解页式虚拟存储器的实现原理。

2、掌握用随机数生成满足一定条件的指令地址流的方法。

3、掌握页面置换的模拟方法。

实验要求与内容1、采用一种熟悉的语言,如C、PASCAL 或C++等,编制程序,最好关键代码采用C/C++,界面设计可采用其它自己喜欢的语言。

2、模拟操作系统采用OPT、FIFO 和LRU 算法进行页面置换的过程。

3、设程序中地址范围为0 到32767,采用随机数生成256 个指令地址,满足50%的地址是顺序执行,25%向前跳,25%向后跳。

为满足上述条件,可采取下列方法:设d0=10000,第n个指令地址为dn,第n+1 个指令地址为dn+1,n的取值范围为0 到255。

每次生成一个1 到1024 范围内的随机数a,如果a落在1 到512 范围内,则dn+1=dn+1。

如果a落在513 到768范围内,则设置dn+1为1 到dn范围内一个随机数。

如果a落在769 到1024范围内,则设置dn+1为dn到32767 范围内一个随机数。

例如:srand();初始化一个随机函数。

a[0]=10*rand()/32767*255+1;a[1]=10*rand()/32767*a[0]…语句可用来产生a[0]与a[1]中的随机数。

或采用以下方式:(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。

操作系统——模拟页面置换算法(FIFO——先入先出、LRU——最近最少使用、LFU——最近。。。

操作系统——模拟页面置换算法(FIFO——先入先出、LRU——最近最少使用、LFU——最近。。。

操作系统——模拟页⾯置换算法(FIFO——先⼊先出、LRU——最近最少使⽤、LFU——最近。

操作系统——模拟页⾯置换算法(FIFO——先⼊先出、LRU——最近最少使⽤、LFU——最近最不常使⽤),计算置换率(包含程序框图)导语:1. FIFO页⾯置换算法:最简单的页⾯置换算法。

这种算法的基本思想是:当需要淘汰⼀个页⾯时,总是选择驻留主存时间最长的页⾯进⾏淘汰,即先进⼊主存的页⾯先淘汰。

(看时间)2. LRU页⾯置换算法:最近最少使⽤,简单来说就是将数据块中,每次使⽤过的数据放在数据块的最前端,然后将存在的时间最长的,也就是数据块的末端的数据置换掉。

(看时间)3. LFU页⾯置换算法:近期最少使⽤算法,选择近期最少访问的页⾯作为被替换的页⾯,如果⼀个数据在最近⼀段时间内使⽤次数很少,那么在将来⼀段时间内被使⽤的可能性也很⼩。

(看次数)4. 置换率与与缺页率不同。

置换率⽤置换次数算,缺页率⽤缺页中断次数算。

FIFO页⾯置换算法:Linux效果图(采⽤UOS + VScode + g++)程序框图C++代码(FIFO):#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int *analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int a[],int n,int x) //判断数组中是否已有x,若有返回其下标值,没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换,y是⽤来置换的页⾯,x是被置换的页⾯ {int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}int main() {int i;int maxanalogblock=-1;//模仿队列的定义int x;cout<<"请输⼊页框⼤⼩物理块数:\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩!"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数:\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩!"<<endl;return 0;}analogblock=new int[mnum];block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=-1;for (i=0;i<mnum;i++) block[i]=-1;///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下:\n";srand( (unsigned)time( NULL ) );//以time函数值(即当前时间)作为种⼦数,保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"先进先出(FIFO)页⾯置换算法,结果: \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号,输出当前数组元素cout<<"真实物理块情况:";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况:";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[maxanalogblock]=process[x];//新元素从尾部插⼊block[maxanalogblock]=process[x];//新元素从尾部插⼊cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 缺页中断调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 已存在直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//队列法插⼊(尾部元素出,新元素从头部⼊)cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 缺页中断页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0]<<endl; replace(process[x],mnum,analogblock[0]);//置换物理块中页⾯for (i=0;i<mnum-1;i++)LRU 页⾯置换算法:Linux 效果图(采⽤UOS + VScode + g++)程序框图C++代码(LRU): analogblock[i]=analogblock[i+1];analogblock[mnum-1]=process[x];//////////////////maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock 值count++;} else //若数组中存在待插⼊元素 {maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}}}//读⼀个序列号,输出当前数组元素cout<<"真实物理块情况:";for (i=0;i<mnum;i++) {if(block[i]!=-1) cout<<block[i]<<" ";}cout<<"模拟物理块情况:";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}cout<<endl<<"页⾯换算次数为:"<<count<<endl;cout<<"置换率为:"<<(float)count/pnum<<endl;return 0;}//g++ test71.cpp -o test71 -lpthread&&./test71#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int *analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int a[],int n,int x) //判断数组中是否已有x ,若有返回其下标值,没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换,y是⽤来置换的页⾯,x是被置换的页⾯ { int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}void move(int a[],int n,int i) //移动下标为i的元素到尾部 {int j;int m=a[i];for (j=i;j<n-1;j++)a[j]=a[j+1];a[n-1]=m;}int main() {int i;int maxanalogblock=-1;//模仿栈的定义int x;cout<<"请输⼊页框⼤⼩物理块数:\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩!"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数:\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩!"<<endl;return 0;}analogblock=new int[mnum];block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=-1;///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下:\n";srand( (unsigned)time( NULL ) );//以time函数值(即当前时间)作为种⼦数,保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"最近最少使⽤(LRU)页⾯置换算法,结果: \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号,输出当前数组元素cout<<"真实物理块情况:";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况:";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1LFU 页⾯置换算法:Linux 效果图(采⽤UOS + VScode + g++)程序框图 if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[maxanalogblock]=process[x];//新元素从尾部插⼊block[maxanalogblock]=process[x];//新元素从尾部插⼊cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 缺页中断 调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {move(analogblock,maxanalogblock,judge(analogblock,mnum,process[x]));//移动下标为i 的元素到尾部maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//栈法插⼊(第⼀个元素出,后⾯元素前移,新元素从尾部⼊)cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 缺页中断 页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0]<<endl; replace(process[x],mnum,analogblock[0]);//物理块中页⾯置换for (i=0;i<mnum-1;i++)analogblock[i]=analogblock[i+1];analogblock[mnum-1]=process[x];//////////////////maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock 值count++;} else //若数组中存在待插⼊元素 {move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i 的元素到尾部maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}}}//读⼀个序列号,输出当前数组元素cout<<"真实物理块情况:";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况:";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}cout<<endl<<"页⾯换算次数为:"<<count<<endl;cout<<"置换率为:"<<(float)count/pnum<<endl;return 0;}//g++ test72.cpp -o test72 -lpthread&&./test72C++代码(LFU):#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int **analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int *a[],int n,int x) //判断数组中是否已有x,若有返回其下标值,没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i][0])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换,y是⽤来置换的页⾯,x是被置换的页⾯ { int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}void move(int *a[],int n,int i) //移动下标为i的元素,⽐较访问次数次多少进⾏前进 {int j;int m=a[i][0];int m2=a[i][1];for (j=i;j<n-1;j++) {if(m2>=a[j+1][1]) {a[j][0]=a[j+1][0];a[j][1]=a[j+1][1];a[j+1][0]=m;a[j+1][1]=m2;}}}int main() {int i;int maxanalogblock=-1;//模仿栈的定义int x;//动态数组初始化cout<<"请输⼊页框⼤⼩物理块数:\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩!"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数:\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩!"<<endl;return 0;}analogblock=(int**) (new int[mnum]);block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=(int*) new int[2];//⽤于保存页⾯号和访问次数for (i = 0; i < mnum; i++) {analogblock[i][0]=-1;analogblock[i][1]=0;}///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下:\n";srand( (unsigned)time( NULL ) );//以time函数值(即当前时间)作为种⼦数,保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"最近最不常使⽤(LFU)页⾯置换算法,结果: \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号,输出当前数组元素cout<<"真实物理块情况:";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况:";for (i=0;i<mnum;i++) {if(analogblock[i][0]!=-1)cout<<analogblock[i][0]<<" ";//<<"访问次数"<<analogblock[i][1]<<" "}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[0][0]=process[x];//新元素从头部插⼊analogblock[0][1]=1;block[maxanalogblock]=process[x];//新元素从尾部插⼊move(analogblock,mnum,0);//移动下标为i的元素到相同访问次数页⾯的顶部cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 缺页中断调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {// move(analogblock,maxanalogblock,judge(analogblock,mnum,process[x]));//移动下标为i的元素到尾部analogblock[judge(analogblock,mnum,process[x])][1]++;move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i的元素到相同访问次数页⾯的顶部maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 已存在直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//栈法插⼊(新元素从头部⼊,替换掉头部)cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 缺页中断页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0][0]<<endl; replace(process[x],mnum,analogblock[0][0]);//物理块中页⾯置换analogblock[0][0]=process[x];analogblock[0][1]=1;move(analogblock,mnum,0);//移动下标为i的元素相同访问次数页⾯的顶部//////////////////maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock值count++;} else //若数组中存在待插⼊元素 {analogblock[judge(analogblock,mnum,process[x])][1]++;move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i的元素到相同访问次数页⾯的顶部maxanalogblock--;//因为没有插⼊新元素,回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问,页⾯"<<process[x]<<" 已存在直接访问"<<endl; }}}//读⼀个序列号,输出当前数组元素cout<<"真实物理块情况:";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况:";for (i=0;i<mnum;i++) {if(analogblock[i][0]!=-1)cout<<analogblock[i][0]<<" ";}cout<<endl<<"页⾯换算次数为:"<<count<<endl;cout<<"置换率为:"<<(float)count/pnum<<endl;return 0;}//g++ test73.cpp -o test73 -lpthread&&./test73。

操作系统实验页面置换算法实验

操作系统实验页面置换算法实验

淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求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%。

【操作系统】页面置换算法(最佳置换算法)(C语言实现)

【操作系统】页面置换算法(最佳置换算法)(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、设计两个程序模拟实现一个作业在内存中执行的页面置换,并计算缺页中断次数。

3、编制两种页面置换算法:1)FIFO页面置换算法;2)LRU页面置换算法三、实验原理:1、FIFO页面置换算法:总是选择在内存中驻留时间最长的一页将其淘汰。

2、LRU页面置换算法:选择最近一段时间内最长时间没有被访问过的页面予以淘汰。

四、参考程序:1、FIFO页面置换算法:#define M 4 /*m为系统分配给作业的主存中的页面数*/#define N 15#include <stdio.h>void main(){int a[M];/*定义内存页面数*/int b[N];/*定义总页面数*/int c[N];/*定义被淘汰的页面号*/int i,k,flag,count,m=0;printf("请输入作业序号:\n");for(i=0;i<N;i++) /*输入作业依次要访问的页号*/scanf("%d",&b[i]);printf("发生缺页的面号分别为:");for(i=0;i<M;i++)/*输出发生缺页中断的初始页号共m块*/ { a[i]=b[i];printf("%3d,",a[i]);}count=M;for(i=M;i<N;i++){ flag=0;for(k=0;k<M;k++)if(a[k]==b[i])flag=1;if(flag==0){ c[m]=a[0];m++;for(k=0;k<M-1;k++)a[k]=a[k+1];a[M-1]=b[i];count++;printf("%3d,",b[i]);}}printf("\n发生缺页的次数=%d\n",count);printf("\n缺页中断率=%.2f%%%\n",(float)count/N*100); printf("\n驻留内存的页号分别为:");for(i=0;i<M;i++)printf("%3d,",a[i]);printf("\n被淘汰的页号分别为:");for(i=0;i<m;i++)printf("%3d,",c[i]);}2、LRU页面置换算法:#define M 4 /*m为在主存中的页面数*/#define N 15#include <stdio.h>void main(){int a[M];/*定义内存页面数*/int b[N];int c[N];/*定义被淘汰的页面号*/int i,j,k,count,flag,m=0;printf("请输入作业序号:\n");for(i=0;i<N;i++)/*输入作业依次访问的页号*/ scanf("%d",&b[i]);printf("发生缺页的面号分别为:\n");for(i=0;i<M;i++){ a[i]=b[i];printf("%3d",a[i]);}count=M;在此处将程序补充完整/*代码补全*/for(i=M;i<N;i++){ flag=0;for(k=0;k<M;k++)if(a[k]==b[i]){ flag=1;for(j=k;j<M-1;j++)a[j]=a[j+1];a[M-1]=b[i];}if(flag==0){ c[m]=a[0];m++;for(k=0;k<M-1;k++)a[k]=a[k+1];a[M-1]=b[i];count++;printf("%3d,",b[i]);}}printf("\n发生缺页的次数=%d\n",count);printf("\n缺页中断率=%.2f%%%\n",(float)count/N*100);printf("\n驻留内存的页号分别为:");for(i=0;i<M;i++)printf("%d,",a[i]);printf("\n被淘汰的页号分别为:");for(i=0;i<m;i++)printf("%3d,",c[i]);}五、参考文献:1、《操作系统教程》,第3版,孙钟秀主编,高等教育出版社。

实验5 页式存储管理的页面置换算法模拟

实验5 页式存储管理的页面置换算法模拟

实验4 页式存储管理的页面置换算法模拟1.实验目的通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

2.实验环境装有操作系统Windows XP和开发工具VC++6.0,内存在256M以上的微机;或者:装有Linux(Fedora 7)操作系统和gcc编译器,内存在256M以上的微机。

3.实验内容(1)通过随机数产生一个指令序列,共320条指令。

指令的地址按下述原则生成:①50%的指令是顺序执行的;②25%的指令是均匀分布在前地址部分;③25%的指令是均匀分布在后地址部分;具体的实施方法是:①在[0,319]的指令地址之间随机选取一起点m;②顺序执行一条指令,即执行地址为m+1的指令;③在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m’;④顺序执行一条指令,其地址为m’+1的指令;⑤在后地址[m’+2,319]中随机选取一条指令并执行;⑥重复上述步骤①~⑤,直到执行320次指令。

(2)将指令序列变换为页地址流①设页面大小为1K;②分配内存容量为4K到32K;③用户虚存容量为32K。

在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:第0条~第9条指令为第0页(对应虚存地址为[0,9]);第10条~第19条指令为第1页(对应虚存地址为[10,19]);…………第310条~第319条指令为第31页(对应虚存地址为[310,319])。

按以上方式,用户指令可组成32页。

(3)计算先进先出(FIFO)算法或最近最少使用(LRU)算法在不同内存容量下的命中率。

其中,命中率=1-页面失效次数/页地址流长度4.实验要求(1)将FIFO或者LRU算法的源程序及程序执行结果写入实验报告;(2)将FIFO和LRU算法的工作机理写入实验报告。

代码:#include <stdio.h>#include <stdlib.h>#include <string.h>#ifndef _UNISTD_H#define _UNISTD_H#include <IO.H>#include <PROCESS.H>#endif#define TRUE 1#define FALSE 0#define INVALID -1#define total_instruction 320 //指令流长#define total_vp 32 //虚页长#define clear_period 50 //清周期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_type pfc[total_vp], //主存区页面控制结构数组*freepf_head, //主存区页面控制结构的空闲页面头指针*busypf_head, //主存区页面控制结构的忙页面头指针*busypf_tail; //主存区页面控制结构的忙页面尾指针int diseffect; //页错误计数器,初次把页面载入主存时也当做页错误int a[total_instruction]; //随即指令流数组int page[total_instruction]; //指令对应的页面号int offset[total_instruction]; //指令所在页面中的偏移量int initialize(int); //初始化页面结构数组和页面控制结构数组int FIFO(int); //先进先出算法int LRU(int); //最近最久未使用算法int OPT(int); //最佳置换算法int CLOCK(int); //简单时钟(钟表)算法int main( ){int s; //随机数int i;srand(10*getpid()); /*每次运行时进程号不同,用来作为初始化随机数队列的"种子"*/ s = (int)((float)(total_instruction-1)*(rand()/(RAND_MAX+1.0)));printf("\n------------随机产生指令流------------\n");for (i=0; i<total_instruction; i+=4) //产生指令队列{a[i]=s; //任选一指令访问点ma[i+1]=a[i]+1; //顺序执行一条指令a[i+2]=(int)((float)a[i]*(rand()/(RAND_MAX+1.0))); //执行前地址指令m'a[i+3]=a[i+2]+1; //顺序执行一条指令printf("%6d%6d%6d%6d\n", a[i],a[i+1],a[i+2],a[i+3]);s = (int)((float)((total_instruction-1)-a[i+2])*(rand()/(RAND_MAX+1.0))) + a[i+2];}printf("--------------------------------------\n");for (i=0;i<total_instruction;i++) //将指令序列变换成页地址流{page[i]=a[i]/10;offset[i]=a[i]%10;}printf("\n--不同页面工作区各种替换策略的命中率表--\n");printf("Page\t FIFO\t LRU\t OPT\t CLOCK\n");for(i=4;i<=32;i++) //用户内存工作区从个页面到个页面{printf(" %2d \t",i);FIFO(i);LRU(i);OPT(i);CLOCK(i);printf("\n");}return 0;}//初始化页面结构数组和页面控制结构数组//total_pf; 用户进程的内存页面数int initialize(int total_pf){int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; //置页面所在主存区的帧号为-1.表示该页不在主存中pl[i].counter=0; //置页面结构中的访问次数为pl[i].time=-1; //置页面结构中的上次访问的时间为-1 }for(i=0;i<total_pf-1;i++){pfc[i].next=&pfc[i+1]; //建立pfc[i-1]和pfc[i]之间的链接pfc[i].pfn=i; //初始化主存区页面的帧号}pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; //主存区页面控制结构的空闲页面头指针指向pfc[0] return 0;}//最近最久未使用算法//int total_pf; 用户进程的内存页面数int LRU (int total_pf){int MinT; //最小的访问时间,即很久没被访问过int MinPn; //拥有最小的访问时间的页的页号int i,j;int CurrentTime; //系统当前时间initialize(total_pf); //初始化页面结构数组和页面控制结构数组CurrentTime=0;diseffect=0;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) //页面失效{diseffect++; //页错误次数加if(freepf_head==NULL) //无空闲页面{MinT=100000;for(j=0;j<total_vp;j++){ //找出time的最小值,表明该页很久没被访问过if(MinT>pl[j].time&&pl[j].pfn!=INVALID){MinT=pl[j].time;MinPn=j;}}freepf_head=&pfc[pl[MinPn].pfn]; //最久没被访问过的页被释放pl[MinPn].pfn=INVALID; //最久没被访问过的页被换出主存pl[MinPn].time=-1; //最久没被访问过的页的访问时间置为无效freepf_head->next=NULL;}pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,把相应的页面换入主存,并把pfn改为相应的帧号pl[page[i]].time=CurrentTime; //令访问时间为当前系统时间freepf_head=freepf_head->next; //减少一个空闲页面}elsepl[page[i]].time=CurrentTime; //命中则刷新该单元的访问时间CurrentTime++; //系统当前时间加}printf("%6.3f\t",1-(float)diseffect/320);return 0;}//最佳置换算法//int total_pf; 用户进程的内存页面数int OPT(int total_pf){int i,j;int MaxD; //将来最近一次访问的距离的最大值(以时间单元度量)int MaxPn; //将来最近一次访问的距离的最大值的页号int dis; //距离计数器int dist[total_vp]; //距离数组,保存距离上一次访问的时间差距个数initialize(total_pf); //初始化页面结构数组和页面控制结构数组diseffect=0;for(i=0;i<total_instruction;i++){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]=100000; // 该页关联的距离值改为最大值elsedist[j]=0; //如果不在该页主存中,该页关联的距离值改为}dis=1; //初始距离值为for(j=i+1;j<total_instruction;j++) //从要替换的指令的下一条算起,{if(pl[page[j]].pfn!=INVALID &&pl[page[j]].counter==0) //如果该页在主存中,并且是将要最近访问的页//if(pl[page[j]].pfn!=INVALID && dist[page[j]]==100000) //此条语句原理与上相同{ dist[page[j]]=dis; //距离值改为displ[page[j]].counter=1; //使访问次数标志加,区别第一次访问和第二次访问}dis++;}MaxD=-1;for(j=0;j<total_vp;j++){pl[j].counter=0; //重置访问次数为if(MaxD<dist[j]) //查找将来最近一次访问的距离的最大值及其序号{MaxD=dist[j];MaxPn=j;}}freepf_head=&pfc[pl[MaxPn].pfn]; //替换将来一段时间最久访问的页freepf_head->next=NULL;pl[MaxPn].pfn=INVALID;}pl[page[i]].pfn=freepf_head->pfn; //把当前页换入主存中,并且把当前页的pfn改为换入页的帧号,freepf_head=freepf_head->next; //减少一个空闲页面}//if}//forprintf("%6.3f\t",1-(float)diseffect/320);return 0;}//简单时钟算法//int total_pf; 用户进程的内存页面数int CLOCK(int total_pf){int i;int use[total_vp]; //使用位int swap;swap=0; //发生替换initialize(total_pf);pfc_type *pnext; //时钟指针pfc_type *head; //队列头指针pnext=freepf_head;head=freepf_head;for(i=0;i<total_vp;i++){use[i]=0;} //初始化使用位为diseffect=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INVALID) //页面失效,不在主存中{diseffect++; //页错误次数加if(freepf_head==NULL) //无空闲页面{while(use[pnext->pfn]==1) //若时钟指针指向的页的使用位为,则改为并跳过{use[pnext->pfn]=0;pnext=pnext->next;if(pnext==NULL) pnext=head; //如果时钟指针到达队列尾部,重新返回头部}//换出被替换的页pl[pnext->pn].pfn=INVALID;swap=1;}if(use[pnext->pfn]==0){ //如果使用位为,则换入相应的页pl[page[i]].pfn=pnext->pfn; //页面结构中要标记帧号pnext->pn=page[i]; //页面控制结构中要标记页号use[pnext->pfn]=1; //重置使用位为pnext=pnext->next; //时钟指针下移if(pnext==NULL) pnext=head; //如果时钟指针到达队列尾部,重新返回头部if(swap==0){ freepf_head=freepf_head->next; } }}else{//页面在主存中use[pl[page[i]].pfn]=1; //刷新使用位为}}printf("%6.3f\t",1-(float)diseffect/320);return 0;}//先进先出算法版本//int total_pf; 用户进程的内存页面数//实现细节由CLOCK算法退化而来,与FIFO同效果int FIFO(int total_pf){int i;int use[total_vp];int swap=0;initialize(total_pf);pfc_type *pnext,*head;pnext=freepf_head;head=freepf_head;for(i=0;i<total_vp;i++){use[i]=0;}diseffect=0;for(i=0;i<total_instruction;i++){if (pl[page[i]].pfn==INVALID) //页面失效,不在主存中{diseffect++;if(freepf_head==NULL) //无空闲页面{while(use[pnext->pfn]==1){use[pnext->pfn]=0;pnext=pnext->next;if(pnext==NULL) pnext=head;}//换出被替换的页pl[pnext->pn].pfn=INVALID;swap=1;}if(use[pnext->pfn]==0){ //如果使用位为,则换入相应的页pl[page[i]].pfn=pnext->pfn; //页面结构中要标记帧号pnext->pn=page[i]; //页面控制结构中要标记页号use[pnext->pfn]=1; //重置使用位为pnext=pnext->next;if(pnext==NULL) pnext=head;if(swap==0){ freepf_head=freepf_head->next; }}}}printf("%6.3f\t",1-(float)diseffect/320);return 0;}结果:LRU:如果一个数据在最近一段时间没有被访问到,那么在将来它被访问的可能性也很小。

操作系统课程实验报告编程模拟页面置换算法

操作系统课程实验报告编程模拟页面置换算法

湖南师范大学树达学院操作系统课程实验报告题目编程模拟页面置换算法理工系09级电子商务专业姓名学号指导教师张楚才2011年5月 5 日实验题目:编程模拟页面置换算法实验要求:利用C语言分别实现先进先出置换算法FIFO、最佳置换算法OPT、最近最久未使用置换算法LRU。

要求在任意给定的页面访问序列和内存的物理块数下,输出每种算法下的缺页率。

例如,假定系统为某进程分配了3个物理块,进程运行时的页面走向为7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1,开始时3个物理块均为空,分别求出每种算法下的缺页率。

#include<stdio.h>void Print(int bc[],int blockCount){for(int i=0;i<blockCount;i++){printf("%d ",bc[i]);}printf("\n");}bool Travel(int bc[],int blockCount,int x){bool is_found=false;int i;for(i=0;i<blockCount;i++){if(bc[i]==x){is_found=true;break;}}return is_found;}void FIFO(int pc[],int bc[],int pageCount,int blockCount)printf("0:FIFO置换算法\n");int i;if(pageCount<=blockCount){printf("缺页次数为0\n");printf("缺页率为0\n");}else{int noPage=0;int p=0;for(i=0;i<pageCount;i++){//printf("引用页:%d\n",pc[i]);if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{if(p==blockCount){p=0;}bc[p]=pc[i];p++;}noPage++;//printf("物理块情况:\n");//Print(bc,blockCount);}//printf("\n");}printf("FIFO缺页次数为:%d\n",noPage);printf("FIFO缺页率为:%.2f%%\n",(float)noPage/pageCount*100);}}int FoundMaxNum(int a[],int n){int k,j;k=a[0];j=0;for (int i=0;i<n;i++){if(a[i]>=k){k=a[i];j=i;}}return j;}void LRU(int pc[],int bc[],int pageCount,int blockCount) {printf("1:LRU置换算法\n");if(pageCount<=blockCount){printf("缺页次数为0\n");printf("缺页率为0\n");}else{int noPage=0;int i,j,m;int bc1[100];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){// printf("引用页:%d\n",pc[i]);if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];for(int p=0;p<=i;p++){bc1[p]++;}}else{for(j=0;j<blockCount;j++){bc1[j]++;}int k=FoundMaxNum(bc1,blockCount);bc[k]=pc[i];bc1[k]=1;}noPage++;//printf("物理快情况:\n");//Print(bc,blockCount);}else if(Travel(bc,blockCount,pc[i])){if(i<blockCount){for(j=0;j<=i;j++){bc1[j]++;}for(m=0;m<=i;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}else{for(j=0;j<blockCount;j++)bc1[j]++;}for(m=0;m<blockCount;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}}//printf("\n");}printf("LRU缺页次数为:%d\n",noPage);printf("LRU缺页率为:%.2f%%\n",(float)noPage/pageCount*100);}}void Optiomal(int pc[],int bc[],int pageCount,int blockCount){printf("2:最佳置换算法\n");if(pageCount<=blockCount){printf("缺页次数为0\n");printf("缺页率为0\n");}else{int noPage=0;int i,j,k;for(i=0;i<pageCount;i++){// printf("引用页:%d\n",pc[i]);if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}{int max=0;int blockIndex;;for(j=0;j<blockCount;j++){for(k=i;k<pageCount;k++){if(bc[j]==pc[k]){break;}}if(k>=max){max=k;blockIndex=j;}}bc[blockIndex]=pc[i];}noPage++;//printf("物理快情况:\n");//Print(bc,blockCount);}//printf("\n");}printf("OPT缺页次数为:%d\n",noPage);printf("OPT缺页率为:%.2f%%\n",(float)noPage/pageCount*100);}}int main(){int pageCount,blockCount,i,pc[100];printf("输入页面数\n");scanf("%d",&pageCount);printf("输入页面走向\n");for(i=0;i<pageCount;i++){scanf("%d",&pc[i]);}blockCount=3;//物理块数int bc1[100];printf("\n");FIFO(pc,bc1,pageCount,blockCount);int bc2[100];printf("\n");LRU(pc,bc2,pageCount,blockCount);int bc3[100];printf("\n");Optiomal(pc,bc3,pageCount,blockCount);return 0;}。

操作系统实验报告_页面置换算法模拟

操作系统实验报告_页面置换算法模拟

操作系统实验报告_页面置换算法模拟学生实验报告姓名: 年级专业班级学号成绩验证设计实验3 请求分页系统的页面实验类型课程名称实验名称操作系统综合创新置换算法【实验目的、要求】1.通过编程实现请求分页存储管理系统的Optimal、FIFO、LRU调度算法,使学生掌握计算机虚拟存储管理中有关缺页处理方法等内容,巩固有关虚拟存储管理的知识。

2.了解Windows2000/XP中内存管理机制,掌握页式虚拟存储技术。

3.理解内存分配原理,特别是以页面为单位的虚拟内存分配方法。

【实验内容】在Windows XP或Windows 2000等操作系统环境下,使用VC、VB、Delphi、java或C等编程语言,实现请求分页存储管理系统的Optimal、FIFO、LRU调度算法。

【实验环境】(含主要设计设备、器材、软件等)计算机 C语言编程软件【实验步骤、过程】(含原理图、流程图、关键代码,或实验过程中的记录、数据等)1.启动计算机,运行C语言编程软件。

2.分析理解页面的几种基本算法的特点和原理,在纸上画出原理图。

3.编辑源程序,关键代码如下。

(1)先进先出页面置换算法。

#include<stdio.h>void main(){int i,n,t,k=3,a[100];scanf("%d",&n);for(i=0;i<n;i++)scanf("%d",&a[i]);for(i=3;i<n;i++)if(a[i]!=a[0]&&a[i]!=a[1]&&a[i]!=a[2]) //该页面在内存中,不需要置换。

{t=a[i];a[i]=a[k%3]; //通过对k值对3取余的值来确定需要置换的当前页面。

a[k%3]=t;k++; //仅当发生了页面置换时,k的值才发生改变。

printf("%d %d %d\n",a[0],a[1],a[2]);}else{printf("%d %d %d\n",a[0],a[1],a[2]);}}(2)最佳置换算法#include<stdio.h>void main(){int i,j,,n,a[100];int c1,c2,c3; // 标志该页面再次被访问时在引用串中的位置int p,k,r;printf("请输入页面数:\n");scanf("%d",&n);printf("请输入页面号引用串:\n");for(i=0;i<n;i++)scanf("%d",&a[i]);for(j=3;j<n;j++){if((a[j]!=a[0])&&(a[j]!=a[1])&&(a[j]!=a[2])) //页面在内存不发生置换~{for(p=j;p<n;p++)if(a[0]==a[p]){ c1=p;break; //跳出循环,直接置c1=n!} else c1=n; //标志该页面再次被访问时在引用串中的位置~若该页面不会再次被访问,则将c1置为最大n!for(k=j;k<n;k++)if(a[1]==a[k]){ c2=k;break; }elsec2=n;for(r=j;r<n;r++)if(a[2]==a[r]){ c3=r;break;}else c3=n; //通过比较c1,c2,c3的大小确定最长时间内不再访问的页面~if((c1>c2)&&(c1>c3)||(c1==c3)||(c1==c2)) //当前a[0]页面未来最长时间不再访问!{t=a[j];a[j]=a[0];a[0]=t; //把当前访问页面和最佳页面交换~printf("%d %d %d\n",a[0],a[1],a[2]);}if((c2>c1)&&(c2>c3)||(c2==c3)) //当前a[1]页面未来最长时间不再访问!{t=a[j];a[j]=a[1];a[1]=t;printf("%d %d %d\n",a[0],a[1],a[2]);}if((c3>c1)&&(c3>c2)) //当前a[2]页面未来最长时间不再访问!{t=a[j];a[j]=a[2];a[2]=t;printf("%d %d %d\n",a[0],a[1],a[2]); //输出置换后页框中的物理块组成~}}elseprintf("%d %d %d\n",a[0],a[1],a[2]);}}(3)LRU算法。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验五. 请求页式存储管理的模拟[实验内容]:熟悉虚拟存储管理的各种页面置换算法,并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法(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 ,现在为你执行对应操作。

相关文档
最新文档