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

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

实验编号４名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计，以便：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。

实验7页面置换算法的模拟实现三、实验内容与步骤1、定义相关数据#define InitPysiBlocks 4#define MaxPages 16：unsigned int PysicalBlocks[InitPysiBlocks] = { 0 };unsigned int PageSequence[30] = { 1,2,3,6,4,7,3,2,1,4,7,5,6,5,2,1};2、按照教材中FIFO、LRU算法描述进行算法设计unsigned FIFO(unsigned *py,unsigned *pg)unsigned LRU(unsigned *py,unsigned *pg)3、查看运行结果是否与手工计算一致。

四、实验材料的提交与成绩评定1.代码：#include<iostream>usingnamespace std;#define InitPysiBlocks 4#define MaxPages 16unsignedint PysicalBlocks[InitPysiBlocks] = { 0 };unsignedint PageSequence[30] = { 1,2,3,6,4,7,3,2,1,4,7,5,6,5,2,1 };//FIFO算法unsigned FIFO(unsigned *py, unsigned *pg){//初始化填满数据for (int i = 0; i <InitPysiBlocks; i++){py[i] = pg[i];}cout <<"FIFO置换过程如下："<< endl;cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;//判断新获取数据进来的时间int time[4] = { 3,2,1,0 };//开始检测for (int i = 4; i <MaxPages; i++){for (int j = 0; j <InitPysiBlocks; j++){//如果新获取的已存在，直接输出if (py[0] == pg[i] || py[1] == pg[i] || py[2] == pg[i] || py[3] == pg[i]){cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;break;}else{for (int k = 0; k < 4; k++){if (time[k] == 3){time[k] = 0;py[k] = pg[i];}else{time[k]++;}}cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;break;}}}cout <<"置换结束"<< endl;return 0;}//LRU算法//LRU辅助函数:返回除某一排下标后数组中最大元素下标int Max(unsigned *py, int te){int max = 0;int index = -1;for (int i = 0; i <InitPysiBlocks; i++){if (i == te){continue;}else{if (py[i] > max){max = py[i];index = i;}else{continue;}}}return index;}unsigned LRU(unsigned *py, unsigned *pg){//初始化填满数据for (int i = 0; i <InitPysiBlocks; i++){py[i] = pg[i];}cout <<"LRU置换过程如下："<< endl;cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;//判断新获取数据进来的时间unsigned time[4] = { 3,2,1,0 };//统计命中次数int count[4] = { 0 };//开始检测for (int i = InitPysiBlocks; i < 16; i++){for (int j = 0; j <InitPysiBlocks; j++){//如果新获取的已存在，直接输出,并将对应的命中变为1if (py[0] == pg[i] || py[1] == pg[i] || py[2] == pg[i] || py[3] == pg[i]){cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;if (py[0] == pg[i]){count[0] = 1;}elseif (py[1] == pg[i]){count[1] = 1;}elseif (py[2] == pg[i]){count[2] = 1;}elseif (py[3] == pg[i]){count[3] = 1;}else{count[4] = { 0 };}break;}else{if (count[0] == 1){//返回数组中最大值int temp = Max(time, 0);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[0] = 0;}elseif (count[1] == 1){//返回数组中最大值int temp = Max(time, 1);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[1] = 0;}elseif (count[2] == 1){//返回数组中最大值int temp = Max(time, 2);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[2] = 0;}elseif (count[3] == 1){//返回数组中最大值int temp = Max(time, 3);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[3] = 0;}else{//返回数组中最大值int temp = Max(time, -1);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;}cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;break;}}}cout <<"置换结束"<< endl;return 0;}int main(){FIFO(PysicalBlocks, PageSequence);LRU(PysicalBlocks, PageSequence);return 0;}2.运行截图：运行结果与手工计算结果一致。

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

计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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）计算访问命中率。

（命中率＝１－页面失效次数／页地址流长度）。

关键字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算法。