虚拟存储器管理 页面置换算法模拟实验
实验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时，试计算采用先进先出淘汰算法时的缺页率(假设开始执行时主存中没有页面)，并将所得结果填表。
页面置换算法模拟实验报告
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之间。
虚拟页面管理实验报告(3篇)
第1篇一、实验目的1. 理解虚拟存储器的概念和作用。
2. 掌握分页式存储管理的基本原理和地址转换过程。
3. 熟悉几种常见的页面置换算法，并比较其优缺点。
4. 通过实验，加深对虚拟存储器管理机制的理解。
二、实验内容1. 模拟分页式存储管理中的地址转换过程。
2. 比较几种常见的页面置换算法：FIFO、LRU、LFU和OPT。
三、实验原理虚拟存储器是一种将内存和磁盘结合使用的存储管理技术，它允许程序使用比实际物理内存更大的地址空间。
虚拟存储器通过将内存划分为固定大小的页（Page）和相应的页表（Page Table）来实现。
1. 分页式存储管理分页式存储管理将内存划分为固定大小的页，每个页的大小相同。
程序在运行时，按照页为单位进行内存访问。
分页式存储管理的主要优点是内存碎片化程度低，便于实现虚拟存储器。
2. 页面置换算法当内存中没有足够的空间来存放新请求的页面时，需要将某个页面从内存中移除，这个过程称为页面置换。
以下介绍几种常见的页面置换算法：（1）FIFO（先进先出）：优先淘汰最早进入内存的页面。
（2）LRU（最近最少使用）：优先淘汰最近最少被访问的页面。
（3）LFU（最不频繁使用）：优先淘汰最不频繁被访问的页面。
（4）OPT（最佳置换）：优先淘汰未来最长时间内不再被访问的页面。
四、实验步骤1. 模拟分页式存储管理中的地址转换过程（1）创建一个模拟内存的数组，表示物理内存。
（2）创建一个模拟页表的数组，用于存放虚拟页号和物理页号之间的映射关系。
（3）模拟进程对内存的访问，将访问的虚拟页号转换为物理页号。
2. 比较几种常见的页面置换算法（1）创建一个模拟进程的数组，包含访问的虚拟页号序列。
（2）对每个页面置换算法，模拟进程的运行过程，记录缺页中断次数。
（3）计算不同页面置换算法的缺页率，并比较其性能。
五、实验结果与分析1. 分页式存储管理中的地址转换过程实验结果表明，分页式存储管理能够有效地将虚拟地址转换为物理地址，实现虚拟存储器。
实验三页面置换算法模拟实验
计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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值，表示该虚页的最后一次被访问时间。
操作系统实验四模拟页面置换算法
实验四实现页面置换算法FIFO和LRU 一、实验目的：（1）进一步理解父子进程之间的关系；（2）理解内存页面调度的机理；（3）掌握页面置换算法的实现方法；（4）通过实验比较不同调度算法的优劣；（5）培养综合运用所学知识的能力。
页面置换算法是虚拟存储管理实现的关键，通过本次试验理解内存页面调度的机制，在模拟实现FIFO、LRU等经典页面置换算法的基础上，比较各种置换算法的效率及优缺点，从而了解虚拟存储实现的过程。
将不同的置换算法放在不同的子进程中加以模拟，培养综合运用所学知识的能力。
二、实验内容及要求：（1）这是一个综合型实验，要求在掌握父子进程并发执行机制和内存页面置换算法的基础上，能综合运用这两方面的知识，自行编制程序；（2）程序涉及一个父进程和两个子进程。
父进程使用rand()函数随机产生若干随机数，经过处理后，存于一数组Acess_Series[]中，作为内存页面访问的序列。
两个子进程根据这个访问序列，分别采用FIFO和LRU两种不同的页面置换算法对内存页面进行调度。
要求：（3）每个子进程应能反映出页面置换的过程，并统计页面置换算法的命中或缺页情况。
设缺页的次数为diseffect。
总的页面访问次数为total_instruction。
缺页率 = disaffect/total_instruction命中率 = 1- disaffect/total_instruction（4）说明FIFO算法存在的Belady现象。
三、实现：数据结构（1）存放页面访问序列的数组：intAcess_Series[total_instruction]；int total_instruction; //进程总的页面数（2）用一个结构数组M_Frame[]记录为进程分配的内存页面的使用情况：struct one_frame{ //记录为进程分配的内存页面情况;int page_No; //记录页面号int time; //记录页面进入内存时间int used_time; //记录页面最近使用时间};one_frame M_Frame[frame_num];int frame_num; //驻留集大小(3)本次实验我并没有采用推荐的数据结构——struct one_frame {int page_no;char flag;};struct one_frame M_Frame[frame_num];是因为我认为这个数据结构并没有很好地体现出FIFO依据进入内存时间来置换页面、LRU依据最近使用时间来置换页面。
计算机操作系统实验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. 算法分类- 最优页面置换算法(OPT)：根据未来的访问情况，选择最长时间内不再被访问的页面进行置换。
- 先进先出页面置换算法(FIFO)：选择最早进入物理内存的页面进行置换。
- 最近最少使用页面置换算法(LRU)：选择最长时间内未被访问的页面进行置换。
- 时钟页面置换算法(CLOCK)：使用一个指针指向当前页面，选择指针指向的页面进行置换。
3. 算法比较- OPT算法是最理想的页面置换算法，但实际上很难实现，因为需要预测未来的页面访问情况。
- FIFO算法简单易实现，但可能会出现“抖动”现象，即频繁地将同一页面置换出去再置换回来。
- LRU算法性能较好，但实现较为复杂，需要维护一个访问时间戳。
- CLOCK算法是对LRU算法的一种改进，实现较为简单，但在某些情况下可能会出现性能问题。
4. 实验设计- 使用C++语言实现了FIFO、LRU和CLOCK三种页面置换算法。
- 使用随机生成的页面序列进行测试，记录每种算法的缺页率和执行时间。
- 分析实验结果，比较各种算法的优缺点。
5. 实验结果- 在测试中，FIFO算法的缺页率最高，CLOCK算法的缺页率最低，LRU 算法的缺页率居中。
- 在执行时间方面，CLOCK算法最快，FIFO算法最慢，LRU算法居中。
- 综合考虑，可以根据具体的应用场景选择适合的页面置换算法。
6. 结论- 虚拟内存页面置换算法是操作系统中的重要技术，对系统性能有着重要影响。
- 不同的页面置换算法有着各自的优缺点，需要根据具体情况进行选择。
- 实验结果表明，CLOCK算法在缺页率和执行时间方面都表现较好，可以作为一种较为通用的页面置换算法。
操作系统实验报告材料6-页面置换算法模拟
实验报告（ 2013 / 2014学年第1学期）课程名称操作系统原理实验名称实验6：页面置换算法模拟实验时间2013 年12 月 10 日指导单位软件工程系指导教师杨健学生姓名班级学号学院(系) 软件工程系专业计算机软件与服务外包//物?理え?块é定¨义?typedef struct BlockNode{int page_index;//page数簓组哩?的?下?标括?struct BlockNode * next;}BlockNode;struct{int length;//当獭?前°物?理え?块é长¤度èint miss_flag;//缺ā?页?标括?志?，?若?为a1，?则ò缺ā?页?int miss_count;//缺ā?页?次?数簓BlockNode*front;BlockNode*rear;}Block;//本?程ì序ò中D全?局?变?量?名?均ù由?两?个?单蹋?词洙?组哩?成é，?且ò开a头?字?母?大洙?写′int BlockSize = 5;//物?理え?块é大洙?小?int PageCount = 200;//页?面?总哩?数簓int PageSize = 1024;//页?面?大洙?小?int AddrRange = 8*1024;//访?问ê地?址·范?围§int get_num(int down,int up)//得?到?一?个?down~up之?间?的?整?数簓{int num;char str[111];while(1){fgets(str,111*sizeof(int),stdin);num=atoi(str);//把?字?符?串?中D的?数簓字?转羇换?为a整?数簓if(num>=down&& num<=up)break;printf("输?入?范?围§有瓺误ó,请?重?新?输?入?:");}//whilereturn num;}void init_block()//构1造ì一?个?空?的?物?理え?块é队ó列{Block.rear=Block.front=(BlockNode*)malloc(sizeof(BlockNode)); if(!Block.front){printf("内ú存?分?配?失骸?败悒?\n");exit(0);}Block.length=0;Block.miss_count=0;Block.rear->next=NULL;}void enqueue(int page_index)//入?队óvoid clear_block()//清?空?物?理え?块é{while(Block.rear=Block.front->next){ Block.front->next=Block.rear->next;free(Block.rear);Block.length--;}Block.rear=Block.front;Block.length=0;Block.miss_count=0;}void destroy_block()//销ú毁ù物?理え?块é{while(Block.rear=Block.front){Block.front=Block.front->next;free(Block.rear);}free(page);}void init_page()//初?始?化ˉ页?面?系μ列int i,j;srand(time(NULL));//用?当獭?前°系μ统?时骸?间?来ぁ?初?始?化ˉ随?机ú种?子哩? page=(struct node_page*) malloc(PageCount*sizeof(struct node_page));for(i=0;i<PageCount;i++){page[i].address=rand()%AddrRange;page[i].page_num=page[i].address/PageSize;}for(i=0;i<PageCount;i++){for(j=i+1;j<PageCount;j++){if(page[i].page_num== page[j].page_num){page[i].next_order=j;break;}//if}//forif(j== PageCount)//说μ明÷page[i]以?后ó都?不?会á再ù访?问êpage[i].next_order= PageCount;}//for}void print_page()//打洙?印?页?面?系μ列{int i;printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); printf("页?面?系μ列为a：阰\n");for(i=0;i<PageCount;i++){printf("[%-2d,%-4d]",page[i].page_num,page[i].address%PageSize); if((i+1)%5== 0){printf("\n");}//if}printf("\n");}void FIFO_Replace(int page_index)//FIFO置?换?{BlockNode*node;if(!Block.length){enqueue(page_index);Block.miss_flag=0;return;}node=Block.front;while(node=node->next){if(page[node->page_index].page_num==page[page_index].page_num){destroy_block(); return 0;}截图。
页面置换算法的模拟【实验报告】
实验三页面置换算法的模拟专业：信息管理与信息系统学号：2014******姓名：陈*实验日期：2016年12月23日一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验要求基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。
1、先进先出的算法（FIFO）2、最近最久未使用算法（LRU）命中率＝１－页面失效次数／页地址流(序列)长度三、实验方法内容1.算法设计思路（流程图）2.算法中用到的数据结构（1）int serial[]，保存要执行的序列（2）int block[]，分配给该进程的物理块（3）int order[]，各页面进入内存的次序3.主要模块（函数名）（4）void print(int n,int numBlock),输出已在内存的页面,numBlock为物理块的个数（5）int isHave(int page，int numBlock),查找block数组，看内存中是否已存在page对应的页面（6）void FIFO(int numBlock)，FIFO算法,numBlock为物理块的个数（7）void replace(int num,int n)，用于LRU算法，当num页面已经在内存里面，则将其在order数组的位置换到最后（8）void LRU(int numBlock)，LRU算法,numBlock为物理块的个数（9）int main()，主函数三、实验结果1.执行结果（1）在有三个物理块的内存中执行FIFO算法的结果（2）在有三个物理块的内存中执行LRU算法的结果（3）在有四个物理块的内存中执行FIFO算法的结果（4）在有四个物理块的内存中执行LRU算法的结果2.结果分析（1）所获结果正确；（2）LRU算法的命中率高于FIFO算法，但实现比较难；五、实验总结（1）通过《页面置换算法的模拟》这个实验，加深了对页面置换和命中率、缺页率的理解；（2）更加了解了FIFO算法和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];
操作系统实验(四)实验报告--虚拟内存
操作系统实验(四)实验报告--虚拟内存操作系统实验（四）虚拟内存1、实验题目页面置换算法模拟——OPT、FIFO和LRU算法2、实验目的了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法，如最佳（Optimal）置换算法、先进先出（Fisrt In First Out）置换算法和最近最久未使用（Least Recently Used）置换算法3、实验内容1）OPT算法：需要发生页面置换时，算法总是选择在将来最不可能访问的页面进行置换。
2）FIFO算法：算法总是选择在队列中等待时间最长的页面进行置换。
3）LRU算法：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，那么，在最近未来是不大可能被访问的。
4、程序代码#include<iostream>#include <cstdlib>#include <time.h>#include <cstdio>#define L 30///页面走向长度最大为30using namespace std;int M=4; ///内存块struct P///定义一个结构体{int num,time;}p[30];int Input(int m,P p[L])///打印页面走向状态{m=30;int i,j;j=time(NULL);///取时钟时间srand(j);///以时钟时间x为种子，初始化随机数发生器cout<<"页面走向: ";for(i=0; i<m; i++){p[i].num=rand( )%10;///产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;return m;}void print(P *page1)///打印当前的页面{P *page=new P[M];page=page1;for(int i=0; i<M; i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,P *page1 )///寻找内存块中与e相同的块号{P *page=new P[M];page=page1;for(int i=0; i<M; i++)if(e==page[i].num)return i; ///返回i值return -1;}int Max(P *page1)///寻找最近最长未使用的页面用于OPT算法{P *page=new P[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(P *page1,int i,int t,P p[L])///记录当前内存块中页面离下次使用间隔长度用于OPT算法{P *page=new P[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=1;int m=0,t=0;float n=0;///缺页次数m=Input(m,p);///调用input函数，返回m值M=4;P *page=new P[M];///dowhile(c==1||c==2||c==3){int i=0;for(i=0; i<M; i++) ///初试化页面基本情况{page[i].num=0;page[i].time=m-1-i;}cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"3:OPT页面置换"<<endl;cout<<"按其它键结束程序；"<<endl;cin>>c;if(c==1)///FIFO页面置换///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<<"缺页次数："<<n<<" 缺页率："<<n<<"/"<<m<<" ="<<n/m<<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;///把与它相同的内存块的时间置0for(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<<"缺页次数："<<n<<" 缺页率："<<n<<"/"<<m<<" = "<<n/m<<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<<"缺页次数："<<n<<" 缺页率："<<n<<"/"<<m<<" = "<<n/m<<endl;}}///while(c==1||c==2||c==3);return 0;}5、心得体会通过该实验，是我对虚拟内存更加了解，对最佳置换算法、先进先出算法、最近最久算法更加了解。
页面置换算法模拟
实验四页面置换算法模拟（1）一、实验目的1、理解虚拟存储器概念。
2、掌握分页式存储管理地址转换和缺页中断。
二、实验内容与基本要求1、模拟分页式存储管理中硬件的地址转换和产生缺页中断。
2、用先进先出页面调度算法处理缺页中断。
三、实验报告内容1、分页式存储管理和先进先出页面调度算法原理。
a.分页式存储管理原理在存储器管理中，连续分配方式会形成许多“碎片”，虽然可通过“紧凑”方法将许多碎片拼接成可用的大块空间，但须为之付出很大开销。
如果允许将一个进程直接分散地装入到许多不相邻的分区中，则无须再进行“紧凑”。
基于这一思想而产生了离散分配方式。
如果离散分配的基本单位是页，则称为分页存储管理方式。
在分页存储管理方式中，如果不具备页面对换功能，则称为基本分页存储管理方式，或称为纯分页存储管理方式，它不具有支持实现虚拟存储器的功能，它要求把每个作业全部装入内存后方能运行。
请求式分页系统是建立在基本分页基础上的，为了能支持虚拟存储器功能，而增加了请求调页功能和页面置换功能。
b.先进先出页面调度算法原理优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。
该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。
但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。
2、程序流程图。
3、程序及注释。
（完善程序：数据能动态的，少了越界错误的判断（页号小于页长，页内地址小于页的大小））#include<cstdio>#include<cstring>#define SizeOfPage 128#define SizeOfBlock 128#define M 4struct info//页表信息结构体{bool flag; //页标志，1表示该页已在主存，0表示该页不在主存long block;//块号long disk;//在磁盘上的位置bool dirty;//更新标志}pagelist[SizeOfPage];long po;//队列标记long P[M];//假设内存中最多允许M=4个页面void init_ex1() //内存空间初始化。
实验4页式存储管理的页面置换算法模拟
实验4 页式存储管理的页面置换算法模拟1.实验目的通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
2.实验环境装有操作系统Windows XP和开发工具VC++，内存在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算法的工作机理写入实验报告。
实验4 虚拟存储器算法的模拟实现
实验四虚拟存储器中的算法模拟实现
一、实验目的
1.了解虚拟存储器的原因，以及虚拟存储器的实现方法
2.掌握分页式存储管理中硬件的地址转换和产生缺页中断的
工作原理，深刻理解各种页面置换算法，了解算法的执行过
程，深化对各种页面置换算法的理解
二、实验内容
1.操作系统页面置换算法的模拟实现
2.建立软件仿真模型
三、实验要求
1.操作系统实现的虚拟存储器技术，要求分别体现出以下几种
页面置换算法的页面调度：Opt算法、FIFO算法与LRU算法
为必做内容；Clock算法NRU为学有余力的同学选作；
2.运行结果须可再现，具有良好的GUI（图形界面）
3.建立软件仿真模型，实验报告中不能只有代码，应该附图
（screenshot）说明各个算法的调用，辅以中文说明，可用
少量核心代码作为辅助说明。
四、实验提示
1.编程语言不限，VB、VC、java、C# 均可
2.可以使用一维数组、Vector或Hashtable存储页面访问序列；
3.模拟OS对各种页面置换算法的调度（4个物理块），页面访
问序列为[]
601203042134，可以将各个页面置换算法单独编写为一个函数调用；
4.最多2人组合为一个实验小组，集思广益、分工设计
5.算法（源程序片段，附程序运行的每个算法的Screenshot）
五、实验被告正文
Signature Below 作者本人签字。
操作系统实验4虚拟内存页面置换4种算法实验报告
操作系统实验报告实验题目：程序模拟内存页面置换策略学院：计算机学院专业班级：网络工程年级：2011级姓名：学号：完成时间：2013 年12 月8 日指导教师：指导教师评定成绩：指导教师签名：年月日指导教师评定成绩：指导教师签名：年月日指导教师评定成绩：指导教师签名：年月日本科学生实验项目任务书说明：学院、专业、年级均填全称，如：计算机学院、计算机科学与技术、2011。
实验报告正文1 需求分析（1）根据内存访问的局部性原理产生不少于1000次的页面请求序列。
需要从MFC界面的一个编辑框中得到一个大于1000的页面数，再根据页面数随机产生页面地址（本次试验主要将地址控制在0—100）。
（2）统计在不同页框数目下的页面失效率。
首先，要初始化页框，再编写isExit函数，用来判断某页是否已经存在在页框中。
在将FIFO作为置换策略的情况下，我们用一个Button控制该算法，在该算法下，我们设置了页框数分别为8,10,12,14的4种情况。
设置了4个HitNumber变量分别记录4中情况下的命中页数，用于画折线图和计算缺页率。
在将OPT，LUR，COLCK作为置换策略的情况下，基本需求同FIFO。
（3）在画折线图时，主要需要的就是从（1）（2）步骤里得到的页框数和HitNumber数，用CDC的MoveTO和LineTo两个函数。
2 系统设计（类图、模块图等）程序主界面模块图3 关键代码描述（1）初始条件产生函数①获得由界面输入的页面数void COS4aDlg::OnBnClickedButton1(){// TODO: 在此添加控件通知处理程序代码UpdateData(true);m_e3=PageNumber;UpdateData(false);}②随机产生并输出页面访问地址void COS4aDlg::OnBnClickedButton2(){// TODO: 在此添加控件通知处理程序代码CString str;srand(time(NULL));UpdateData(true);int count=0;for(int i=0;i<PageNumber;i++){ count++;CString q;PageOrder[i]=rand()%100;q.Format("%d",PageOrder[i]);if(count%8==0)str+=q+"\r\n";elsestr+=q+"__";}m_e4=str;UpdateData(false);}（2）4种算法的关键代码①FIFO的实现，得到4中页框数下的缺页率和命中数void COS4aDlg::OnBnClickedButton3(){// TODO: 在此添加控件通知处理程序代码U pdateData(true);i nt x=0; //标记最早进入内存的页面C String s2,s3,s4,s5;C String d,e,f,g,h,i,j,k,l,m,n,o;C String str1,str2,str3,str4;f or(int i=0;i<8;i++)In[i]=PageOrder[i];f or(int i=8;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<8;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit1(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%8;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber1++;}s2+=s1+" "+b+c+"\r\n";}f loat lost1=((PageNumber-FHitNumber1)*1.0/PageNumber)*100;d.Format("%f",lost1);e.Format("%d",8);f="在页框数为"+e+"时FIFO缺页率为："+d;s tr1=s2+"\r\n"+f;f or(int i=0;i<10;i++)In[i]=PageOrder[i];f or(int i=10;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<10;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit2(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%10;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber2++;}s3+=s1+" "+b+c+"\r\n";}f loat lost2=((PageNumber-FHitNumber2)*1.0/PageNumber)*100;g.Format("%f",lost2);h.Format("%d",10);i="当页框数为"+h+"时FIFO缺页率为："+g;s tr2=s3+"\r\n"+i;for(int i=0;i<12;i++)In[i]=PageOrder[i];f or(int i=12;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<12;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit3(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%12;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber3++;}s4+=s1+" "+b+c+"\r\n";}f loat lost3=((PageNumber-FHitNumber3)*1.0/PageNumber)*100; j.Format("%f",lost3);k.Format("%d",12);l="当页框数为"+k+"时FIFO缺页率为："+j;s tr3=s4+"\r\n"+l;f or(int i=0;i<14;i++)In[i]=PageOrder[i];f or(int i=14;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<14;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit4(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%14;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber4++;}s5+=s1+" "+b+c+"\r\n";}f loat lost4=((PageNumber-FHitNumber4)*1.0/PageNumber)*100; m.Format("%f",lost4);n.Format("%d",14);o="当页框数为"+n+"时FIFO缺页率为："+m;s tr4=s5+"\r\n"+o;m_e5+=str1+"\r\n\r\n"+str2+"\r\n\r\n"+str3+"\r\n\r\n"+str4+"\r\n"; U pdateData(false);}int COS4aDlg::isExit1(int i){f or(int j=0;j<8;j++){if(In[j]==PageOrder[i])return 1;}r eturn 0;}②OPT的实现，获得4种情况下的缺页率和命中数void COS4aDlg::OnBnClickedButton4(){// TODO: 在此添加控件通知处理程序代码U pdateData(true);i nt x=0; //标记最早进入内存的页面C String s2,s3,s4,s5;C String d,e,f,g,h,i,j,k,l,m,n,o;C String str1,str2,str3,str4;f or(int i=0;i<8;i++)In[i]=PageOrder[i];f or(int i=8;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<8;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit1(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber1++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best1(i);In[x]=PageOrder[i];}s2+=s1+" "+b+c+"\r\n";}f loat lost1=((PageNumber-OHitNumber1)*1.0/PageNumber)*100;d.Format("%f",lost1);e.Format("%d",8);f="当页框数为"+e+"时OPT缺页率为："+d;s tr1=s2+"\r\n"+f;f or(int i=0;i<10;i++)In[i]=PageOrder[i];f or(int i=10;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<10;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit2(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber2++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best2(i);In[x]=PageOrder[i];}s3+=s1+" "+b+c+"\r\n";}f loat lost2=((PageNumber-OHitNumber2)*1.0/PageNumber)*100;g.Format("%f",lost2);h.Format("%d",10);i="当页框数为"+h+"时OPT缺页率为："+g;s tr2=s3+"\r\n"+i;f or(int i=0;i<12;i++)In[i]=PageOrder[i];f or(int i=12;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<12;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit3(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber3++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best3(i);In[x]=PageOrder[i];}s4+=s1+" "+b+c+"\r\n";}f loat lost3=((PageNumber-OHitNumber3)*1.0/PageNumber)*100; j.Format("%f",lost3);k.Format("%d",12);l="当页框数为"+k+"时OPT缺页率为："+j;s tr3=s4+"\r\n"+l;f or(int i=0;i<14;i++)In[i]=PageOrder[i];f or(int i=14;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<14;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit4(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber4++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best4(i);In[x]=PageOrder[i];}s5+=s1+" "+b+c+"\r\n";}f loat lost4=((PageNumber-OHitNumber4)*1.0/PageNumber)*100;m.Format("%f",lost4);n.Format("%d",14);o="当页框数为"+n+"时OPT缺页率为："+m;s tr4=s5+"\r\n"+o;m_e5+=str1+"\r\n\r\n"+str2+"\r\n\r\n"+str3+"\r\n\r\n"+str4;U pdateData(false);}int COS4aDlg::Best1(int mi){i nt i=0,j=0,k=0,l=0,n=0,h=0,x=0,y=0;//分别代表In[0],In[1],In[2],等0的为最近最迟出现的页面。
页面置换算法模拟实验报告材料
实验编号４名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计，以便：1、了解虚拟存储技术的特点2、掌握请求页式存储管理中页面置换算法实验内容与步骤设计一个虚拟存储区和内存工作区，并使用FIFO和LRU算法计算访问命中率。
<程序设计>先用srand()函数和rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算相应的命中率。
<程序1>#include <windows.h> //Windows版，随机函数需要，GetCurrentProcessId()需要//#include <stdlib.h>//Linux版，随机函数srand和rand需要#include <stdio.h> //printf()需要#define TRUE 1#define FALSE 0#define INV ALID -1#define NULL 0#define total_instruction 320 //共320条指令#define total_vp 32 //虚存页共32页#define clear_period 50 //访问次数清零周期typedef struct{//定义页表结构类型〔页面映射表PMT〕int pn, pfn, counter, time;//页号、页框号(块号)、一个周期内访问该页面的次数、访问时间}PMT;PMT pmt[32];typedef struct pfc_struct{//页面控制结构int pn, pfn;struct pfc_struct *next;}pfc_type;pfc_type pfc[32];pfc_type *freepf_head,*busypf_head,*busypf_tail;//空闲页头指针，忙页头指针，忙页尾指针int NoPageCount; //缺页次数int a[total_instruction];//指令流数组int page[total_instruction], offset[total_instruction];//每条指令的页和页内偏移void initialize( int );void FIFO( int );//先进先出void LRU( int );//最近最久未使用void NRU( int );//最近最不经常使用/****************************************************************************main()*****************************************************************************/ void main(){int i,s;//srand(10*getpid());//用进程号作为初始化随机数队列的种子//Linux版srand(10*GetCurrentProcessId());//用进程号作为初始化随机数的种子//Windows版s=rand()%320;//在[0，319]的指令地址之间随机选取一起点mfor(i=0;i<total_instruction;i+=4){//产生指令队列if(s<0||s>319){printf("when i==%d,error,s==%d\n",i,s);exit(0);}a[i]=s;//任意选一指令访问点m。
《FIFO算法来模拟实现页面的置换》实验报告
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算法来模拟实现页面的置换
目的
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
淮海工学院计算机工程学院实验报告书课程名：《操作系统原理A 》题目：虚拟存储器管理页面置换算法模拟实验班级：软件***学号：20**1228**姓名：****一、实验目的与要求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 值，表示该虚页的最后一次被访问时间。
当LRU算法需要置换时，从所有已分配实页的虚页中找出time值为最小的虚页就是“最近最久未用”的虚页面，应该将它置换出去。
4．算法中实页的组织因为能分配的实页数n是在程序运行时由用户动态指派的，所以应使用链表组织动态产生的多个实页。
为了调度算法实现的方便，可以考虑引入free和busy两个链表：free链表用于组织未分配出去的实页，首指针为free_head，初始时n个实页都处于free链表中；busy链表用于组织已分配出去的实页，首指针为busy_head，尾指针为busy_tail，初始值都为null。
当所要访问的一个虚页不在实页中时，将产生缺页中断。
此时若free链表不为空，就取下链表首指针所指的实页，并分配给该虚页。
若free链表为空，则说明n个实页已全部分配出去，此时应进行页面置换：对于FIFO算法要将busy_head 所指的实页从busy链表中取下，分配给该虚页，然后再将该实页插入到busy链表尾部；对于LRU算法则要从所有已分配实页的虚页中找出time值为最小的虚页，将该虚页从装载它的那个实页中置换出去，并在该实页中装入当前正要访问的虚页。
三、程序流程图FIFO算法LRU算法四、主要程序清单#include<stdlib.h>#include<stdio.h>#include<conio.h>#include <time.h>#define M 10 //10个虚页#define N 20 //20个页面的访问序列//定义虚页的结构typedef struct VirtualPage{int pn;int pfn;int time;}VirtualPage;//定义实页的结构typedef struct Page{int pn;int pfn;struct Page* next;}Page;struct VirtualPage vp[M]; // 定义存放10个虚页的数组int queue[N]; //定义一个数组，存放随机生成的20个数，表示访问虚页的次序，里面的数值不能超过9int count; //存放缺页次数，用来统计缺页率。
本算法没有考虑预调页，只要该页不在内存，就认为缺页一次。
int countime; //用于LRU算法中，找出要淘汰的页。
每当要访问一个虚页面时，countime的值加1，然后将所要访问的虚页的time项值设置为增值后的当前countime值int NotInMemory[N]; //表示每次虚页访问是否在内存struct Page *Free,*Free_head,*Busy,*Busy_tail,*Busy_head,*temp;void init(Page pp[],int MemoryStatus[][N],int L){int i,j;count=0;countime=0;//初始化10个虚页for(i=0;i<M;i++){vp[i].pn=i;vp[i].pfn=-1;vp[i].time=0;}//初始化5个实页，并将其串成链表形式for(i=0;i<L;i++){pp[i].pn=-1;pp[i].pfn=i;pp[i].next=NULL;}//将5个实页依次相连，形成Free链表Free=&pp[0];for(i=0;i<L-1;i++){pp[i].next=&pp[i+1];}pp[L-1].next=NULL;Free_head=Free;//初始化Busy链表Busy=NULL;Busy_head=NULL;Busy_tail=NULL;//初始化MemoryStatus数组for(i=0;i<L;i++)for(j=0;j<N;j++){MemoryStatus[i][j]=-1;}//初始化NotInMemory数组for(i=0;i<N;i++){NotInMemory[i]=1;}}void FIFO(int L,int MemoryStatus[][N]) //先入先出算法的具体实现。
{count=0;int i,j,k,currentpage; //一些临时变量for(i=0;i<N;i++) //这是主循环，每次处理一个虚页访问。
直到把20个虚页处理完为止。
{//当前访问的虚页是哪一页？由数组queue[i]中的值表示currentpage=queue[i];//判断该虚页是否已经调入内存if(vp[currentpage].pfn!=-1) //表示该页已经在内存中，可以直接访问。
同时记录访问该页时对应的实页信息（和前一页相同）{for(j=0;j<L;j++){MemoryStatus[j][i]=MemoryStatus[j][i-1];}NotInMemory[i]=0;}else //该页不在内存，需要请求调页{count=count+1; //缺页数加1if(Free!=NULL) //如果Free链表不为空，表示内存中还有空的实页，故从Free链表中取队首元素，装入该虚页，并修改相关信息。
{temp=Free_head; //本程序中用Free表示链表的起始地址，Free_head表示链表中的第一个元素地址。
实际上两者的值永远相等。
Free_head=Free_head->next;Free=Free_head;//将虚页currentpage装入temp指向的实页，该实页的编号为temp->pfnvp[currentpage].pfn=temp->pfn;temp->pn=currentpage;//将temp指向的实页插入Busy链表的末尾temp->next=NULL;if(Busy==NULL) //如果是第一次把虚页装入实页，则temp就是Busy链表的第一个元素。
{Busy=temp;Busy_head=Busy;Busy_tail=Busy;}else //如果不是第一次把虚页装入实页，则将temp插入Busy链表的队尾。
{Busy_tail->next=temp;Busy_tail=temp;}//修改内存状态for(k=0;k<L;k++) //复制访问前一页时的内存状态{MemoryStatus[k][i]=MemoryStatus[k][i-1];}MemoryStatus[temp->pfn][i]=currentpage; //虚页currentpage装入了temp->pfn表示的那个实页里}else //如果Free链表为空，需要置换一页出去。
由于采用FIFO算法，故取busy链表的队首元素，将其置换出去，修改信息后插入队尾。
{//将Busy首元素取出，赋给temptemp=Busy;Busy_head=Busy->next;Busy=Busy_head;//将当前虚页currentpage装入temp指向的实页，修改其信息vp[temp->pn].pfn=-1; //该页被置换出去了，所以其pfn字段要设置成-1，表示其已经不再内存。
vp[currentpage].pfn=temp->pfn; //currentpage被装入内存，更新其pfn字段为temp指向的实页。
temp->pn=currentpage; //temp指向的实页，装入了currentpage虚页//将temp指向的实页插入Busy链表的末尾,此时不用再考虑Busy是否为空了。
temp->next=NULL;Busy_tail->next=temp;Busy_tail=temp;//修改内存状态for(k=0;k<L;k++) //复制访问前一页时的内存状态{MemoryStatus[k][i]=MemoryStatus[k][i-1];}MemoryStatus[temp->pfn][i]=currentpage; //虚页currentpage装入了temp->pfn表示的那个实页里}}}}void LRU(Page pp[],int MemoryStatus[][N],int L){int i,j,k,currentpage;for(i=0;i<N;i++){currentpage=queue[i];if(vp[currentpage].pfn!=-1){for(j=0;j<L;j++){MemoryStatus[j][i]=MemoryStatus[j][i-1];}NotInMemory[i]=0;}else{count=count+1;if(Free!=NULL){temp=Free_head;Free_head=Free_head->next;Free=Free_head;vp[currentpage].pfn=temp->pfn;temp->pn=currentpage;temp->next=NULL;if(Busy==NULL){Busy=temp;Busy_head=Busy;Busy_tail=Busy;}else{Busy_tail->next=temp;Busy_tail=temp;}for(k=0;k<L;k++) //复制访问前一页时的内存状态{MemoryStatus[k][i]=MemoryStatus[k][i-1];}MemoryStatus[temp->pfn][i]=currentpage;}else{int min=vp[pp[0].pn].time;temp=&pp[0];for(k=1;k<L;k++){if(vp[pp[k].pn].time<min){min=vp[pp[k].pn].time;temp=&pp[k];}}vp[temp->pn].pfn=-1;.vp[currentpage].pfn=temp->pfn;temp->pn=currentpage;for(k=0;k<L;k++){MemoryStatus[k][i]=MemoryStatus[k][i-1];}MemoryStatus[temp->pfn][i]=currentpage;}}countime++;vp[currentpage].time=countime;}}int main(){int i,j,flag=1,L;while(flag){printf("请输入实页的个数:");scanf("%d",&L);struct Page pp[L]; //定义一个存放5个实页的数组，在底下还要将其串成链表int MemoryStatus[L][N];init(pp,MemoryStatus,L);printf("FIFO算法：\n");srand(time(0));for(i=0;i<N;i++){queue[i]=rand()%10;printf("|%3d",queue[i]);}printf("\n");FIFO(L,MemoryStatus); //运行FIFO() 算法//显示依次访问20个虚页时对应的内存状态，即MemoryStatus数组的值。