实验五存储管理常用页面置换算法模拟实验
实验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时，试计算采用先进先出淘汰算法时的缺页率(假设开始执行时主存中没有页面)，并将所得结果填表。
页面置换算法模拟实验报告材料
实验编号４名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计，以便：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。
存储管理模拟实现
存储管理模拟实现On March 12, 2022, study standards and apply standards.一、实验目的存储管理的主要功能之一是合理地分配空间;请求页式管理是一种常用的虚拟存储管理技术;本实验的目的是通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式管理的页面置换算法;二、实验内容编程实现页面置换算法,要求输出页面的置换过程,具体可以编程实现OPT、FIFO和LRU算法;1．过随机数产生一个指令序列,共320条指令;其地址按下述原则生成：①50%的指令是顺序执行的；②25%的指令是均匀分布在前地址部分；③25%的指令是均匀分布在后地址部分；具体的实施方法是：A.在0,319的指令地址之间随机选区一起点M;B.顺序执行一条指令,即执行地址为M+1的指令；C.在前地址0,M+1中随机选取一条指令并执行,该指令的地址为M’;D.顺序执行一条指令,其地址为M’+1；E.在后地址M’+2,319中随机选取一条指令并执行；F.重复A—E,直到执行320次指令;2．指令序列变换成页地址流设：1页面大小为1K；（2）用户内存容量为4页到32页；（3）用户虚存容量为32K;在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为：第0条—第9条指令为第0页对应虚存地址为0,9；第10条—第19条指令为第1页对应虚存地址为10,19；;;;;;;;;;;;;;;;;;;;;;第310条—第319条指令为第31页对应虚存地址为310,319；按以上方式,用户指令可组成32页;3. 计算并输出下述各种算法在不同内存容量下的命中率;A.FIFO先进先出的算法B.LRU最近最少使用算法C．LFU最少访问页面算法三、实验要求1、需写出设计说明；2、设计实现代码及说明3、运行结果；四、主要实验步骤1、分析算法结构；画出算法的流程图,即设计说明；根据画出的流程图使用C语言编写相应的代码代码过长,放到最后；程序主要由main函数和以下几个函数组成：void initialization;初始化内存数据void FIFO;FIFO先进先出算法；void LRU;LRU最久未使用算法；void LFU;LFU最近最久未使用算法：流程图如下：页面置换算法整体结构FIFO页面置换算法LRU页面置换算法LFU页面置换算法2、设计说明及源代码FIFO算法设计说明：按照所要求的产生随机指令序列,存放在order320这个数组中;通过循环产生这些随机指令,每产生一条都要进行下列判断：是否和内存中即mem _volume4中存放的页面相同,如果相同则不做任何操作,如果不相同,则产生缺页,相应的缺页次数加一,按照fcfs将最先进入内存的页数淘汰,并将该页写到内存中去;重复上面的操作直到完成这320条指令;源代码：pp : 定义控制台应用程序的入口点;.3fpp : 定义控制台应用程序的入口点;.3fpp : 定义控制台应用程序的入口点;//include ""int _tmainint argc, _TCHAR argv{return 0;}include <>include <>include <>define N 5 //定义运行次数void main{int order320,count32={0},compare4={0},mem_volume4={100,100,100,100};//compare数组中存放了每次要比较的四个内存块中页数的调用次数int l=0,i=0,j,k=0,cx=0;int min,num=0,n,sign=0,add=0;float value=0,sum=0;srandtimeNULL;forcx=0;cx<N;cx++{whilei<320{orderi=rand%320;forj=0;j<4;j++iforderi+1/10==mem_volumej{n=orderi+1/10;countn+=1;sign=1; //相同执行加1操作}ifsignsign=0;else{l++;ifmem_volume3==100{mem_volume3=orderi+1/10;n=orderi+1/10;countn+=1;}else{ min=1000;fornum=0;num<4;num++{k=mem_volumenum;comparenum=countk;ifcomparenum<min{min=comparenum;j=num; //通过比较确定最少使用的页数,}}mem_volumej=orderi+1/10;}}i++;orderi=rand%orderi-1+2;forj=0;j<4;j++iforderi/10==mem_volumej{n=orderi/10;countn+=1;sign=1;}ifsignsign=0;else {l++;ifmem_volume2==100{mem_volume2=orderi+1/10;n=orderi+1/10;countn+=1;}else{ min=1000;fornum=0;num<4;num++{k=mem_volumenum;comparenum=countk;ifcomparenum<min{min=comparenum;j=num;}}mem_volumej=orderi+1/10;}}i++;orderi=orderi-1+1;forj=0;j<4;j++iforderi/10== mem_volumej{n=orderi/10;countn+=1;sign=1;}ifsignsign=0;else{l++;ifmem_volume1==100{mem_volume1=orderi+1/10;n=orderi+1/10;countn+=1;}else{ min=1000;fornum=0;num<4;num++{k=mem_volumenum;comparenum=countk;ifcomparenum<min{min=comparenum;j=num;}}mem_volumej=orderi+1/10;}}i++;orderi=rand%319-orderi-1-2+orderi-1+2;forj=0;j<4;j++iforderi/10==mem_volume0{n=orderi/10;countn+=1;sign=1;}ifsignsign=0;else {l++;ifmem_volume0==100{mem_volume0=orderi+1/10;n=orderi+1/10;countn+=1;}else{ min=1000;fornum=0;num<4;num++{k=mem_volumenum;comparenum=countk;ifcomparenum<min{min=comparenum;j=num;}}mem_volumej=orderi+1/10;}}i++;}value=l/100;add=add+l;sum=sum+value;}printf" LFU页面置换算法 \n";printf" 最后一次指令序列 ";fori=0;i<320;i++{ifi%10==0printf"\n";printf"%5d",orderi;}printf"\n";printf"\n";printf"\t%d次的平均缺页数为%d\n\t%d次的平均缺页率为%.3f%%",N,add/10,N,sum/10;printf"\n";}五、实验数据及处理结果FIFO页面置换算法运行结果：LRU页面置换算法运行结果：LFU页面置换算法运行结果：。
实验5页面置换算法
实验5页⾯置换算法实验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命中？N内存页⾯满？Y 最先进⼊的进程退出内存页⾯N当前调⼊页⾯进⼊内存页⾯Y 命中次数+1N完？退出Y⼦进程2命中？N内存页⾯满？Y 被访问次数最少的进程退出内存页⾯N当前调⼊页⾯进⼊内存页⾯Y 命中次数+1，命中页⾯访问数+1N逻辑页⾯读完？退出Y五、运⾏结果及其说明FIFO:LRU:：六、回答以下问题：①⽗进程、⼦进程之间的并发执⾏的过程⽗进程与⼦进程之间的并发执⾏宏观并⾏，微观串⾏。
实验五虚拟内存页面置换算法
实验五虚拟内存页⾯置换算法实验五虚拟内存页⾯置换算法⼀：实验⽬的通过这次实验，加深对虚拟内存页⾯置换概念的理解，进⼀步掌握先进先出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表⽰的是物理块中没有页⾯。
页面置换算法模拟实验报告
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算法
常用页面置换算法模拟实验
实验环境
Windows xp 、Microsoft Visual c++ 6.0
实验目的与要求：
通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特 点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并 比较它们的效率。
实验内容：
设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率。
struct Pro { int num,time; };
二、 输入实际页数
函数名称：int Input(int m,Pro p[M]) 函数功能：输入实际页数，并输入各页面号
三、 查找页面是否存在
函数名称：int Search(int e,Pro *page1)
四、 找出离现在时间最长的页面
函数名称：int Max(Pro *p Nhomakorabeage1)
五、 比较页面
函数名称：int Compfu(Pro *page1,int i,int t,Pro p[M])
六、 打印当前的页面
函数名称：void print(Pro *page1)
七、 主函数
函数名称：int main() 1、 输入可用内存页面数 2、 初试化页面基本情况 3、 选择置换页面算法：FIFO 页面置换、LRU 页面置换、OPT 页面置换 显示页面置换情况 4、 5、 输出缺页次数和缺页率 6、 按其它键结束程序。
实验总结：
1.最佳淘汰算法（OPT） 2.先进先出的算法（FIFO） 3.最近最久未使用算法（LRU） 命中率＝１－页面失效次数／页地址流长度
1、一个算法的实现，要考虑很多的全面，要想写好算法，必须将数据结构和 C 语言学习好。
《FIFO算法来模拟实现页面的置换》实验报告
struct pageInfor
{
int content;//页面号
int timer;//被访问标记
};
class PRA
{
public:
PRA(void);
int findSpace(void); //查找是否有空闲内存
int findExist(int curpage); //查找内存中是否有该页面
FIFO算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序连接成一个队列，并设置一个替换指针，使它总指向最老的页面。
pageInfor * page; //页面号串
private:
}
运行界面：
总结
在进程运行过程中，若其所访问的页面不存在内存而需要把它们调入内存，但内存已无空闲时，为了保证该进程能够正常运行，系统必须从内存中调出一页程序或数据送磁盘的对换区中。但应调出哪个页面，需根据一定的算法来确定，算法的好坏，直接影响到系统的性能。
int findReplace(void); //查找应予置换的页面
void display(void); //显示
void FIFO(void); //FIFO算法
void BlockClear(void);//BLOCK清空，以便用另一种方法重新演示
pageInfor * block; //物理块
《FIFO算法来模拟实现页面的置换》实验报告
实验
时间
2011年05月16日
实验人
虎胆英侠
专业
计算机
学号
实验
名称
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值，表示该虚页的最后一次被访问时间。
存储管理模拟实现
一、实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。
二、实验内容编程实现页面置换算法，要求输出页面的置换过程，具体可以编程实现OPT、FIFO和LRU算法。
1．过随机数产生一个指令序列，共320条指令。
其地址按下述原则生成：①50%的指令是顺序执行的；②25%的指令是均匀分布在前地址部分；③25%的指令是均匀分布在后地址部分；#具体的实施方法是：A.在[0，319]的指令地址之间随机选区一起点M;B.顺序执行一条指令，即执行地址为M+1的指令；C.在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’;D.顺序执行一条指令，其地址为M’+1；E.在后地址[M’+2，319]中随机选取一条指令并执行；F.重复A—E，直到执行320次指令。
2．指令序列变换成页地址流设：（1）页面大小为1K；（2）用户内存容量为4页到32页；（3）用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条—第9条指令为第0页（对应虚存地址为[0，9]）；第10条—第19条指令为第1页（对应虚存地址为[10，19]）；。
第310条—第319条指令为第31页（对应虚存地址为[310，319]）；按以上方式，用户指令可组成32页。
3. 计算并输出下述各种算法在不同内存容量下的命中率。
A.FIFO先进先出的算法B.LRU最近最少使用算法C．LFU最少访问页面算法三、实验要求1、需写出设计说明；2、设计实现代码及说明3、运行结果；四、主要实验步骤1、分析算法结构；画出算法的流程图，即设计说明；根据画出的流程图使用C语言编写相应的代码（代码过长，放到最后）；程序主要由main函数和以下几个函数组成：void initialization();初始化内存数据void FIFO();FIFO先进先出算法；void LRU();LRU最久未使用算法；void LFU();LFU最近最久未使用算法：流程图如下：页面置换算法整体结构FIFO页面置换算法LRU页面置换算法LFU页面置换算法2、设计说明及源代码FIFO算法设计说明：按照所要求的产生随机指令序列，存放在order[320]这个数组中。
请求页式存储管理中常用页面置换算法模拟
计算机操作系统实验报告济南大学信息科学与技术学院2013年xx月xx日一、实验概述1. 实验名称请求页式存储管理中常用页面置换算法管理2. 实验目的（1）了解内存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。
（5）了解页面大小和内存实际容量对命中率的影响3. 实验内容（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；（2）实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟；（3）使用某种编程语言模拟页面置换算法。
二、实验环境C语言三、实验过程1. 设计思路和流程图选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换2. 算法实现（1）OPT基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组next[mSIZE]记录物理块中对应页面的最后访问时间。
每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。
（2）FIFO基本思想：是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。
或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最小的页面。
(3)LRU基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组flag[10]标记页面的访问时间。
每当使用页面时，刷新访问时间。
发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。
3.源程序并附上注释#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 designBy();void download();void mDelay(unsigned int Delay);/*主函数*/void main(){int i,k,code;system("color 0A");designBy();printf("┃请按任意键进行初始化操作... ┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");printf(" >>>");getch();system("cls");system("color 0B");printf("请输入物理块的个数(M<=10)：");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100)：");scanf("%d",&pSIZE);puts("请依次输入页面号引用串(连续输入，无需隔开)：");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);download();system("cls");system("color 0E");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");system("color 0A");designBy(); /*显示设计者信息后退出*/printf("┃谢谢使用页面置换算法演示器! 正版授权㊣┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");exit(0);default:printf("输入错误，请重新输入：");}printf("按任意键重新选择置换算法：>>>");getch();system("cls");}while (code!=4);getch();}/*载入数据*/void download(){int i;system("color 0D");printf("╔════════════╗\n");printf("║正在载入数据，请稍候!!!║\n");printf("╚════════════╝\n");printf("Loading...\n");printf(" O");for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++){mDelay((pSIZE+mSIZE)/2);printf(">");}printf("\nFinish.\n载入成功，按任意键进入置换算法选择界面：>>>");getch();}/*设置延迟*/void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}/*显示设计者信息*/void designBy(){printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("┃课题三：页面置换算法┃\n");printf("┃学号：20111214034 ┃\n");printf("┃姓名：韩瑶┃\n");printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"); }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]);}/*每行显示20个*/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; /*记录置换次数*//*前mSIZE个数直接放入*/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; /*记录置换次数*//*前mSIZE个数直接放入*/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; /*记录该页的访问时间*/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 OPT(){int memery[10]={0};int next[10]={0}; /*记录下一次访问时间*/int i,j,k,l,m;int max; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[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++;/*得到物理快中各页下一次访问时间*/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;/*下一次访问时间都为pSIZE,则置换物理块中第一个*/memery[max]=page[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);}6. 程序运行时的初值和运行结果1. 按任意键进行初始化：2. 载入数据：3. 进入置换算法选择界面：4.运算中延迟操作5.三种算法演示结果：四、实验体会掌握了一般的调度算法，了解了页面大小和内存实际容量对命中率的影响（英文版）Two regulations promulgated for implementation is in the party in power for a long time and the rule of law conditions, the implementation of comprehensive strictly strategic plan, implementation in accordance with the rules and discipline to manage the party, strengthen inner-party supervision of major initiatives. The two regulations supporting each other, the < code > adhere to a positive advocate, focusing on morality is of Party members and Party leading cadres can see, enough to get a high standard; < rule > around the party discipline, disciplinary ruler requirements, listed as "negative list, focusing on vertical gauge, draw the party organizations and Party members do not touch the" bottom line ". Here, the main from four square face two party rules of interpretation: the first part introduces two party Revised regulations the necessity and the revision process; the second part is the interpretation of the two fundamental principles of the revision of laws and regulations in the party; the third part introduces two party regulations modified the main changes and needs to grasp several key problems; the fourth part on how to grasp the implementation of the two regulations of the party. < code > and < Regulations > revised the necessity and revisedhistory of the CPC Central Committee the amendment to the Chinese Communist Party members and leading cadres honest politics several guidelines > and < Chinese Communist Party discipline and Punishment Regulations > column 1 by 2015 to strengthen party laws and regulations focus. Two party regulations revision work lasted a Years, pooling the wisdom of the whole party, ideological consensus, draw historical experience, respect for the wisdom of our predecessors, which reflects the unity of inheritance and innovation; follow the correct direction, grasp the limited goals, adhere to the party's leadership, to solve the masses of the people reflect a focus on the problem. The new revision of the < code > and < rule >, reflects the party's 18 and the eighth session of the third, the spirit of the fourth plenary session, reflecting the experience of studying and implementing the General Secretary Xi Jinping series of important speech, reflects the party's eighteen years comprehensive strictly practice. (a) revised two regulations of the party need of < the ICAC guidelines > in < in 1997 Leaders as members of the Communist Party of China clean politics certain criteria (Trial) > based on revised, the promulgation and implementation of January 2010, to strengthen the construction of the contingent of leading cadres play animportant role. But with the party to manage the party strictly administering the deepening, has not been able to fully meet the actual needs. Content is too complicated, "eight prohibition, 52 are not allowed to" hard to remember, and also difficult to put into practice; the second is concisely positive advocated by the lack of prohibited provisions excessive, no autonomy requirements; the third is banned terms and discipline law, both with the party discipline, disciplinary regulations repeat and Criminal law and other laws and regulations repeat; the fourth is to "clean" the theme is not prominent, not for the existing problems, and is narrow, only needle of county-level leading cadres above. < rule > is in 1997 < Chinese Communist Party disciplinary cases (Trial) > based on revision, in December 2003 the promulgation and implementation, to strengthen the construction of the party play very important role. Along with the development of the situation, which many provisions have been unable to fully meet the comprehensive strictly administering the practice needs. One is Ji law, more than half of the provisions and criminal law and other countries laws and regulations Repetition; two is the political discipline regulations is not prominent, not specific, for violation of the party constitution, damage theauthority of Party Constitution of misconduct lack necessary and serious responsibility to pursue; third is the main discipline for the leading cadres, does not cover all Party members. Based on the above situation, need to < the criterion of a clean and honest administration > and < rule > the two is likely to be more relevant regulations first amendment. By revising, really put the authority of Party discipline, the seriousness in the party tree and call up the majority of Party members and cadres of the party constitution of party compasses party consciousness. (II) two party regulations revision process the Central Committee of the Communist Party of China attaches great importance to two regulations revision . Xi Jinping, general books recorded in the Fifth Plenary Session of the eighth session of the Central Commission for Discipline Inspection, on the revised regulations < > made clear instructions. According to the central deployment, the Central Commission for Discipline Inspection from 2014 under six months begin study two regulations revision. The Standing Committee of the Central Commission for Discipline Inspection 4 review revised. Comrade Wang Qishan 14 times held a special meeting to study two regulations revision, amendment clarifies the direction, major issues of principle, path and target,respectively held a forum will listen to part of the province (area) secretary of the Party committee, Secretary of the Discipline Inspection Commission, part of the central ministries and state organs DepartmentThe first party committee is mainly responsible for people, views of experts and scholars and grassroots party organizations and Party members. Approved by the Central Committee of the Communist Party of China, on 7 September 2015, the general office of the Central Committee of the Party issued a notice to solicit the provinces (autonomous regions, municipalities) Party, the central ministries and commissions, state ministries and commissions of the Party (party), the General Political Department of the military, every 3 people organization of Party of two regulations revision opinion. Central Commission for Discipline Inspection of extensive solicitation of opinions, careful study, attracting, formed a revised sent reviewers. In October 8 and October 12, Central Committee Political Bureau Standing Committee and the Political Bureau of the Central Committee After consideration of the two regulations revised draft. On October 18, the Central Committee of the Communist Party of China formally issued two regulations. Can say, two laws amendment concentrated thewisdom of the whole party, embodies the party. Second, < code > and < Regulations > revision of the basic principles of two party regulations revision work and implement the party's eighteen, ten eight plenary, the spirit of the Fourth Plenary Session of the Eleventh Central Committee and General Secretary Xi Jinping important instructions on the revised < low political criterion > and < Regulations >, highlighting the ruling party characteristics, serious discipline, the discipline quite in front of the law, based on the current, a long-term, advance as a whole, with Bu Xiuding independent < rule > and < rule >. Main principle is: first, adhere to the party constitution to follow. The constitution about discipline and self-discipline required specific, awaken the party constitution of party compasses party consciousness, maintaining the authority of the constitution. General Secretary Xi Jinping pointed out that "no rules, no side round. Party constitution is the fundamental law, the party must follow the general rules. In early 2015 held the eighth session of the Central Commission for Discipline Inspection Fifth Plenary Session of the 16th Central Committee, Xi Jinping again pointed out that constitution is the party must follow the general rules, but also the general rules." the revision of the< code > and < rule > is Method in adhere to the regulations established for the purpose of combining rule of virtue is to adhere to the party constitution as a fundamental to follow, the constitution authority set up, wake up the party constitution and party rules the sense of discipline, the party constitution about discipline and self-discipline specific requirements. 4 second is to adhere to in accordance with the regulations governing the party and the party. The Party of rule of virtue "de", mainly refers to the party's ideals and beliefs, excellent traditional style. The revised the < code > closely linked to the "self-discipline", insisting on the positive initiative, for all members, highlight the "vital few", emphasized self-discipline, focusing on the morality, and the majority of Party members and the ideological and moral standards. The revised < > Ji method separately, Ji, Ji Yan to Method, as a "negative list", emphasizing the heteronomy, focusing on vertical gauge. Is this one high and one low, a positive reaction, the strict party discipline and practice results transformation for the integration of the whole party to observe moral and discipline requirements, for the majority of Party members and cadres provides benchmarking and ruler. Third, insist on to. In view of the problems existing in theparty at the present stage, the main problems of Party members and cadres in the aspect of self-discipline and abide by the discipline to make clearly defined, especially the party's eighteen years strict political discipline and political rules, organization and discipline and to implement the central eight provisions of the spirit against the four winds and other requirements into Disciplinary provisions. Not one pace reachs the designated position, focusing on in line with reality, pragmatic and effective. After the revision of major changes, major changes in the < code > and < rule > modified and needs to grasp several key problems (a) < code > < code > adhere to according to regulations governing the party and party with morals in combination, for at the present stage, the leadership of the party members and cadres and Party members in existing main problems of self-discipline, put forward principles, requirements and specifications, showing Communists noble moral pursuit, reflected at all times and in all over the world ethics from high from low 5 common requirements. One is closely linked to the "self-discipline", removal and no direct relation to the provisions of . the second is adhere to a positive advocate, "eight prohibition" 52 are not allowed to "about the content of the" negative list moved into synchronizationamendment < cases >. Three is for all the party members, will apply object from the leadership of the party members and cadres to expand to all Party members, fully embodies the comprehensive strictly required. The fourth is prominent key minority, seize the leadership of the party members and cadres is the key, and put forward higher requirements than the ordinary Party members. Five is to simplify, and strive to achieve concise, easy to understand, easy to remember. The revised < code > is the ruling Party since the first insists on a positive advocate forAll Party members and the self-discipline norms, moral declaration issued to all members of the party and the National People's solemn commitment. > < criterion of a clean and honest administration consists of 4 parts, 18, more than 3600 words. After the revision of the < code >, a total of eight, 281 words, including lead, specification and Party member cadre clean fingered self-discipline norms, etc. Part 3 members low-cost clean and self-discipline, the main contents can be summarized as "four must" "eight code". Lead part, reiterated on ideal and faith, fundamental purpose, the fine traditions and work style, noble sentiments, such as "four must" the principle of requirements, strong tone of self-discipline, The higher request for 6 andsupervised tenet, the foothold in permanent Bao the party's advanced nature and purity, to reflect the revised standards requirements. Members of self-discipline norms around the party members how to correctly treat and deal with the "public and private", "cheap and rot" thrifty and extravagance "bitter music", put forward the "four norms". Party leader cadre clean fingered self-discipline norms for the leadership of the party members and cadres of the "vital few", around the "clean politics", from civil servant of the color, the exercise of power, moral integrity, a good family tradition and other aspects of the leadership of the party members and cadres of the "four norms" < > < norm norm. "The Party member's self-discipline norms" and "party members and leading cadre clean fingered self-discipline norms," a total of eight, collectively referred to as the "eight". "Four must" and "eight" of the content from the party constitution and Party's several generation of leaders, especially Xi Jinping, general secretary of the important discussion, refer to the "three discipline and eight points for attention" statements, and reference some embody the Chinese nation excellent traditional culture essence of epigrams. (2) the revised regulations, the main changes in the revised Regulations > to fully adapt to thestrictly requirements, reflects the according to the regulations governing the law of recognition of deepening, the realization of the discipline construction and Jin Ju. < rule > is party a ruler, members of the basic line and follow. And the majority of Party members and cadres of Party organizations at all levels should adhere to the bottom line of thinking, fear discipline, hold the bottom line, as a preventive measure, to keep the party's advanced nature and purity. 1, respect for the constitution, refinement and discipline. Revised < rule > from comprehensive comb physical constitution began, the party constitution and other regulations of the Party of Party organizations and Party discipline requirements refinement, clearly defined in violation of the party constitution will be in accordance with regulations to give the corresponding disciplinary action. The original 10 categories of misconduct, integration specification for political discipline, discipline, honesty and discipline masses Ji Law and discipline and discipline and other six categories, the content of < rule > real return to Party discipline, for the majority of Party members and listed a "negative list. 7 2, highlighting the political discipline and political rules. > < Regulations according to the stage of the discipline of outstandingperformance, emphasizing political discipline and political rules, organization and discipline, in opposition to the party's leadership and the party's basic theory, basic line, basic program and basic experience, the basic requirement of behavior made prescribed punishment, increase the cliques, against the organization such as violation of the provisions, to ensure that the central government decrees and the Party of centralized and unified. 3, adhere to strict discipline in the law and discipline In front, Ji separated. Revised < Regulations > adhere to the problem oriented, do Ji separated. Any national law existing content, will not repeat the provisions, the total removal of 79 and criminal law, repeat the content of the public security management punishment law, and other laws and regulations. In the general reiterated that party organizations and Party members must conscientiously accept the party's discipline, die van comply with national laws and regulations; at the same time, to investigate violations of Party members and even criminal behavior of Party discipline and responsibility, > < Regulations distinguish five different conditions, with special provisions were made provisions, so as to realize the connection of Party discipline and state law. 4, reflect Wind building and anti-corruptionstruggle of the latest achievements. < rule > the party's eighteen years implement the spirit of the central provisions of the eight, against the requirements of the "four winds" and transformation for disciplinary provisions, reflecting the style construction is always on the road, not a gust of wind. In the fight against corruption out of new problems, increase the trading rights, the use of authority relatives profit and other disciplinary terms. Prominent discipline of the masses, the new against the interests of the masses and ignore the demands of the masses and other disciplinary terms and make provisions of the disposition and the destruction of the party's close ties with the masses.Discipline to protect the party's purpose. 8 of these regulations, a total of three series, Chapter 15, 178, more than 24000 words, after the revision of the regulations a total of 3 series, Chapter 11, 133, 17000 words, divided into "general" and "special provisions" and "Supplementary Provisions" Part 3. Among them, add, delete, modify the provisions of the proportion of up to nearly 90%. 1, the general general is divided into five chapters. The first chapter to the regulations of the guiding ideology, principles and scope of application of the provisions, highlight the strengthening ofthe party constitution consciousness, maintenance the authority of Party Constitution, increase the party organizations and Party members must abide by the party constitution, Yan Centralized centralized, would examine at all levels of the amended provisions implementing and maintaining Party discipline, and consciously accept the party discipline, exemplary compliance with national laws and regulations. The second chapter of discipline concept, disciplinary action types and effects of the regulations, will be a serious warning from the original a year for a year and a half; increase the Party Congress representative, by leaving the party above (including leave probation) punishment, the party organization should be terminated its representative qualification provisions. The third chapter of the disciplinary rules of use prescribed in the discipline rectifying process, non convergence, not close hand classified as severely or heavier punishment. "Discipline straighten "At least eighteen years of five years, these five years is to pay close attention to the provisions of the central eight implementation and anti -" four winds ". The fourth chapter on suspicion of illegal party disciplinary distinguish five different conditions, with special provisions were madeprovisions, to achieve effective convergence of Party and country 9 method. < rule > the provisions of Article 27, Party organizations in the disciplinary review found that party members have committed embezzlement, bribery, dereliction of duty dereliction of duty and other criminal law act is suspected of committing a crime shall give cancel party posts, probation or expelled from the party. The second is < Regulations > Article 28 the provisions of Party organizations in the disciplinary review But found that party members are stipulated in the criminal law, although not involved in a crime shall be investigated for Party discipline and responsibility should be depending on the specific circumstances shall be given a warning until expelled punishment. This situation and a difference is that the former regulation behavior has been suspected of a crime, the feeling is quite strict, and the latter for the behavior not involving crime, only the objective performance of the provisions of the criminal code of behavior, but the plot is a crime to slightly. < Regulations > the 29 provisions, Party organizations in the discipline review found that party members and other illegal behavior, affect the party's image, the damage to the party, the state and the people's interests, we should depend on the situation。
页面置换算法实验报告
页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中，页面置换算法是一种重要的内存管理策略。
当物理内存不足以容纳所有需要运行的进程时，操作系统需要根据一定的算法将部分页面从内存中换出，以便为新的页面腾出空间。
本实验旨在通过实际操作，对比不同的页面置换算法在不同场景下的性能表现。
二、实验背景在计算机系统中，每个进程都有自己的虚拟内存空间，而物理内存空间是有限的。
当进程需要访问某个页面时，如果该页面不在物理内存中，就会发生缺页中断，操作系统需要根据页面置换算法选择一个页面将其换出，然后将需要访问的页面换入。
常见的页面置换算法有先进先出（FIFO）、最近最久未使用（LRU）、时钟（Clock）等。
三、实验目的本实验旨在通过模拟不同的页面置换算法，比较它们在不同情况下的缺页率和效率。
通过实验结果，评估各个算法在不同场景下的优劣，为实际系统的内存管理提供参考。
四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较：FIFO、LRU和Clock。
我们使用C++编程语言模拟了一个简单的内存管理系统，并通过产生不同的访存序列来模拟不同的场景。
实验中，我们设置了不同的物理内存大小，访存序列长度和页面大小，以模拟不同的系统环境。
五、实验结果与分析在实验中，我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。
通过统计不同算法的缺页率和运行时间，得出以下结论：1. FIFO算法FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。
实验结果表明，FIFO算法在缺页率方面表现一般，特别是在访存序列具有局部性的情况下，其性能明显下降。
这是因为FIFO算法无法区分不同页面的重要性，可能会将经常使用的页面换出，导致缺页率升高。
2. LRU算法LRU算法是一种基于页面访问时间的置换算法，它认为最近被访问的页面很可能在未来会被再次访问。
实验结果表明，LRU算法在缺页率方面表现较好，特别是在访存序列具有较强的局部性时，其性能明显优于FIFO算法。
页面置换算法的模拟-(1)
课程设计报告课程名称：操作系统实验题目：页面置换算法的模拟日期：2010.07.01目录一、课程设计分析 (3)二、相关知识 (3)三、功能设计分析 (4)四、程序设计 (4)五、运行截图 (5)六、参考程序 (7)七、结果分析 (15)八、心得体会 (15)一、课程设计分析编写程序实现页面置换算法中常用的FIFO、LRU。
FIFO页面置换算法：FIFO淘汰算法是最先使用的页面最先被淘汰。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
先进先出(FIFO)页面置换算法，是根据页面调入内存后的使用情况进行决策的。
该算法是选择在内存中驻留时间最久的页面予以淘汰。
该算法赋于请求调入页面一个空间（工作集），淘汰掉最先调入的页，取而代之的是紧随它进来的页，这样就基本上实现了对最先进入内存的页面的淘汰。
LRU页面置换算法：该算法淘汰的页面是在最近一段时间里较久未被访问的那一页，它是根据程序执行时的局部性原理而设计的。
二、相关知识1．虚拟存储器的引入局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
页面置换算法实验报告
页面置换算法实验报告背景页面置换算法是计算机操作系统中的一个重要概念，它用于解决操作系统需要共享有限的物理内存资源给多个进程使用的问题。
在操作系统中，每个进程都有自己的虚拟地址空间，但实际的物理内存资源是有限的。
当物理内存不足时，操作系统需要根据一定的策略将一部分进程暂时从内存中移出，以便为其他进程让出空间，而后再从外存中将其重新加载到内存中。
这个过程就是页面置换。
页面置换算法有很多种，比如最优页面置换算法（Optimal）、先进先出页面置换算法（FIFO）、最近最久未使用页面置换算法（LRU）等等。
不同的算法对于系统性能、响应时间等指标有着不同的影响，因此在实际应用中需要选择合适的算法来平衡各种需求。
本实验旨在通过模拟页面置换算法，并对不同算法进行性能分析，以便了解各种算法的优缺点，为实际系统的选择提供依据。
分析在实验中，我们选择了三种常用的页面置换算法，分别是FIFO、LRU和Optimal。
下面对这三种算法进行详细的分析和说明。
先进先出页面置换算法（FIFO）FIFO算法是最简单和最直观的页面置换算法。
它按照页面进入内存的顺序来选择被淘汰的页面。
当内存不足时，选择最早进入内存的页面进行置换，即将其从内存中移出。
FIFO算法不需要进行进一步的页面访问计算，只需要维护一个页面进入内存的队列即可，因此实现起来比较简单。
然而，由于FIFO算法没有考虑页面的访问频率和重要性，所以可能会导致被频繁访问的页面被淘汰出内存，从而影响系统的性能。
最近最久未使用页面置换算法（LRU）LRU算法是一种基于”最近使用原则”的页面置换算法。
它根据页面最近被访问的时间来选择被淘汰的页面。
当内存不足时，选择最长时间未被访问的页面进行置换，即将其从内存中移出。
LRU算法需要维护一个页面访问时间的记录，以便在需要置换时能够快速找到最近最久未使用的页面。
相比于FIFO算法，LRU算法更加合理地利用了页面的访问情况，但实现起来相对复杂一些。
操作系统 操作系统页面置换算法
实验五操作系统页面调度算法专业班级：学号：姓名：教师评分：实验项目名称：操作系统页面置换算法一、实验目的和要求：目的：对操作系统中使用的页面调度算法进行设计。
要求：对教材中所讲述的几种页面调度算法进行深入的分析，通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。
二、实验内容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 页式存储管理的页面置换算法模拟
实验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：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。
实验五请求页式存储管理的页面置换算法
操作系统实验报告班级:计科0801班姓名：韩伟伟学号：08407106 时间：2011-5-25 实验五请求页式存储管理的页面置换算法一．实验目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二．实验属性设计三．实验内容1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条至第9条指令为第0页；第10条至19条指令为第1页；…第310条至319条指令为第31页。
3.计算并输出下述各种算法在不同内存容量下的命中率。
(1) 先进先出算法（FIFO）(2) 最近最少使用算法（LRU）(3) 最佳使用算（OPT）命中率＝１－页面失效次数／页地址流长度本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
四．思路关于随机数的产生办法。
首先要初始化设置随机数，产生序列的开始点，例如，通过下列语句实现：srand ( 400 ) ；(1) 计算随机数，产生320条指令序列m＝160；for (i＝0；i＜80；i++＝{j＝i﹡4；a[j]＝m；a[j+1]＝m+1；a[j+2]＝a[j] ﹡1.0﹡rand( )/32767；a[j+3]＝a[j+2]+1m＝a[j+3]+(319-a[j+3]) ﹡1.0﹡rand( )/32767；}(2) 将指令序列变换成为页地址流for ( k＝0；k＜320；k++){ pt＝a[k]/10；pd= a[k]%10；…}(3) 计算不同算法的命中率rate＝1-1.0﹡U/320 ；其中U为缺页中断次数，320是页地址流长度。
请求页式存储管理中常用页面置换算法模拟
记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时 候选择现有页面中其时间值最大的进行淘汰。 最佳置换算法的替换规则：其所选择的被淘汰页面，将是以后永不 使用的或许是在最长(未来)时间内不再被访问的页面。 先进先出(FIFO)页面置换算法的替换规则：该算法总是淘汰最先进 入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。该算法 实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队 列，并设置一个指针，称为替换指针，使它总是指向最老的页面。 三种替换算法的命中率由高到底排列OPT>LRU>FIFO。 本次的程序是在网上查找的相关代码然后自己进行修改，先自己仔 细地研读了这段代码，在这过程中我对C++代码编写有了更深的了解。 总之，本次实验使我明白要学会把课堂上的理论应用到实际操作中。我 需要在今后熟练掌握课堂上的理论基础，只有坚实的基础，才能在实际 操作中更得心应手。 附 录： #include "iostream.h" #include <iomanip.h> const int DataMax=100; const int BlockNum = 10; int DataShow[BlockNum][DataMax]; // 用于存储要显示的数组 bool DataShowEnable[BlockNum][DataMax]; // 用于存储数组中的数 据是否需要显示 int Data[DataMax]; // 保存数据 int Block[BlockNum]; // 物理块 int count[BlockNum]; // 计数器 int N ; // 页面个数 int M;//最小物理块数 int ChangeTimes; void DataInput(); // 输入数据的函数 void DataOutput(); void LRU(); // LRU函数 ///* int main(int argc, char* argv[]) { DataInput();// DataInput();
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
大理大学课程教案
（实验教学）
课程名称：操作系统
课程类型：（ 1 ）1、必修；2、选修；3、其它
授课对象：计算机科学与技术专业（本）2013级1、2班授课时间： 2015 至 2016 学年 2 学期
计划学时： 48 学时（其中：理论 32 ，实验： 16 ）
任课教师：曾新
所属学院：数学与计算机学院
课程管理部门（教研室）：硬件教研室
大理大学教务处制
大理大学课程教案（教学要求）
课程名称：操作系统
教材：计算机操作系统教程（第3版）、清华大学出版社
授课人：曾新专业技术职务：助教
学历：研究生学位：硕士
实验题目：存储管理常用页面置换算法模拟实验计划学时：6
实验类型：（2）1、演示性2、验证性3、综合性4、设计性
每组实验的学生人数：2人
教学目的和要求：
1、通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟
存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程。
2、做图分析并比较各种算法的效率
实验方法（包括实验中需要注意的问题等）：
1、给出操作内容要求学生自己动手完成
2、注意程序的输入并分析运行结果
实验重点（主要解决的问题和达到的目的）：
1、存储管理常用页面置换算法模拟实验的实现过程
2、各种算法的效率分析与比较
实验难点（预计实验过程中会遇到的问题和解决方案）：
1、存储管理常用页面置换算法模拟实验的实现过程
2、实验结果的分析
教学方法（实验前的教学和实验过程中的指导方法）：
以学生自己查阅资料为主，教师辅导为辅。
实验仪器和材料：
计算机并安装有Red Hat Linux9.0操作系统。
实验报告要求和思考题：
认真填写实验报告并根据讲义完成思考题
参考资料：
《计算机操作系统教程（第3版）习题解答与实验指导》、清华大学出版社
设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率。
和
然后将指令序列变换成相应的页地址流，
m’
and */
*/
*/
改为
1,i=%d\n",i); //i=86;i=176;206;250;220,221;192,193,194;258;274,275,276,277,278;
" */
FIFO
大理学院课程教案（教学总结）。