操作系统 七次实验报告 常用页面置换算法模拟实验
页面置换算法模拟实验报告
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）了解内存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。
（5）了解页面大小和内存实际容量对命中率的影响。
二、实验内容采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响，设计一个虚拟存储区和内存工作区，并使用下述算法来模拟实现页面的置换：1. 先进先出的算法（FIFO）2. 最近最久未使用算法（LRU）3. 最佳置换算法（OPT）实验分析在进程运行过程中，若其所访问的页面不存在内存而需要把它们调入内存，但内存已无空闲时，为了保证该进程能够正常运行，系统必须从内存中调出一页程序或数据送磁盘的对换区中。
但应调出哪个页面，需根据一定的算法来确定，算法的好坏，直接影响到系统的性能。
一个好的页面置换算法，应该有较低的页面更换频率。
2.1 先进先出（FIFO ）页面置换算法当需要访问一个新的页面时，首先查看物理块中是否就有这个页面，若要查看的页面物理块中就有，则直接显示，不需要替换页面；如果要查看的页面物理块中没有，就需要寻找空闲物理块放入，若存在有空闲物理块，则将页面放入；若没有空闲物理块，则替换页面。
并将物理块中所有页面 timer++。
2.2 最近久未使用 (LRU) 置换算法的思路最近久未使用置换算法的替换规则，是根据页面调入内存后的使用情况来进行决策的。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。
2.3 最佳（OPT）置换算法的思路其所选择的被淘汰的页面，是以后不使用的，或者是在未来时间内不再被访问的页面，采用最佳算法，通常可保证获得最低的缺页率。
三、实验流程3.1 系统功能图图3-1 系统功能图3.2 算法流程图1）先进先出（FIFO ）页面置换算法流程图图3-2 先进先出页面置换算法流程图2）最近久未使用 (LRU) 置换算法图3-3 最近久未使用置换算法流程图3）最佳（ OPT ）置换算法图3-4 最佳置换算法流程图四、源程序#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20 //页面长度最大为20int M; //内存块struct Pro//定义一个结构体{int num,time;};Input(int m,Pro p[L])//打印页面走向状态{cout<<"请输入页面长度(10～20)：";do{cin>>m;if(m>20||m<10){ cout<<endl;cout<<"页面长度必须在10～20之间"<<endl<<endl;cout<<"请重新输入L：";}else break;}while(1);int i,j;j=time(NULL);//取时钟时间srand(j);//以时钟时间j为种子，初始化随机数发生器cout<<endl;cout<<"输出随机数: "<<endl;cout<<endl;for(i=0;i<m;i++){p[i].num=rand( )%10;//产生0到9之间的随机数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl<<endl;return m;}void print(Pro *page1)//打印当前的页面{Pro *page=new Pro[M];page=page1;for(int i=0;i<M;i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,Pro *page1 )//寻找内存块中与e相同的块号{Pro *page=new Pro[M];page=page1;for(int i=0;i<M;i++)if(e==page[i].num)return i;//返回i值return -1;}int Max(Pro *page1)//寻找最近最长未使用的页面{Pro *page=new Pro[M];page=page1;int e=page[0].time,i=0;while(i<M) //找出离现在时间最长的页面{if(e<page[i].time) e=page[i].time;i++;}for( i=0;i<M;i++)if(e==page[i].time)return i;//找到离现在时间最长的页面返回其块号return -1;}int Count(Pro *page1,int i,int t,Pro p[L])//记录当前内存块中页面离下次使用间隔长度{Pro *page=new Pro[M];page=page1;int count=0;for(int j=i;j<L;j++){if(page[t].num==p[j].num )break;//当前页面再次被访问时循环结束else count++;//否则count+1}return count;//返回count的值}int main(){int c;int m=0,t=0;float n=0;Pro p[L];m=Input(m,p);//调用input函数，返回m值cout<<"请输入分配的物理块m(2～6): ";cout<<endl<<endl;do{cin>>M;if(M>6||M<2){ cout<<endl;cout<<"物理块m必须在2～6之间"<<endl<<endl;cout<<"请重新输入m： ";}else break;}while(1);Pro *page=new Pro[M];do{for(int i=0;i<M;i++)//初始化页面基本情况{ page[i].num=0;page[i].time=m-1-i;}i=0;cout<<endl;cout<<"1:FIFO页面置换2:LRU页面置换"<<endl;cout<<"3:OPT页面置换4:退出"<<endl;cout<<"请选择页面置换算法："<<endl;cin>>c;if(c==1)//FIFO页面置换{n=0;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0) //当前页面在内存中{cout<<p[i].num<<" "; //输出当前页p[i].numcout<<"不缺页"<<endl;i++; //i加1}else //当前页不在内存中{if(t==M)t=0;else{n++; //缺页次数加1page[t].num=p[i].num; //把当前页面放入内存中cout<<p[i].num<<" ";print(page); //打印当前页面t++; //下一个内存块i++; //指向下一个页面}}}cout<<endl;cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl<<endl; }if(c==2)//LRU页面置换{n=0;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){int a;t=Search(p[i].num,page);if(t>=0)//如果已在内存块中{ page[t].time=0;//把与它相同的内存块的时间置0 for(a=0;a<M;a++)if(a!=t)page[a].time++;//其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else //如果不在内存块中{n++; //缺页次数加1t=Max(page); //返回最近最久未使用的块号赋值给tpage[t].num=p[i].num; //进行替换page[t].time=0; //替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0;a<M;a++)if(a!=t) page[a].time++; //其它的时间加1 }i++;}cout<<endl;cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl<<endl; }if(c==3)//OPT页面置换{n=0;cout<<" OPT算法置换情况如下:"<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0)//如果已在内存块中{cout<<p[i].num<<" ";cout<<"不缺页"<<endl;i++;}else//如果不在内存块中{int a=0;for(t=0;t<M;t++)if(page[t].num==0)a++;//记录空的内存块数if(a!=0) //有空内存{int q=M;for(t=0;t<M;t++)if(page[t].num==0&&q>t)q=t;//把空内存块中块号最小的找出来page[q].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}else{int temp=0,s;for(t=0;t<M;t++)//寻找内存块中下次使用离现在最久的页面if(temp<Count(page,i,t,p)){temp=Count(page,i,t,p);s=t; }//把找到的块号赋给spage[s].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}}}cout<<endl;cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl<<endl;}if(c == 4) break;}while(c==1||c==2||c==3);return 0;}五、实验结果5.1 程序主界面运行程序后，将会提示用户输入页面长度，长度在10到20之间。
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现FIFO、LRU和Clock算法。
二、实验原理页面置换算法是操作系统中用到的一种算法，其作用是在内存不够用时，选择牺牲已经在内存中的一些页，腾出更多的空间给新的内容。
本次实验主要实现了FIFO、LRU和Clock算法。
1、FIFO算法FIFO算法是最简单的页面置换算法，它采用先进先出的原则，即最先进入内存的页面应该最早被替换出去。
该算法的实现非常简单，只需要维护一个队列即可。
当需要置换页面时，选择队列的第一个页面进行替换即可。
2、LRU算法LRU算法是Least Recently Used的缩写，即最近最少使用算法。
该算法的核心思想是选择最久没有被使用的页面进行替换。
为了实现该算法，需要维护记录页面使用时间的链表、栈或队列等结构。
3、Clock算法Clock算法也叫做二次机会算法，是一种改良的FIFO算法。
它是基于FIFO算法的思想，并且每个页面都设置了一个使用位（use bit），用于记录该页面是否被使用过。
当需要置换一个页面时，检查该页面的使用位，如果该页面的使用位为1，则将该页面的使用位设置为0并移到队列的末尾，表示该页面有“二次机会”继续待在内存中；如果该页面的使用位为0，则选择该页面进行替换。
三、实验过程本次实验采用Python语言实现页面置换算法，并使用样例进行测试。
1、FIFO算法实现FIFO算法的实现非常简单，只需要用一个队列来维护已经在内存中的页面，当需要置换页面时，选择队列的第一个元素即可。
代码如下：```pythonfrom collections import dequeclass FIFO:def __init__(self, frame_num):self.frame_num = frame_numself.frames = deque(maxlen=frame_num)def access(self, page):if page in self.frames:return Falseif len(self.frames) >= self.frame_num:self.frames.popleft()self.frames.append(page)return True```2、LRU算法实现LRU算法的实现需要维护一个记录页面使用时间的链表或队列。
页面置换实验报告
计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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值，表示该虚页的最后一次被访问时间。
操作系统实验 页面置换算法模拟
实验四页面置换算法模拟一、实验内容简要描述开发语言及实现平台或实验环境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();三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。
页面置换算法模拟实验报告
实验编号４名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计，以便：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。
操作系统实验报告_页面置换算法模拟
操作系统实验报告_页面置换算法模拟学生实验报告姓名: 年级专业班级学号成绩验证设计实验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算法。
模拟操作系统的页面置换实验报告（模板）
模拟操作系统的页面置换实验报告（模板）一、综设计实验题目：模拟操作系统的页面置换二、中文摘要：了解页面置换的概念。
理解页面置换的算法。
加深对页面置换算法的理解。
锻炼知识的运用能力和实践能力。
掌握用随机数生成满足一定条件的指令地址流的方法。
关键词：页面置换先进先出置换算法（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。
操作系统页面置换算法实验报告
学生实验报告姓名：年级专业班级学号成绩【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见1.程序的执行结果如下：(1)先进先出页面置换算法(2)最佳页面置换法(3)最近最久未使用置换算法2.以上三个程序通过数组和排序语句实现页面的三种基本调度算法。
(1)先进先出算法事先设定标志k=3，页面每发生一次置换k值增加1。
通过取k对3的余数来确定被置换的内存中的页面，当被访问页面存在于内存时，不置换，而直接输出原内存中的3个页面。
(2)最佳置换算法通过设定c1,c2,c3来记录当前内存中的页面被下一次访问的位置(时间)，通过对c1,c2,c3的大小比较确定内存中需要被置换的页面。
三者中值最大的对应的内存页面选择被置换。
即实现了未来最长时间未访问的机制，即最佳置换算法。
(3)最近最久未使用置换算法的原理跟最佳置换算法类似。
初始设定变量c1,c2,c3记录当前内存中的以前的最近一次未被访问的位置(时间)，比较三者的大小来确定需要被置换的页面。
三者中至最小的对应的内存页面选择被置换。
即实现了最近最久未使用的机制，即最近最久未使用置换算法。
3.上述三个程序分别能较好的模拟页面的基本调度算法，实现页面的置换，保证进程的正常执行。
但也分别存在一些不足。
(1)当内存中三个页面有部分相同时，程序不能很好的实现调度。
即c1,c2,c3中有部分变量值相等，源程序可能不能准确的找到调度顺序，如图所示。
(LRU算法)改进的方法为在c1,c2,c3间的大小比较判断语句中增加关系语句的默认处理办法，当三者间有部分相同时，默认选择按从前到后的顺序执行。
比如当c2=c3的时候选择页面a[2]进行置换。
当c1=c2=c3时则选择页面a[0]进行置换。
也就相当于无法运用LRU算法调用的时候折衷采取先进先出置换算法，以实现页面的合理调度，提高页面的利用效率。
指导教师签名：20 年月日【备注】。
常用页面置换算法模拟实验
目录一、摘要 (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）计算访问命中率。
页面置换算法实验报告
页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程，了解不同算法的优缺点，掌握算法的实现方法，以及对算法的性能进行评估。
二、实验原理页面置换算法是操作系统中的一个重要概念，它是为了解决内存不足的问题而产生的。
当系统中的进程需要使用内存时，如果内存已经被占满，就需要将一些页面从内存中置换出去，以便为新的页面腾出空间。
页面置换算法就是用来决定哪些页面应该被置换出去的算法。
常见的页面置换算法有以下几种：1. 最佳置换算法（OPT）最佳置换算法是一种理论上的最优算法，它总是选择最长时间内不会被访问的页面进行置换。
但是，由于无法预测未来的页面访问情况，因此最佳置换算法无法在实际中使用。
2. 先进先出置换算法（FIFO）先进先出置换算法是一种简单的置换算法，它总是选择最先进入内存的页面进行置换。
但是，这种算法容易出现“抖动”现象，即频繁地将页面置换出去，然后再将其置换回来。
3. 最近最久未使用置换算法（LRU）最近最久未使用置换算法是一种比较常用的置换算法，它总是选择最长时间未被访问的页面进行置换。
这种算法可以避免“抖动”现象，但是实现起来比较复杂。
4. 时钟置换算法（Clock）时钟置换算法是一种改进的FIFO算法，它通过维护一个环形链表来实现页面置换。
当需要置换页面时，算法会从当前位置开始扫描链表，如果找到一个未被访问的页面，则将其置换出去。
如果扫描一圈后都没有找到未被访问的页面，则将当前位置的页面置换出去。
三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序，可以模拟上述四种算法的过程，并输出算法的性能指标。
程序的主要流程如下：1. 读取输入文件，获取页面访问序列和内存大小等参数。
2. 根据选择的算法，初始化相应的数据结构。
3. 遍历页面访问序列，模拟页面置换的过程。
4. 输出算法的性能指标，包括缺页率、页面置换次数等。
下面分别介绍四种算法的实现方法。
1. 最佳置换算法（OPT）最佳置换算法需要预测未来的页面访问情况，因此需要遍历整个页面访问序列，找到最长时间内不会被访问的页面。
页面置换算法实验报告
页面置换算法实验报告一、实验目得:设计与实现最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Cｌock置换算法;通过支持页面访问序列随机发生实现有关算法得测试及性能比较、二、实验内容:●虚拟内存页面总数为N,页号从0到N—1●物理内存由M个物理块组成●页面访问序列串就是一个整数序列,整数得取值范围为0到N - １、页面访问序列串中得每个元素p表示对页面p得一次访问●页表用整数数组或结构数组来表示❑符合局部访问特性得随机生成算法1.确定虚拟内存得尺寸Ｎ,工作集得起始位置p,工作集中包含得页数e,工作集移动率ｍ(每处理m个页面访问则将起始位置p ＋1),以及一个范围在0与１之间得值t;2.生成ｍ个取值范围在p与ｐ+ e间得随机数,并记录到页面访问序列串中;3.生成一个随机数r,0 ≤r ≤1;4.如果r〈t,则为p生成一个新值,否则p = (p＋１) mod N;5.如果想继续加大页面访问序列串得长度,请返回第2步,否则结束。
三、实验环境:操作系统:Wiｎｄows7软件: ＶＣ++6.0四、实验设计:本实验包含六种算法,基本内容相差不太,在实现方面并没有用统一得数据结构实现,而就是根据不同算法得特点用不同得数据结构来实现:1、最佳置换与随机置换所需操作不多,用整数数组模拟内存实现;2、先进先出置换与最近最久未使用置换具有队列得特性,故用队列模拟内存来实现;3、CLOCK置换与改进得CＬOＣＫ置换具有循环队列得特性,故用循环队列模拟内存实现;4、所有算法都就是采用整数数组来模拟页面访问序列。
五、数据结构设计:／/页面访问序列数组:ｉnｔｒeｆ［ref_sｉze];//内存数组:iｎt pｈy［phy_size］;//队列数据结构定义:tｙpeｄef sｔrｕｃt QＮoｄeﻩ//定义队列数据结构｛ﻩint daｔa;struct QNｏde *ｎext;}QNodｅ,*ＱueuePtr;ｔypedｅｆstrｕct{QuｅuｅPtr ｆrｏnt;ﻩ／/头指针ﻩQuｅuｅPtr reaｒ;ﻩ//尾指针｝LinkQuｅuｅ;/／定义链表数据结构typedeｆstruct LNoｄｅ//定义循环链表数据结构｛iｎt data;iｎt flag;ﻩ//访问位int modｉfy;ﻩﻩ//修改位ﻩstｒuct LNodｅ＊ｎext;}LNｏde,＊LinｋLｉst;六、主要函数说明:1、voｉd seｔ_rａｎｄ_num()ﻩ//产生具有局部特性得随机数列;2、int Exchange_ＬNoｄｅ(LｉnkLisｔ&L,inｔe,iｎt i)//将链表Ｌ中序号为i得结点替换为内容为e得结点;3、ｂool Sｅａrch_ＬiｎkLisｔ(LinｋＬｉst＆L,ｉnt e,ｉnｔ&i)／／找到链表Ｌ中内容为ｅ得结点,并用i返回其位置,i=1表示第一个非头结点,依次类推;4、void Ｓeａrch_ＬＬ_Flａg(LiｎkLisｔ＆Ｌ,iｎt ＆i)//用i返回第一个flag为0得结点得位置,i＝1表示第一个非头结点,以此类推;5、voｉd Ｓeｔ_LL＿Ｆlag(LinkLｉsｔ&L,int i) //设置链表Ｌ中得序号为ｉ得结点得ｆlaｇ标志为1;6、iｎtＳｅarch_ＬL＿ModifyClock(LinkLｉst ＆L,ｉnt&moｄｉｆy_ｎｕm)／/找到改进得CLOＣＫ算法所需要淘汰得页,用ｍodｉfｙ_nｕm返回其位置;此函数根据书上给得思路,第一遍扫描Ａ=０且M=０得页面予以淘汰,若失败,则进行第二轮扫描A=０且M=１得页面,第二轮扫描时将所有访问过得页面得访问位Ａ置0;若失败则重复上述两部;7、voｉd Sｅｔ＿LL_moｄｉfy(ＬｉｎｋLｉst＆L,int i) //设置链表L中得序号为i得结点得ｍodiｆy标志为1;8、booｌSearｃhQuｅｕe(LｉnｋQuｅｕe ＆Q,iｎｔe,int ＆ｉ)ﻩ//寻找队列Ｑ中结点data域等于ｅ得结点,并用i返回其在Q中得位置;9、ｉnt getnum(iｎt a,intｂ)ﻩﻩ//用ｂ返回元素ａ在被引用数列中得下一个位置10、voｉd ORA() ／/实现最佳置换算法,包括判断页面就是否在内存中、页面进内存、输出内存状态等内容;11、ｖoid RＡＮD() ﻩ／/随机置换算法12、void FＩＦO() ﻩﻩﻩ//先进先出算法1３、voiｄLRＵ() ﻩﻩ//最近最久未使用算法实现最近最久未使用算法得思想就是:判断待进入内存得页面,如果与内存中得第一个页面相同,则将它移到最后一个,即标志为最近使用得页;如果与内存中得第二个页面相同,则将它删除,并在队列尾部添加相同元素,即标志为最近使用得页;ﻩ１４、vｏid CＬOＣK()ﻩﻩ／／实现CLOＣK算法1５、ｖoid Ｍｏdifiｅｄ_Ｃlock() ／/实现改进得CLOCK算法16、inｔｍain() ／/主函数,调用实现各算法得６个主要函数,并输出各算法得缺页率。
页面置换算法-操作系统实验报告
页面置换算法实现一、实验目的（1）了解内存分页管理及调页策略（2）掌握一般常用的调度算法（3）学会各种存储分配算法的实现方法。
（4）了解页面大小和内存实际容量对命中率的影响。
（5）通过页面访问序列随机发生器实现对上述算法的测试及性能比较二、实验内容采用页式分配存储方案,通过分别计算不同算法的命中率来比较算法的优劣,同时也考虑页面大小及内存实际容量对命中率的影响,设计一个虚拟存储区和内存工作区,并使用下述算法来模拟实现页面的置换：1. 先进先出的算法（FIFO）(是最简单的页面置换算法)2. 最近最久未使用算法（LRU）3. 最佳置换算法（OPT）（理想置换算法）实验分析在进程运行过程中,若其所访问的页面不存在内存而需要把它们调入内存, 但内存已无空闲时,为了保证该进程能够正常运行,系统必须从内存中调出一页程序或数据送磁盘的对换区中。
但应调出哪个页面,需根据一定的算法来确定, 算法的好坏,直接影响到系统的性能。
一个好的页面置换算法,应该有较低的页面更换频率。
2.1 先进先出（FIFO ）页面置换算法当需要访问一个新的页面时,首先查看物理块中是否就有这个页面,若要查看的页面物理块中就有,则直接显示,不需要替换页面；如果要查看的页面物理块中没有,就需要寻找空闲物理块放入,若存在有空闲物理块,则将页面放入；若没有空闲物理块,则替换页面。
并将物理块中所有页面 timer++,是最简单的页面置换算法。
这种算法的基本思想是：当需要淘汰一个页面时,总是选择驻留主存时间最长的页面进行淘汰,即先进入主存的页面先淘汰。
其理由是：最早调入主存的页面不再被使用的可能性最大。
2.2 最近久未使用 (LRU) 置换算法的思路最近久未使用置换算法的替换规则,是根据页面调入内存后的使用情况来进行决策的。
该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间,当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。
页面置换算法模拟 实验报告
int select;
PRA test;
while(select)
{
cin>>select;
switch(select)
{
case 0:
break;
case 1:
cout<<"LRU算法结果如下:"<<endl;
test.LRU();
test.BlockClear();
3、实验要求
编程实现页面置换算法，最少实现两种算法，比较算法的优劣，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。
（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；
（2）实现OPT算法(最优置换算法)、LRU算法(Least Recently)、FIFO算法(First IN First Out)的模拟；
}
}
int PRA::findSpace(void)
{
for(int i=0; i<Bsize; i++)
if(block[i].content == -1)
return i;//找到空闲内存，返回BLOCK中位置
return -1;
}
int PRA::findExist(int curpage)
{
for(int i=0; i<Bsize; i++)
{
block[i].content = -1;
block[i].timer = 0;
}
page = new pageInfor[Psize];
操作系统—页面置换算法实验报告
操作系统—页面置换算法实验报告本报告旨在介绍操作系统中的页面置换算法，包括实验的目的和背景以及页面置换算法的概念和作用。
本实验旨在描述实验环境以及所使用的页面置换算法，包括FIFO、LRU、OPT等。
同时，还会详细介绍实验步骤和设置的参数。
实验环境操作系统：Windows 10编程语言：C++开发环境：Visual。
2019页面置换算法FIFO（First-In-First-Out）算法：按照先进先出的原则置换页面，最早进入内存的页面会被置换出去。
LRU（Least Recently Used）算法：根据页面的使用情况，置换最长时间没有被访问过的页面。
OPT（Optimal）算法：理论上最优的页面置换算法，根据未来一段时间内页面的访问情况，选择最少使用的页面进行置换。
实验步骤创建一个模拟操作系统的C++程序。
设定内存大小、页面大小和页面数等参数。
实现FIFO算法，将其应用于模拟操作系统中的页面置换过程。
实现LRU算法，将其应用于页面置换过程。
实现OPT算法，将其应用于页面置换过程。
运行模拟程序，观察不同页面置换算法的效果。
分析比较不同算法的页面置换结果，评估其优缺点。
参数设置内存大小：512MB页面大小：4KB页面数：128以上是本次实验的实验设计，将通过创建模拟操作系统程序，实现FIFO、LRU和OPT等页面置换算法，并对其结果进行比较和评估。
本实验展示了页面置换算法的不同性能，并分析了各种算法的优缺点。
实验结果表明，不同的页面置换算法对系统性能有显著影响。
以下是对各种算法的性能分析：先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。
先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。
操作系统 七次实验报告 常用页面置换算法模拟实验..(推荐文档)
{
case 1:
FIFO();
break;
case 2:
LRU();
break;
case 3:
system("cls");
system("color 0A");
exit(0);
default:
printf("输入错误，请重新输入：");
}
printf("按任意键重新选择置换算法：>>>");
getch();
system("cls");
}while (code!=3);
getch();
}
void print(unsigned int t)
{
int i,j,k,l;
int flag;
for(k=0;k<=(pSIZE-1)/20;k++)
{
for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++)
1、第二次机会算法（Second Chance）
2、最近最少使用算法（Least Recently Used，LRU）
3、最不常用算法（Not Frequently Used，NFU）
4、最近未使用算法（Not Recently Used，NRU）
5、时钟页面置换算法
6、老化算法（aging）
页框的数量固定为4，虚拟页面数为8。实验输入为访问页面序列，比如0，1，3，2，7，1
printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n");
页面置换算法实验报告
页面置换算法实验报告一、实验目的：设计和实现最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Clock置换算法；通过支持页面访问序列随机发生实现有关算法的测试及性能比较。
二、实验内容：●虚拟内存页面总数为N，页号从0到N-1●物理内存由M个物理块组成●页面访问序列串是一个整数序列，整数的取值范围为0到N - 1。
页面访问序列串中的每个元素p表示对页面p的一次访问●页表用整数数组或结构数组来表示❑符合局部访问特性的随机生成算法1.确定虚拟内存的尺寸N，工作集的起始位置p，工作集中包含的页数e，工作集移动率m（每处理m个页面访问则将起始位置p +1），以及一个范围在0和1之间的值t；2.生成m个取值范围在p和p + e间的随机数，并记录到页面访问序列串中；3.生成一个随机数r，0 ≤r ≤1；4.如果r < t，则为p生成一个新值，否则p = (p + 1) mod N；5.如果想继续加大页面访问序列串的长度，请返回第2步，否则结束。
三、实验环境：操作系统：Windows 7软件：VC++6.0四、实验设计：本实验包含六种算法，基本内容相差不太，在实现方面并没有用统一的数据结构实现，而是根据不同算法的特点用不同的数据结构来实现：1、最佳置换和随机置换所需操作不多，用整数数组模拟内存实现；2、先进先出置换和最近最久未使用置换具有队列的特性，故用队列模拟内存来实现；3、CLOCK置换和改进的CLOCK置换具有循环队列的特性，故用循环队列模拟内存实现；4、所有算法都是采用整数数组来模拟页面访问序列。
五、数据结构设计：//页面访问序列数组：int ref[ref_size];//内存数组：int phy[phy_size];//队列数据结构定义：typedef struct QNode //定义队列数据结构{int data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front; //头指针QueuePtr rear; //尾指针}LinkQueue;//定义链表数据结构typedef struct LNode //定义循环链表数据结构{int data;int flag; //访问位int modify; //修改位struct LNode *next;}LNode,*LinkList;六、主要函数说明：1、void set_rand_num() //产生具有局部特性的随机数列；2、int Exchange_LNode(LinkList &L,int e,int i)//将链表L中序号为i的结点替换为内容为e的结点；3、bool Search_LinkList(LinkList &L,int e,int &i)//找到链表L中内容为e的结点，并用i返回其位置，i=1表示第一个非头结点，依次类推；4、void Search_LL_Flag(LinkList &L,int &i)//用i返回第一个flag为0的结点的位置,i=1表示第一个非头结点，以此类推；5、void Set_LL_Flag(LinkList &L,int i) //设置链表L中的序号为i的结点的flag标志为1；6、int Search_LL_ModifyClock(LinkList &L,int &modify_num)//找到改进的CLOCK算法所需要淘汰的页，用modify_num返回其位置；此函数根据书上给的思路，第一遍扫描A=0且M=0的页面予以淘汰，若失败，则进行第二轮扫描A=0且M=1的页面，第二轮扫描时将所有访问过的页面的访问位A置0；若失败则重复上述两部；7、void Set_LL_modify(LinkList &L,int i) //设置链表L中的序号为i的结点的modify标志为1；8、bool SearchQueue(LinkQueue &Q,int e,int &i) //寻找队列Q中结点data域等于e的结点，并用i返回其在Q中的位置；9、int getnum(int a,int b) //用b返回元素a在被引用数列中的下一个位置10、void ORA() //实现最佳置换算法，包括判断页面是否在内存中、页面进内存、输出内存状态等内容；11、void RAND() //随机置换算法12、void FIFO() //先进先出算法13、void LRU() //最近最久未使用算法实现最近最久未使用算法的思想是：判断待进入内存的页面，如果与内存中的第一个页面相同，则将它移到最后一个，即标志为最近使用的页；如果与内存中的第二个页面相同，则将它删除，并在队列尾部添加相同元素，即标志为最近使用的页；14、void CLOCK() //实现CLOCK算法15、void Modified_Clock() //实现改进的CLOCK算法16、int main() //主函数，调用实现各算法的6个主要函数，并输出各算法的缺页率。
山东大学操作系统实验七内存页面置换算法问题
计算机科学与技术学院操作系统实验报告实验题目：内存页面置换算法问题假请在以上示例实验程序中补充“增强二次机会”等置换算法的模拟程序。
输入不同的内存页面引用串和实存帧数,观察并分析其页面置换效果和性能,并将其与LRU和FIFO算法进行比较。
改进以上示例实验程序,使之能够随机的产生内存页面引用串,以便能动态的观测各种置换算法的性能。
实验目的：加深对于存储管理的了解,掌握虚拟存储器的实现原理;观察和了解重要的页面置换算法和置换过程。
练习模拟算法的编程技巧,锻炼分析试验数据的能力。
硬件环境：Inter(R)Core(TM)i5-3210M CPU@2.50GHz内存：4GB硬盘：500G软件环境：XUbuntu－Linux操作系统Gnome桌面2.18.3BASH_VERSION='3.2.33(1)-releasegcc version4.1.2gedit2.18.2OpenOffice2.3实验步骤：1、问题分析:示例实验程序中模拟两种置换算法:LRU算法和FIFO算法能对两种算法给定任意序列不同的页面引用串和任意帧实内存块数的组合测试,显示页置换的过程。
能统计和报告不同置换算法情况下依次淘汰的页号、缺页次数(页错误数)和缺页率。
比较两种置换算法在给定条件下的优劣。
为了能方便的扩充页面置换算法,更好的描述置换过程,示例实验程序采用了C++语言用Replace类描述了置换算法及其属性。
2、算法设计说明如下：1.二次机会算法描述(Clock):将帧表设置为循环表,由RefBit数组记录某一页是否被引用(0表示未被引用,1表示被引用)。
当访问一页时,首先从帧表中检查此页是否在实存,若在将其引用位设置为1;若不在,在循环帧表中循序查找,若某页引用位为1,则将其设置为0，然后继续查找；若某页引用位为0，将其替换。
若查找一圈，没有替换页（所有引用位均为1），则将全部引用位设置为0。
2.增强的二次机会算法（Eclock）：将帧表设置为循环表，由RefBit 数组记录某页是否被引用,ModBit数组记录某页是否被修改。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验用到的软件（： ） DevC++,Visio 实验内容及关键步骤（代码）Q3（15 分） 得分：
流程图：
输入页ห้องสมุดไป่ตู้访问序列
取访问的页号
查页表 是 是否缺页？ 否
置缺页标志 flag 为’*’
按算法不同淘汰一页面
调入所访问的页面
FIFO 算法流程图
LRU 算法流程图：
函数关系解释图：
主函数，入口
{ /*判断新页面号是否在物理块中*/ for(j=0,k=0;j<mSIZE;j++) { if(memery[j]!=page[i]) k++; else flag[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);
内容：编写一个程序，使用以下页面置换算法中的某 2 种分别模拟一个分页系统，并统
计同一个页面访问序列情况下不同页面置换算法引发的缺页中断次数。 1、第二次机会算法（Second Chance） 2、最近最少使用算法（Least Recently Used，LRU ） 3、最不常用算法（Not Frequently Used，NFU） 4、最近未使用算法（Not Recently Used ，NRU） 5、时钟页面置换算法 6、老化算法（aging） 页框的数量固定为 4，虚拟页面数为 8。实验输入为访问页面序列，比如 0，1 ，3 ，2， 7，1
} /*显示设计者信息*/ void designBy() { printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n"); printf("┃㊣ 实验七：页面置换算法 ㊣┃\n"); printf("┃ 学号：1001010042 ┃\n"); printf("┃ 姓名：黄浩全 <Dev-C++ 4.9.9.0>┃\n"); printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"); }
实验 总分 (Q1+Q2+ Q3+Q4)
实验编号与实验名称：
实验七、常用页面置换算法模拟实验
实验目的：
通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点， 掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它 们的效率。
实验内容及要求（详见实验讲义与实验指导书） ：
printf(" | |"); } 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(" "); else printf(" |%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 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++) { /*判断新页面号是否在物理块中*/
操作系统课程第七次实验报告
姓名 任课教师 实验地点 实验时间 实验课表 现
学号 指导教 贺辉 师 综合楼 B102 2012-9-26 出勤和个人表现 Q1(15+15 （组长评分）=30 分) 实验完成情况 Q2(45 分(组 长与教师评分的加权平 均))
系 贺辉 评阅教师
计算机 贺辉
得分： 得分：
/*物理块数*/
#define PROESS_SIZE 8 /*页面号引用串个数*/#include <stdio.h> #include <stdlib.h> /*全局变量*/ int mSIZE=4; int pSIZE=8; static int memery[4]={0}; /*物理块中的页号*/ static int page[8]={0}; /*页面号引用串*/ static int temp[8][4]={0}; /*辅助数组*/ /*置换算法函数*/ void FIFO(); void LRU(); void OPT(); void designBy(); /*辅助函数*/ void print(unsigned int t); /*主函数*/ int main() { int i,k,code; designBy(); system("color 0A"); puts("请依次输入页面号(8 个)："); for(i=0;i<pSIZE;i++) scanf("%1d",&page[i]); 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]); else printf("%d ",page[i]); } } printf("* * * * * * * * * * * * * * * * * * * * * * *\n"); printf("* 请选择页面置换算法：\t\t\t *\n"); printf("* ----------------------------------------- *\n"); printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n"); printf("* 3.退出 *\n");
designB y() 0 1
作者信息显示
Main()
用FIFO算法实现
1 FIFO()
1 LRU
用LRU算法实 现 退出
EXIT()
2
实现结果：
PRINT()
2
显示内存页框每次 置换结果
图1
图2
代码：
#include <stdio.h> #include <stdlib.h> #define MEMORY_SIZE 4
实验过程中遇到的问题解决办法与实验体会 Q4（需手写，10 得分： 分） 1、在 FIFO 算法可以很容易用数组实现，而 LRU 算法可以用数组实现，不过用结 构体会更明显简单。结构体成员变量可以记录页号进入的时间，和最近使用的记 录。相对比数组更容易理解和实现。 2:首先，FIFO（先进先出）算法和 LRU（最近未使用算法）两者之间，FIFO 算法 明显会比 LRU 容易理解，而且比 LRU 算法较容易实现，但在性能方面，LRU 的 确在优化方面做的比较理想。再且在考虑页框和页表号之间的问题用代码可以容 易模拟，但是真是在物理内存块中是如何实现，那确实是很难以理解，需要真正 理解到内存内部的知识才知道这两个算法是怎么实现的。 评阅教师特殊评语：
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]; } } 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++)