实验四页面置换算法代码
实验四 模拟一个指令序列,共有320条指令解析
20111060255 曹加站计科实验四一、模拟一个指令序列，共有320条指令（模拟320个页号）50%的指令是顺序执行的25%的指令存放在当前指令之前的地址25%的指令存放在当前指令之后的地址实验结果分析：此实验模拟一个指令序列，共有320条指令：50%的指令是顺序执的，25%的指令是均匀分布在前地址部分，25%的指令是均匀分布在后地址部分。
二、模拟页面结构模拟页面页面大小为1K物理内存容量为4页~32页虚拟内存容量为32K每页内存存放了10条指令实现几种页面置换算法输出各页面置换算法在一定的物理内存容量下的命中率命中率=1-页面失效次数/320当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
常用的页面置换算法有1、最佳置换算法（Optimal）2、先进先出法（Fisrt In First Out）3、最近最久未使用（Least Recently Used）4、最不经常使用法（Least Frequently Used）5、最近未使用法（No Used Recently）由于OPT算法不能实现，实验中也只能模拟，故在程序中没有展示。
注释3：for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/for(i=4;i<=32;i++) /*用户内存工作区从4个页面到32个页面*/int initialize(total_pf) /*初始化相关数据结构*/int total_pf; /*用户进程的内存页面数*/pl[i].pfn=INVALID; /*置页面控制结构中的页号，页面为空*/pl[i].counter=0;pl[i].time=-1; /*页面控制结构中的访问次数为0，时间为-1*/实验结果：先进先出的算法（FIFO）：其总是选择在内存驻留时间最长的一页将其淘汰。
页面置换算法实验(内含完整代码)
实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。
1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、简单时钟(钟表)算法（CLOCK）命中率＝１－页面失效次数／页地址流(序列)长度三、实验原理简述UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页，核心配置了四种数据结构：页表、页帧（框）号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
（1）通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：A：50%的指令是顺序执行的B：25%的指令是均匀分布在前地址部分C：25%的指令是均匀分布在后地址部分具体的实施方法是：A：在[0，319]的指令地址之间随机选取一起点mB：顺序执行一条指令，即执行地址为m+1的指令C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’D：顺序执行一条指令，其地址为m’+1E：在后地址[m’+2，319]中随机选取一条指令并执行F：重复步骤A-E，直到320次指令（2）将指令序列变换为页地址流设：页面大小为1K；用户内存（页帧）容量为4页~32页；用户虚存容量为32K。
页面置换算法模拟实验报告
if(block[i].timer >= block[pos].timer)
pos = i;//找到应予置换页面，返回BLOCK中位置
return pos;
}
void PRA::display(void)
{
for(int i=0; i<Bsize; i++)
}
}
int PRA::findSpace(void)
{
for(int i=0; i<Bsize; i++)
if(block[i].content == -1)
return i;//找到空闲内存，返回BLOCK中位置
return -1;
}
int PRA::findExist(int curpage)
{
if(exist != -1)
{
cout<<"不缺页"<<endl;
}
else
{
space = findSpace();
if(space != -1)
{
block[space] = page[i];
display();
}
else
{
for(int k=0; k<Bsize; k++)
for(int j=i; j<Psize; j++)
int findReplace(void); //查找应予置换的页面
void display(void); //显示
void FIFO(void);//FIFO算法
页面置换算法实验(内含完整代码)
实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。
1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、简单时钟(钟表)算法（CLOCK）命中率＝１－页面失效次数／页地址流(序列)长度三、实验原理简述UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页，核心配置了四种数据结构：页表、页帧（框）号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
（1）通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：A：50%的指令是顺序执行的B：25%的指令是均匀分布在前地址部分C：25%的指令是均匀分布在后地址部分具体的实施方法是：A：在[0，319]的指令地址之间随机选取一起点mB：顺序执行一条指令，即执行地址为m+1的指令C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’D：顺序执行一条指令，其地址为m’+1E：在后地址[m’+2，319]中随机选取一条指令并执行F：重复步骤A-E，直到320次指令（2）将指令序列变换为页地址流设：页面大小为1K；用户内存（页帧）容量为4页~32页；用户虚存容量为32K。
页面置换算法
頁面置換算法最佳置換算法（opt）#include<stdio.h>#include<conio.h>#define MaxSize 100void main(){int i=0,j,k=0,a=0,b=0,n=0,sum_page=-1,page_piece;intinput_page[MaxSize],output_page[MaxSize],x,count[MaxSize];int iBuf_Size=0,iQueye=0,OutValue;printf("\nInput Number of Block: "); //输入允许的最大页块数scanf("%d",&page_piece);printf("Input Page_No:(when '-1' end!)\n"); //输入页序列do{scanf("%d",&input_page[i]);x=input_page[i];i++,sum_page+=1;}while(x!=-1);for(j=0;j<page_piece;j++) //内存初始化output_page[j]=-1;printf("\nNumber of page_No:%d\n",sum_page);printf("output page_No is:\n");for(i=0;i<sum_page;i++){a=0;if(iBuf_Size==0&&b!=page_piece) //内存未满{for(j=0;j<=b;j++)if(output_page[j]!=input_page[i])a+=1;else break; //内存中存在第i页if(a==b+1) //内存中不存在第i页，将该页存入{output_page[b]=input_page[i];b++;iQueye+=1;}}else iBuf_Size=1;if(iBuf_Size==1) //内存已满{if(iBuf_Size==1)for(j=0;j<page_piece;j++) //计数器情零count[j]=0;OutValue=0;a=0;for(j=0;j<page_piece;j++)if(input_page[i]!=output_page[j])a+=1;else break; //内存中存在第i页if(a==page_piece) //内存中不存在第i页，{for(j=0;j<page_piece;j++){for(k=i+1;k<sum_page;k++) //在输入序列中寻找内存中此后最if(output_page[j]!=input_page[k]) //久不会被用到的页号count[j]+=1;elsebreak;if(count[j]==sum_page-i-1) //内存中第j页再不会被用到{printf("%d ",output_page[j]);iQueye+=1;output_page[j]=input_page[i];OutValue=1;break;}}if(OutValue==0) //寻找内存中计数器最大的页号输出{ //并将第i页装入该位置n=0;for(k=0;k<page_piece;k++)if(count[n]<count[k])n=k;printf("%d ",output_page[n]);output_page[n]=input_page[i];iQueye+=1;}}}}printf("\nIRQ page_NO. is:%d",iQueye); //输出缺页中断的次数getche();}//LRU算法，用vc++6.0编译，程序运行，提示输入要访问的页面字串和分配的内存块数，//输出缺页中断的次数（包括开始的几个页面），和具体页面。
操作系统实验 页面置换算法模拟
实验四页面置换算法模拟一、实验内容简要描述开发语言及实现平台或实验环境C++/JA V ATurbo C / Microsoft Visual Studio 6.0 / Microsoft Visual Studio .NET 2010实验目的（1）了解内存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。
（5）了解页面大小和内存实际容量对命中率的影响。
【实验内容】编程实现页面置换算法，最少实现两种算法，比较算法的优劣，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。
【实验要求】（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；（2）实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟；（3）使用某种编程语言模拟页面置换算法。
二、报告主要内容1．设计思路A、设计页面走向、物理块数等初值。
B、编制程序，使用多种算法实现页面置换。
C、计算和比较缺页率。
最佳置换算法OPT(Optimal)它是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但是可以利用此算法来评价其它算法。
如果编写程序模拟该算法，可以提前设定页面访问次序，获知某个页面是否在未来不再被访问。
2．画流程图3.实验结果（输入、输出截图）程序运行结果4.主要代码#include "stdio.h"#include "stdlib.h"#include "math.h"#include "conio.h"#include "time.h"#define TRUE 1#define FALSE 0#define NULL 0#define total_instruction 20#define total_vp 10typedef struct{ int pn,pfn;}pv_type;pv_type pv[10];typedef struct pf_struct{ int pn,pfn;struct pf_struct *next;}pf_type;pf_type pf[20],*free_head,*busy_head,*busy_tail,*q; int page[total_instruction];int total_pf;int count;void initialiaze(){ int i;count=0;for(i=0;i<total_vp;i++){ pv[i].pn=i;pv[i].pfn=-1;}printf("请输入实页数目:");scanf("%d",&total_pf);for(i=0;i<=total_pf-1;i++){ pf[i].next=&pf[i+1];pf[i].pfn=i+1;pf[i].pn=-1;}pf[total_pf-1].next=NULL;free_head=&pf[0];printf("随机产生的页地址流为：\n");for(i=0;i<total_instruction;i++){ page[i]=rand()%10;printf("%2d",page[i]);}}void FIFO(){ int i,j;pf_type *p;q=busy_head=busy_tail=NULL;for(i=0;i<=total_instruction-1;i++){ printf("\n第%d次执行:",i+1);if(pv[page[i]].pfn==-1){ count+=1;printf("缺页，缺页次数count=%d,",count);if(free_head==NULL){printf("实页%d中的页面%d将被置换出去",busy_head->pfn,busy_head->pn);p=busy_head->next;pv[busy_head->pn].pfn=-1;free_head=busy_head;free_head->next=NULL;busy_head=p;}p=free_head->next;free_head->next=NULL;free_head->pn=page[i];pv[page[i]].pfn=free_head->pn;if(busy_tail==NULL)busy_head=busy_tail=free_head;else{ busy_tail->next=free_head;busy_tail=free_head;}free_head=p;}else printf("命中，缺页次数不变，仍为count=%d",count);printf("\npfn pn");for(j=0;j<=total_pf-1;j++){if(pf[j].pn!=-1)printf("\n%d%8d",pf[j].pfn,pf[j].pn);}}printf("\n先进先出算法的命中率为:%6.4f\n缺页总次数为%d\n",1-(float)count/20,count);}void main(){srand((unsigned)time(NULL));initialiaze();FIFO();三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。
C语言实现页面置换算法
C语⾔实现页⾯置换算法本⽂实例为⼤家分享了C语⾔实现页⾯置换算法的具体代码，供⼤家参考，具体内容如下操作系统实验页⾯置换算法（FIFO、LRU、OPT）概念：1.最佳置换算法（OPT）（理想置换算法）：从主存中移出永远不再需要的页⾯；如⽆这样的页⾯存在，则选择最长时间不需要访问的页⾯。
于所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯，这样可以保证获得最低的缺页率。
2.先进先出置换算法（FIFO）：是最简单的页⾯置换算法。
这种算法的基本思想是：当需要淘汰⼀个页⾯时，总是选择驻留主存时间最长的页⾯进⾏淘汰，即先进⼊主存的页⾯先淘汰。
其理由是：最早调⼊主存的页⾯不再被使⽤的可能性最⼤。
3．最近最久未使⽤（LRU）算法：这种算法的基本思想是：利⽤局部性原理，根据⼀个作业在执⾏过程中过去的页⾯访问历史来推测未来的⾏为。
它认为过去⼀段时间⾥不曾被访问过的页⾯，在最近的将来可能也不会再被访问。
所以，这种算法的实质是：当需要淘汰⼀个页⾯时，总是选择在最近⼀段时间内最久不⽤的页⾯予以淘汰。
题⽬：编写⼀个程序，实现本章所述的FIFO、LRU和最优页⾯置换算法。
⾸先，⽣成⼀个随机的页⾯引⽤串，其中页码范围为0-9.将这个随机页⾯引⽤串应⽤到每个算法，并记录每个算法引起的缺页错误的数量。
实现置换算法，⼀遍页⾯帧的数量可以从1~7。
#include <stdio.h>#include <stdlib.h>#include <time.h>int numbers[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};//本地数据，与课本⼀致，⽅便测试int nums=0;//输⼊栈的个数，为了⽅便使⽤，int stack[20][7]={10};void begin();void randomnum();//⽤于产⽣随机数void init();//初始化void FIFO();//FIFO算法void LRU();//LRU算法void OPT();//最优页⾯置换算法（OPT）void print();//输出int main() {begin();FIFO();LRU();OPT();return 0;}void begin()//开始菜单界⾯{int i,j,k;printf("请输⼊页⾯帧的数量(1-7)：");scanf("%d",&nums);for(k=0;;k++){printf("是否使⽤随机数产⽣输⼊串（0：是，1：否）");scanf("%d",&j);if(j==0){randomnum();break;}else if(j==1){break;}else{printf("请输⼊正确的选择！\n");}}printf("页⾯引⽤串为：\n");for(i=0;i<20;i++){printf("%d ",numbers[i]);}printf("\n");init();}void randomnum()//如果需要使⽤随机数⽣成输⼊串，调⽤该函数{srand(time(0));//设置时间种⼦for(int i = 0; i < 20; i++) {numbers[i] = rand() % 10;//⽣成区间0`9的随机页⾯引⽤串}}void init()//⽤于每次初始化页⾯栈中内容，同时⽅便下⾯输出的处理{int i,j;for(i=0;i<20;i++)for(j=0;j<nums;j++)stack[i][j]=10;}void print()//输出各个算法的栈的内容{int i,j;for(i=0;i<nums;i++){for(j=0;j<20;j++){if(stack[j][i]==10)printf("* ");elseprintf("%d ",stack[j][i]);}printf("\n");}}void FIFO()//FIFO算法{init();int i,j=1,n=20,k,f,m;stack[0][0]=numbers[0];for(i=1;i<20;i++){f=0;for(m=0;m<nums;m++){stack[i][m]=stack[i-1][m];}for(k=0;k<nums;k++){if(stack[i][k]==numbers[i]){n--;f=1;break;}}if(f==0){stack[i][j]=numbers[i];j++;}if(j==nums)j=0;}printf("\n");printf("FIFO算法：\n");print();printf("缺页错误数⽬为：%d\n",n);}void LRU()//LRU算法{int i,j,m,k,sum=1;int sequence[7]={0};//记录序列init();stack[0][0]=numbers[0];sequence[0]=nums-1;for(i=1;i<nums;i++)//前半部分，页⾯空置的情况{for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){if(sequence[j]==0){stack[i][j]=numbers[i];break;}}for(j=0;j<i;j++)//将之前的优先级序列都减1{sequence[j]--;}sequence[i]=nums-1;//最近使⽤的优先级列为最⾼sum++;}for(i=nums;i<20;i++)//页⾯不空，需要替换的情况{int f;f=0;for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++)//判断输⼊串中的数字，是否已经在栈中 {if(stack[i][j]==numbers[i]){f=1;k=j;break;}}if(f==0)//如果页⾯栈中没有，不相同{for(j=0;j<nums;j++)//找优先序列中为0的{if(sequence[j]==0){m=j;break;}}for(j=0;j<nums;j++){sequence[j]--;}sequence[m]=nums-1;stack[i][m]=numbers[i];sum++;}else//如果页⾯栈中有，替换优先级{if(sequence[k]==0)//优先级为最⼩优先序列的{for(j=0;j<nums;j++){sequence[j]--;}sequence[k]=nums-1;}else if(sequence[k]==nums-1)//优先级为最⼤优先序列的{//⽆需操作}else//优先级为中间优先序列的{for(j=0;j<nums;j++){if(sequence[k]<sequence[j]){sequence[j]--;}}sequence[k]=nums-1;}}}printf("\n");printf("LRU算法：\n");print();printf("缺页错误数⽬为：%d\n",sum);}void OPT()//OPT算法{int i,j,k,sum=1,f,q,max;int seq[7]={0};//记录序列init();stack[0][0]=numbers[0];seq[0]=nums-1;for(i=1;i<nums;i++)//前半部分，页⾯空置的情况{for(j=0;j<nums;j++){stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){if(seq[j]==0){stack[i][j]=numbers[i];break;}}for(j=0;j<i;j++)//将之前的优先级序列都减1{seq[j]--;}seq[i]=nums-1;//最近使⽤的优先级列为最⾼sum++;}for(i=nums;i<20;i++)//后半部分，页⾯栈中没有空的时候情况{//k=nums-1;//最近的数字的优先级for(j=0;j<nums;j++)//前⾯的页⾯中内容赋值到新的新的页⾯中{stack[i][j]=stack[i-1][j];}for(j=0;j<nums;j++){f=0;if(stack[i][j]==numbers[i]){f=1;break;}}if(f==0)//页⾯中没有，需要替换的情况{for(q=0;q<nums;q++)//优先级序列中最⼤的就是最久未⽤的，有可能出现后⾯没有在⽤过的情况 {seq[q]=20;}for(j=0;j<nums;j++)//寻找新的优先级{for(q=i+1;q<20;q++){if(stack[i][j]==numbers[q]){seq[j]=q-i;break;}}}max=seq[0];k=0;for(q=0;q<nums;q++){if(seq[q]>max){max=seq[q];k=q;}}stack[i][k]=numbers[i];sum++;}else{//页⾯栈中有需要插⼊的数字，⽆需变化，替换的优先级也不需要变化 }}printf("\n");printf("OPT算法：\n");print();printf("缺页错误数⽬为：%d\n",sum);}运⾏结果截图：以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
计算机操作系统实验4页面置换算法
实验4 页面置换算法（2学时）一、实验目的通过实验加强对虚拟存储管理中页面置换算法的理解和掌握。
二、实验内容编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法。
三、实验要求1、任意给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。
2、分配给该作业一定的物理块（如3块、4块等）。
3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。
4、每访问一个页面均需给出内存中的内容（内存中的页面号），若有淘汰还需给出淘汰的页面号。
5、通过给出特殊的页面访问顺序，分配不同的物理块，利用FIFO 算法计算其缺页率，进一步理解Belady现象。
6、（附加）实现CLOCK置换算法，修改位可在确定页面号时直接任意给出。
程序代码（java）package wcm4;import java.util.LinkedList;import java.util.Scanner;public class Test {/*** @param args*/LinkedList ll=new LinkedList();int a;int leng;int[] all={1,2,5,7,5,7,1,4,3,5,6,4,3,2,1,5,2};//int[] free=new int[all.length];Object o=new Integer(a);public static void main(String[] args) {// TODO Auto-generated method stubTest t=new Test();t.begin();}public void begin(){System.out.println("请选择测试类型：");System.out.println("1 OPT; 2 FiFO; 3 LRU; 4 CLOCK; 5退出");Scanner sc=new Scanner(System.in);int choose=sc.nextInt();while(choose!=5){switch(choose){case 1:this.opt();break;case 2:this.fifo();break;case 3:this.lru();break;case 4:this.clock();break;}System.out.println("请选择测试类型：");System.out.println("1 OPT; 2 FiFO; 3 LRU; 4 CLOCK; 5退出");sc=new Scanner(System.in);choose=sc.nextInt();}}public void need(){System.out.println("请输入分配给该作业的物理块数：");Scanner sc=new Scanner(System.in);leng=sc.nextInt();}public void fifo(){ll=new LinkedList();this.need();int a=0;for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{ll.add(o);o=ll.poll();a++;}}else{o=null;}this.print();}System.out.println("FIFO的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void opt(){//最佳置换算法//leng=0;ll=new LinkedList();this.need();int a=0;//int temp=0;//int[] b=new int[leng];for(int i=0;i<all.length;i++){int[] b=new int[leng];o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{for(int j=i;j<all.length;j++){Object o1=new Integer(all[j]);for(int k=0;k<leng;k++){if(ll.get(k).equals(o1)){if(b[k]==0){b[k]=j;//待替换的页在以后第一次出现的位置}}}}if(b[leng-1]==0){o=ll.set(leng-1, o);a++;}else{int temp=0;for(int m=0;m<leng;m++){if(b[m]==0){temp=m;break;}else if(b[m]>b[temp]){temp=m;}}o=ll.set(temp, o);//替换以后离得最远的a++;}}}else{o=null;}this.print();}System.out.println("OPT的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void lru(){//最近最久未使用ll=new LinkedList();this.need();int a=0;for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{ll.add(o);o=ll.poll();a++;}}else{ll.add(o);ll.remove(o);o=null;}this.print();}System.out.println("OPT的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void clock(){//简单clockll=new LinkedList();this.need();int a=0;int[] b=new int[leng];for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{for(int j=0;j<=ll.size();j++){if(b[j%ll.size()]==0){b[j%ll.size()]=1;}else{int temp1=j%ll.size();o=ll.set(temp1, o);b[temp1]=0;//改变该位的标记位break;}}a++;}}else{int temp=ll.indexOf(o);//找到该位b[temp]=0;o=null;}this.print();System.out.println("标记位为：");for(int k=0;k<ll.size();k++){System.out.print(b[k]);}System.out.println();}System.out.println("CLOCK的缺页率为：");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void print(){Object[] op=ll.toArray();for(int i=0;i<ll.size();i++){System.out.print(op[i]);}System.out.print(" ");System.out.println(o);//System.out.println();} }。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四页面置换算法模拟（2）一．题目要求：设计一个虚拟存储区和内存工作区，编程序演示下述算法的具体实现过程，并计算访问命中率：要求设计主界面以灵活选择某算法，且以下算法都要实现1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)二．实验目的：1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。
2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三．相关知识：1．虚拟存储器的引入：局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
5．页面置换算法：常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
四．设计思想：选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换：OPT基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组next[mSIZE]记录物理块中对应页面的最后访问时间。
每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。
【特别声明】若物理块中的页面都不再使用，则每次都置换物理块中第一个位置的页面。
FIFO基本思想：是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。
或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最小的页面。
LRU基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组flag[10]标记页面的访问时间。
每当使用页面时，刷新访问时间。
发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。
五．流程图：如下页所示六．源代码：如下页所示【使用C语言】#include <stdio.h>#include <conio.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("┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\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);}/*最佳置换算法*/{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);}七．参考文献：1. 严蔚敏, 吴伟民. 数据结构. 清华大学出版社, 2005.112. 谭浩强. C语言程序设计. 清华大学出版社, 2005.113. 于帆, 赵妮. 程序设计基础(C语言版). 清华大学出版社, 2006.114. 汤小丹, 梁红兵, 哲凤屏, 汤子瀛. 计算机操作系统. 西安电子科技大学出版社, 2007.5。