页面置换算法模拟设计
实验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时，试计算采用先进先出淘汰算法时的缺页率(假设开始执行时主存中没有页面)，并将所得结果填表。
页面置换算法模拟程序课程设计报告
****学院计算机科学系课程设计报告设计名称：软件课程设计设计题目：页面置换算法模拟程序学生学号：****专业班级：学生姓名：学生成绩：指导教师（职称）：课题工作时间：2010.5.31至2010.6.11说明：1、报告中的任务书、进度表由指导教师在课程设计开始前填写并发给每个学生；四、五两项（中英文摘要）由学生在完成综合设计后填写。
2、学生成绩由指导教师根据学生的设计情况给出各项分值及总评成绩。
3、指导教师评语一栏由指导教师就学生在整个设计期间的平时表现、设计完成情况、报告的质量及答辩情况，给出客观、全面的评价。
4、所有学生必须参加课程设计的答辩环节，凡不参加答辩者，其成绩一律按不及格处理。
答辩小组成员应由2人及以上教师组成。
5、报告正文字数一般应不少于3000字，也可由指导教师根据本门综合设计的情况另行规定。
6、平时表现成绩低于6分的学生，取消答辩资格，其本项综合设计成绩按不及格处理。
计算机科学系课程设计任务书王渊博哈夫曼编码的另一种实现算法[J] 安徽教育学院学报2009(6)严蔚敏.吴伟民数据结构[M] 高等教育2004指导教师：系主任：日期：2010 年 5 月 28 日计算机科学系课程设计进度安排表指导教师签名：2010年5 月 28 日指导教师评语答辩记录表成绩评定表学生姓名：学号：班级：摘要操作系统（英语；Operating System，简称OS）是一管理电脑硬件与软件资源的程序，同时也是计算机系统的内核与基石。
操作系统身负诸如管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本事务。
操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源;控制程序运行;改善人机界面;为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。
操作系统是一个庞大的管理控制程序，大致包括5个方面的管理功能:进程与处理机管理、作业管理、存储管理、设备管理、文件管理。
《操作系统》实验五：页面置换算法模拟
实验五. 请求页式存储管理的模拟[实验内容]:熟悉虚拟存储管理的各种页面置换算法，并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法（LRU），要求在每次产生置换时显示页面分配状态和缺页率。
[实验要求]：1、运行给出的实验程序，查看执行情况，进而分析算法的执行过程，在理解FIFO页面置换算法和最近最久未使用算法（LRU）置换算法后，给出最佳置换算法的模拟程序实现，并集成到参考程序中。
2、执行2个页面置换模拟程序，分析缺页率的情况。
最好页框数和访问序列长度可调节，在使用同一组访问序列数据的情况下，改变页框数并执行2个页面置换模拟程序，查看缺页率的变化。
3、在每次产生置换时要求显示分配状态和缺页率。
程序的地址访问序列通过随机数产生，要求具有足够的长度。
最好页框数和访问序列长度可调节。
实验的执行结果如下图所示（左下图为FIFO执行结果，右下图为LRU执行结果）：程序源代码： #include <libio.h> #include "windows.h" #include <conio.h>#include <stdlib.h>#include <fstream.h>#include <io.h>#include <string.h>#include <stdio.h>void initialize(); //初始化相关数据结构void createps(); //随机生成访问序列void displayinfo(); //显示当前状态及缺页情况void fifo(); //先进先出算法int findpage(); //查找页面是否在内存void lru(); //最近最久未使用算法int invalidcount = 0; // 缺页次数int vpoint; //页面访问指针int pageframe[10]; // 分配的页框int pagehistory[10]; //记录页框中数据的访问历史int rpoint; //页面替换指针int inpflag; //缺页标志，0为不缺页，1为缺页struct PageInfo //页面信息结构{int serial[100]; // 模拟的最大访问页面数，实际控制在20以上int flag; // 标志位，0表示无页面访问数据int diseffect; // 缺页次数int total_pf; // 分配的页框数int total_pn; // 访问页面序列长度} pf_info;//////////////////////////////////////////////////////////////////////// //初始化相关数据结构void initialize(){int i,pf;inpflag=0; //缺页标志，0为不缺页，1为缺页pf_info.diseffect =0; // 缺页次数pf_info.flag =0; // 标志位，0表示无页面访问数据printf("\n请输入要分配的页框数："); // 自定义分配的页框数scanf("%d",&pf);pf_info.total_pf =pf;for(i=0;i<100;i++) // 清空页面序列{pf_info.serial[i]=-1;}}///////////////////////////////////////////////////////////////////// 随机生成访问序列void createps(void ){int s,i,pn;initialize(); //初始化相关数据结构printf("\n请输入要随机生成访问序列的长度："); //自定义随机生成访问序列的长度scanf("%d",&pn);srand(rand()); //初始化随机数队列的"种子"s=((float) rand() / 32767) * 50 + pn; // 随机产生页面序列长度pf_info.total_pn = s;for(i=0;i<s;i++) //产生随机访问序列{pf_info.serial[i]=((float) rand() / 32767) * 16 ; //随机数的大小在0-15之间}}////////////////////////////////////////////////////////////////////////// 显示当前状态及缺页情况void displayinfo(void){int i,n;if(vpoint==0){printf("\n=============页面访问序列=============\n");for(i=0; i<pf_info.total_pn; i++){printf("%4d",pf_info.serial[i]);if ((i+1) % 10 ==0) printf("\n"); //每行显示10个}printf("\n======================================\n"); }printf("访问%3d : 内存<",pf_info.serial[vpoint]);for(n=0;n<pf_info.total_pf;n++) // 页框信息{if (pageframe[n] >=0)printf("%3d",pageframe[n]);elseprintf(" ");}printf(" >");if(inpflag==1) //缺页标志，0为不缺页，1为缺页{printf(" ==>缺页");printf("缺页率%3.1f",(float)(pf_info.diseffect)*100.00/vpoint);}printf("\n");}//////////////////////////////////////////////////////////////////////// // 查找页面是否在内存，1为在内存，0为不在即缺页int findpage(int page){int n;for(n=0;n<pf_info.total_pf;n++){pagehistory[n] ++; // 访问历史加1}for(n=0;n<pf_info.total_pf;n++){if (pageframe[n]==page ){inpflag=0 ; //inpflag缺页标志，0为不缺页，1为缺页pagehistory[n]=0; //置访问历史为0return 1;}}inpflag=1; //页面不存在，缺页return 0;}//////////////////////////////////////////////////////////////////////// // FIFO页面置换算法void fifo(void){int n,count,pstate;rpoint=0; // 页面替换指针初始化为0invalidcount = 0; // 缺页数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满是所有的页框for(n=0;n<pf_info.total_pf;n++) // 清除页框信息{pageframe[n]=-1;}inpflag=0; //缺页标志，0为不缺页，1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0) // 页不存在则置换页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;pf_info.diseffect++; // 缺页次数加1 }}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束getch();return;}/////////////////////////////////////////////////////////////////// // LRU页面置换算法void lru(void){int n,count,pstate,max;rpoint=0; // 页面替换指针invalidcount = 0; // 缺页次数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满所有的页框for(n=0;n<pf_info.total_pf;n++){pageframe[n]=-1; // 清除页框信息pagehistory[n]=0; // 清除页框历史}inpflag=0; //缺页标志，0为不缺页，1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint]; //把要调入的页面放入一个空的页框里rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0)// 页不存在则置换页面{max=0;for(n=1;n<pf_info.total_pf;n++){if(pagehistory[n]>pagehistory[max]){max=n;}}rpoint=max;pageframe[rpoint]=pf_info.serial[vpoint];pagehistory[rpoint]=0;pf_info.diseffect++; // 缺页次数加1 }}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}/////////////////////最佳置换算法自己完成/////////////////////////////////////////////////////////////////// // 主函数int main(){char ch;system("cls") ;while ( true ){printf("*******************************************\n");printf(" 若要执行FIFO页面置算法请按1\n");printf(" 若要执行LRU 页面置算法请按2\n");printf(" 若要退出请按3\n") ;printf("*******************************************\n");printf( "Enter your choice (1 or 2 or 3): ");do{ //如果输入信息不正确，继续输入ch = (char)getch() ;}while(ch != '1' && ch != '2'&& ch != '3');printf("\n\n你按的是：%c ,现在为你执行对应操作。
002-页面置换算法模拟
页面置换算法模拟一、设计目的1.本课程设计是进行一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强动手能力。
2.熟悉页面置换算法及其实现，引入计算机系统性能评价方法的概念。
二、设计要求1．实现OPT,LRU,FIFO三种算法并进行对比分析.2.要求界面简单,易懂,关键代码部分要注释.3.编程语言可以采用自己任意精通的语言三、设计思想说明根据设计要求可以从以下几方面进行设计：1.采用Optinal、FIFO、LRU算法进行页面置换，统计缺页率2.用随机数方法产生页面走向，页面走向长度为L(15<=L<=20),L由控制台输入。
3.假定可用内存块为m(3<=m<=5)，m由控制台输入，初始时，作业页面都不在内存.四、 设计过程(1)FIFO （先进先出）设计原理：需要进行页面置换，即把内存中装入最早的那个页面淘汰，换入当前的页面。
算法流程图开始 页面走向存入数组p[]中，内存块用page[]表示初始化为0当前p[]中第i 个元素是否已在内存Page[]是否有空把p[i]的内容直接装入最上面一个空内存块，i++把page[]中最先装入的页面置换出去.i++输出当前内存块状态结束i++YYNN(2).LRU （最近最久未使用） 设计原理：当需要淘汰某一页时，选择离当前时间最近的一段时间内最久没有使用过的页先淘汰。
该算法的主要出发点是，如果某页被访问了，则它可能马上还要被访问。
或者反过来说，如果某页很长时间未被访问，则它在最近一段时间也不会被访问。
算法流程图：开始当前p[]中第i 个元素是否已在内存页面走向存入数组p[]中，内存块用page[]表示初始化为0 Page[]是否有空 把p[i]的内容直接装入最上面一个空内存块，i++ 把page[]中最近最久未使用的页面置换出去.i++ 输出当前内存块状态 结束 i++ N NY Y(3).OPT（最佳置换算法）设计原理：需要进行页面置换，把内存中以后一段时间都不使用或是使用时间离现在最远的页面换出。
常用页面置换算法模拟实验
实验环境
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 语言学习好。
实验三页面置换算法模拟实验
计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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();三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。
页面置换算法模拟_课程设计
《操作系统原理与Linux》课程设计报告专业计算机科学与技术班级学号姓名指导教师完成时间成绩目录一、设计题目 (2)二、设计目的 (2)三、设计要求 (2)四、设计思想说明 (2)1. 最佳置换算法（OPT） (2)2. 先进先出置换算法（FIFO) (3)3. 最近最久未使用置换算法(LRU) (3)五、系统结构说明 (3)1. 内存信息类(MemInfo) (5)2. 访问器(MemVisitor) (5)3. 加载器(MemLoader) (6)4. 页面走向列表类(MemReqs) (6)5. MemReplacement (6)六、数据结构说明 (6)1. 内存信息类(MemInfo) (6)2. 访问器(MemVisitor) (7)3. 加载器(MemLoader) (8)4. 页面走向列表类(MemReqs) (9)七、程序清单 (9)1. 访问器 (9)2. 加载器 (10)3. 最佳置换算法 (11)4. 先进先出算法 (13)5. 最近最久末使用算法 (13)八、使用说明书 (14)九、实验体会、建议 (17)十、参考文献 (17)一、设计题目页面置换算法模拟二、设计目的1、编写页面置换算法，实现计算机中页面置换的模拟。
2、通过算法模拟的实现，理解几种常用的页面置换算法的执行过程。
三、设计要求1、实现OPT,LRU,FIFO三种算法并进行对比分析。
2、要求界面简单,易懂,关键代码部分要注释。
3、编程语言可以采用自己任意精通的语言。
四、设计思想说明1. 最佳置换算法（OPT）最佳置换算法所选择的被淘汰掉的页面，将是以后永久不再使用的，或许是在最长（未来）时间内不再被访问的页面。
采用最佳置算法，通常可保证获得最低的缺页率。
本模拟算法中，最佳页面置换算法实现所采用的思想是：循环读入每个页表项，若该页表在内存中，则读取下一个页表项。
若页表不存在内存中：一种情况是内存不满，则将页表放入内存中；若内存块已满，刚分别计算内存中各个页表再次被使用的时间，并将最久不被访问的调出，放入当前读入页表项。
操作系统课程设计--页面置换算法的模拟实现_
操作系统课程设计--页面置换算法的模拟实现_ 题目: 页面置换算法的模拟实现_专业计算机科学与技术学生姓名班级学号指导教师发放日期信息工程学院目录1 概述 ..................................................................... .........................................................................12 设计原理 ..................................................................... .. (1)2.1 先进先出(FIFO)算法 ..................................................................... ...................................... 1 2.2 最近最久未使用(LRU)算法 ..................................................................... .......................... 1 3 详细设计与编码 ..................................................................... ..................................................... 2 3.1 模块设计 ..................................................................... .. (2)3.2 系统详细设计 ..................................................................... ...................................................... 2 4 结果与分析 ..................................................................... . (4)4.1 测试方案 ..................................................................... .. (4)4.2 测试结果 ..................................................................... .. (5)4.3测试结果分析 ..................................................................... . (8)5 设计小结 ..................................................................... .. (8)6 参考文献 ..................................................................... .. (9)附录程序代码 ..................................................................... (10)操作系统课程设计(2015)页面置换算法的模拟实现1 概述在进程运行过程中，若其所要访问的页面不在内存所需把他们调入内存，但内存已无空闲时，为了保证进程能够正常运行，系统必须从内存中调入一页程序或数据送磁盘的对换区中。
操作系统课程设计--页面置换算法的模拟实现_
操作系统课程设计--页面置换算法的模拟实现_ 题目: 页面置换算法的模拟实现_专业计算机科学与技术学生姓名班级学号指导教师发放日期信息工程学院目录1 概述 ..................................................................... .........................................................................12 设计原理 ..................................................................... .. (1)2.1 先进先出(FIFO)算法 ..................................................................... ...................................... 1 2.2 最近最久未使用(LRU)算法 ..................................................................... .......................... 1 3 详细设计与编码 ..................................................................... ..................................................... 2 3.1 模块设计 ..................................................................... .. (2)3.2 系统详细设计 ..................................................................... ...................................................... 2 4 结果与分析 ..................................................................... . (4)4.1 测试方案 ..................................................................... .. (4)4.2 测试结果 ..................................................................... .. (5)4.3测试结果分析 ..................................................................... . (8)5 设计小结 ..................................................................... .. (8)6 参考文献 ..................................................................... .. (9)附录程序代码 ..................................................................... (10)操作系统课程设计(2015)页面置换算法的模拟实现1 概述在进程运行过程中，若其所要访问的页面不在内存所需把他们调入内存，但内存已无空闲时，为了保证进程能够正常运行，系统必须从内存中调入一页程序或数据送磁盘的对换区中。
页面置换算法的模拟-(1)
课程设计报告课程名称：操作系统实验题目：页面置换算法的模拟日期：2010.07.01目录一、课程设计分析 (3)二、相关知识 (3)三、功能设计分析 (4)四、程序设计 (4)五、运行截图 (5)六、参考程序 (7)七、结果分析 (15)八、心得体会 (15)一、课程设计分析编写程序实现页面置换算法中常用的FIFO、LRU。
FIFO页面置换算法：FIFO淘汰算法是最先使用的页面最先被淘汰。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
先进先出(FIFO)页面置换算法，是根据页面调入内存后的使用情况进行决策的。
该算法是选择在内存中驻留时间最久的页面予以淘汰。
该算法赋于请求调入页面一个空间（工作集），淘汰掉最先调入的页，取而代之的是紧随它进来的页，这样就基本上实现了对最先进入内存的页面的淘汰。
LRU页面置换算法：该算法淘汰的页面是在最近一段时间里较久未被访问的那一页，它是根据程序执行时的局部性原理而设计的。
二、相关知识1．虚拟存储器的引入局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
操作系统课程设计报告--页面置换算法模拟程序设计
操作系统课程设计报告题目：页面置换算法模拟程序设计专业：软件工程院系：信息管理学院目录第一部分概述第二部分设计的基本概念和原理第三部分总体设计3.1算法流程图3.2算法的简要实现方法3.2.1 OPT页面置换算法3.2.2 FIFO页面置换算法3.2.3 LRU页面置换算法3.2.4 LFU页面置换算法第四部分详细设计4.1 main函数4.2 OPT函数4.2 FIFO函数4.3 LRU函数4.5 LFU函数4.6辅助函数4.6.1 Designer函数4.6.2 mDelay函数4.6.3 Download函数4.6.4 Compute函数4.6.5 showTable函数第五部分实现源代码第六部分简要的使用说明及主要运行界面第七部分总结第八部分参考文献第一部分概述设计任务：页面置换算法是虚拟存储管理实现的关键，通过本次课程设计理解内存页面调度的机制，在模拟实现OPT、FIFO、LRU和LFU几种经典页面置换算法的基础上，比较各种置换算法的效率及优缺点，从而了解虚拟存储实现的过程。
第二部分设计的基本概念和原理(1)．页面淘汰机制页面淘汰又称为页面置换。
若请求调页程序要调进一个页面，而此时该作业所分得的主存块已全部用完，则必须淘汰该作业已在主存中的一个页。
这时，就产生了在诸页面中淘汰哪个页面的问题，这就是淘汰算法（或称为置换算法）。
置换算法可描述为，当要索取一个页面并送入主存时，必须将该作业已在主存中的某一页面淘汰掉，用来选择淘汰哪一页的规则就叫做置换算法。
(2)．各种页面置换算法的实现思想OPT算法是当要调入一新页而必须先淘汰一旧业时，所淘汰的那一页应是以后不要再用的或是以后很长时间才会用到的页。
FIFO算法的实质是，总是选择在主存中居留时间最长（即最老）的一页淘汰。
其理由是最先调入主存的页面，其不再被使用的可能性比最近调入主存的页的可能性大。
LRU算法的实质是，当需要置换一页时，选择最长时间未被使用的那一页淘汰。
最佳页面置换算法例题
最佳页面置换算法例题
最佳页面置换算法是一种用于将一组页面按照某种规则进行页
边距和布局调整的算法。
下面是一个简单的例题,用于说明如何使用
最佳页面置换算法:
假设有一组文档,共10页,每页有4个页面。
每个页面的大小和
位置都已知,现在需要将这些文档按最佳页面置换算法进行调整,使
得每页的页面数量最少,页面距离最合理。
1. 确定每页需要的页面数量
每页需要的页面数量可以通过以下公式计算:
每页需要的页面数量 = (页数× 2 + 1) / 2
例如,第5页需要的页面数量为(5 × 2 + 1) / 2 = 8/2 = 4页。
2. 确定页面的位置和大小
接下来,需要确定每页应该包含哪些页面。
一种方法是从左到右,从上到下遍历每个页面,并在每个页面上标记出需要保留的页面数量。
例如,在第5页上,需要保留4个页面,所以标记为4个红色矩形。
另一种方法是使用布局算法来确定页面的位置和大小。
例如,可
以使用仿宋字体来设计一个布局,使得每页包含以下页面:第一页、第二页、第三页、第四页和第五页。
3. 调整文档布局
根据标记的数量和位置,使用最佳页面置换算法将文档进行布局
调整。
例如,对于上述例子,第5页应该包含以下页面:第一页、第二页、第三页、第四页和第五页。
4. 检查布局是否合理
最后,需要检查调整后的文档布局是否合理。
例如,如果在某个页面上使用了过多的页面,就需要重新调整页面数量或调整页面的位置。
最佳页面置换算法是一种常用的文档布局算法,可以帮助设计师
和开发人员高效地设计文档布局,提高文档的可读性和可用性。
lru页面置换算法模拟最近最久未使用置换算法课程设计
LRU页面置换算法模拟-最近最久未使用置换算法-课程设计LRU页面置换算法模拟-最近最久未使用置换算法|课程设计|计算机数据库课程设计一、设计目的1、用C语言实现最近最久未使用（LRU）置换算法。
2、了解内存分页管理策略3、掌握调页策略4、掌握一般常用的调度算法5、选取调度算法中的典型算法，模拟实现二、设计任务在Window98/2000 系统的TC2.0环境下运行程序；通过从一般常用的调页算法中选取典型算法LRU，了解页面管理的相关细节，并用程序设计实现LRU。
三、设计内容与步骤分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。
一、调页策略1)何时调入页面如果进程的许多页是存放在外存的一个连续区域中，则一次调入若干个相邻的页，会比一次调入一页的效率更高效一些。
但如果调入的一批页面中的大多数都未被访问，则又是低效的。
可采用一种以预测为基础的预调页策略，将那些预计在不久之后便会被访问的页面，预先调入内存。
如果预测较准确，那么，这种策略显然是很有吸引力的。
但目前预调页的成功率仅为50%。
且这种策略主要用于进程的首次调入时，由程序员指出应该先调入哪些页。
2)请求调页策略当进程在运行中需要访问某部分程序和数据时，若发现其所在的页面不在内存，便即提出请求，由OS将其所需页面调入内存。
由请示调页策略所确定调入的页，是一定会被访问的，再加之请求调页策略比较易于实现，故在目前的虚拟存储器中，大多采用此策略。
但这种策略每次仅调入一页，故须花费较大的系统开销，增加了磁盘I/O的启用频率。
2、从何处调入页面在请求分页系统中的外存分为两部分：用于存放文件的文件区和用于存放对换页面的对换区。
通常，由于对换区是采用连续分配方式，而事件是采用离散分配方式，故对换区的磁盘I/O速度比文件区的高。
这样，每当发生缺页请求时，系统应从何处将缺页调入内存，可分成如下三种情况：(1) 系统拥有足够的对换区空间，这时可以全部从对换区调入所需页面，以提高调页速度。
模拟页面置换算法FIFO、LRU的实现
实验报告五实验名称:模拟页面置换算法FIFO、LRU的实现日期：2015-12-9 班级：13级计科学号:姓名：一、实验目的了解页面置换的概念，理解页面置换的算法加深对页面置换算法的理解。
二、实验内容Java编程语言实现FIFO和LUR页面算法。
三、项目要求与分析FIFO算法当需要置换页面时，主要通过置换最早进入内存的页面从而达到先进先出的目的。
LRU算法当需要置换页面时，主要通过置换进入内存中最久没有被访问的页面而达到最近最久未使用的目的。
程序中可以通过标志位进行记录。
四、具体实现1.FIFO算法实现代码以及运行结果：public class FIFO {/*** 内存块的个数*/public static int N ;/*** 内存块数组*/Object[] array = new Object[N]; /*** 要访问的页面数组*/public static int[]visit;private int size;/*** 内存是非空为否* @return*/public boolean isEmpty() {if(0 == size)return true;elsereturn false;}/*** 内存是非空满* @return*/public boolean isFulled() {if(size >= N)return true;elsereturn false;}/*** 元素(页框)的个数* @return*/public int size() {return size;}/*** 查找元素o在数组中的位置* @param o* @return*/public int indexOfElement(Object o) { for(int i=0; i<N; i++) {if(o == array[i]) {return i;}}}/*** 页面转换* @param obj*/public Object trans(Object obj){Object e = null;int t = 0;if(indexOfElement(obj) != -1) {t = indexOfElement(obj);for(int i=t; i<size-1; i++) {array[i] = array[i+1];}array[size-1] = obj;} else {if(!isFulled()){array[size] = obj;size ++;} else {for(int i=0; i<size-1; i++) {array[i] = array[i+1];array[size-1] = obj;}}if( -1 == t) {return null;} else {return array[t];}}/*** 输出内存区中的各数据*/public void showMemoryBlock() {for(int i=0; i<size; i++) {System.out.print(array[i] + " ");}}/*** 清空队列(页框)*/public void clear(){}/*** @param args*/public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.print("请输入内存块的数量:");N=sc.nextInt();System.out.print("请输入总页面数目：");int n=sc.nextInt();visit=new int[n];System.out.println("请输入各个页的页面号码：");for(int i=0;i<n;i++)visit[i]=sc.nextInt();FIFO fifo = new FIFO();for(int i=0; i<visit.length; i++) {fifo.trans(visit[i]);fifo.showMemoryBlock();System.out.println();}运行结果：2.LUR算法实现代码以及运行结果：public class LRU {static int volum;// 栈的容量static List<Integer>list=new LinkedList<Integer>();//链表用来模拟栈存放页面static int[]visit;//要访问的页面数组static int count=0;//记录缺页次数public static void main(String []args){Scanner sc = new Scanner(System.in);System.out.print("请输入栈的容量:");volum=sc.nextInt();System.out.print("请输入总页面数目：");int n=sc.nextInt();visit=new int[n];System.out.println("请输入各个页的页面号码：");for(int i=0;i<n;i++)visit[i]=sc.nextInt();sLRU();//调用最近最久未使用算法System.out.println("置换页面的数目为："+count); }public static void sLRU(){int index=0;while(index<visit.length){boolean flag=false;if(list.size()<=volum){for(int i=0;i<list.size();i++){if((int)(list.get(i))==visit[index]){list.remove(i);//先删除list.add(visit[index]);//再添加到尾部flag=true;break;}}if(!flag){if(list.size()<volum){//如果栈未满，而且此页面没有在栈中，就将它入栈list.add(visit[index]);}else{//如果栈已经满了，且该页面号码没有在栈中，就把栈底元素删除，将新页插入int temp=list.get(0);list.remove(0);//最开始一个换出list.add(visit[index]);//加到末尾count++;System.out.println("开始换页了,将栈底的"+temp+"换出");System.out.println("这也是没有办法的事情，毕竟栈是有限的");}}System.out.print("经过第"+(index+1)+"个页面的栈内容为");for(int k=0;k<list.size();k++)System.out.print(list.get(k)+" ");System.out.println();index++;}运行结果：五、所遇问题与解决方法问题：针对于FIFO算法定义选择在内存中驻留时间最久的页面予以淘汰，对于内存中的驻留时间理解复杂了不知道如何下手。
05 页面置换算法模拟
实验页面置换算法模拟实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
实验内容设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率。
1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、最不经常使用算法（LFU）5、最近未使用算法（NUR）命中率＝１－页面失效次数／页地址流长度实验准备本实验的程序设计基本上按照实验内容进行。
即首先用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。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0 条-第9 条指令为第0页（对应虚存地址为[0，9]）第10条-第19条指令为第1页（对应虚存地址为[10，19]）………………………………第310条-第319条指令为第31页（对应虚存地址为[310，319]）按以上方式，用户指令可组成32页。
实验指导一、虚拟存储系统UNIX/Linux中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
操作系统之页面置换算法（最佳置换OPT，先进先出FIFO，最近最久未使用LRU）
操作系统之页⾯置换算法（最佳置换OPT，先进先出FIFO，最近最久未使⽤LRU）最近学习操作系统时，实验要求实现常见的三种页⾯置换算法，博主按照书上要求试着编写，实现了案例，并记录在博客随记中，以便后续⾃⼰复习并也给需要的同学分享参考⼀下!⽔平有限，若有错，请悄悄告诉博主！博主好⽴即改正。
最佳置换算法（optimal replacement，OPT）是从内存中选择今后不再访问的页⾯或者在最长⼀段时间后才需要访问的页⾯进⾏淘汰。
如下例⼦：根据页⾯⾛向依次处理，得到最终的置换结果如下图表，整个页⾯缺页次数为7，缺页率为7/12=58%。
1 #include <iostream>2 #include <stdio.h>3 #include <stdlib.h>4#define N 125#define B 36using namespace std;78int pageArr[N]={1,2,3,4,1,2,5,1,2,3,4,5};//页⾯⾛向9int block[B]={0};//物理块3个，其数值是页号10 typedef struct FLAG {11int flags[B];12int counts;13 } FLAG;1415void opt(int pageArr[],int block[]);16int inBlock(int which);17int findFar(int next);18void Replace(int index,int value);19void disPlay();2021int main(void){22 cout << "begin:" <<endl;23 opt(pageArr,block);24 cout << "end!" <<endl;25return0;26 }2728void opt(int pageArr[],int block[]){29int getIndex;30for(int i=0;i<N;i++){31if(i<3){//前3页号#短缺#进队列32 block[i]=pageArr[i];33 printf("缺页：(null)-->%d\n",pageArr[i]);34 }35else {36if(i==3){37 disPlay();3839 }40if(inBlock(pageArr[i])!=-1){//下⼀个页⾯if在物理块中返回index并跳过,反-141 disPlay();4243continue;44 }45 getIndex=findFar(i+1);//从下⼀个页号，找到最远出现的页⾯,替换的下标46if(getIndex==-1){47 cout<<"error,not replace obj!"<<'\t';48 }49else{50 Replace(getIndex,pageArr[i]);//由下标找到上⼀组替换⽬标，⽤第⼆参数替换51 disPlay();5253 }54 }55 }56return;57 }5859//替换block中的物理块60void Replace(int index,int value){61 printf("缺页：%d--被替换为-->%d\n",block[index],value);62 block[index]=value;63return;64 }656667//找到最远出现的页⾯68int findFar(int next){69int index=-1;//error，默认返回不存在的索引70 FLAG myflag;71 myflag.flags[0]=0;72 myflag.flags[1]=0;73 myflag.flags[2]=0;74 myflag.counts=0;75int stop = N-next;76while(stop--){77 index=inBlock(pageArr[next++]);78if(index!=-1){79 myflag.flags[index]=1;80 myflag.counts++;83break;84 }85 }86for(index=0;index<B;index++){87if(myflag.flags[index]==0)88break;89 }90return index;91 }929394//下⼀个页⾯if在物理块中返回index,反-195int inBlock(int which){96//int i=0;97//while(i<B)98// if(block[i++]==which)99// return i-1;100for(int i=0;i<B;i++){101if(block[i]==which)102return i;103 }104return -1;105 }106107//打印⼀元组108void disPlay(){109int i=0;110while(i<B){111 printf("%d\t",block[i++]);112 }113 printf("\n");114return;115 }上⾯是博主使⽤C++（基本是C语法）编写的代码，运⾏结果如下：//////////////////////////////////////////////////////////////////////////begin:缺页：(null)-->1缺页：(null)-->2缺页：(null)-->31 2 3缺页：3--被替换为-->41 2 41 2 41 2 4缺页：4--被替换为-->51 2 51 2 51 2 5缺页：1--被替换为-->33 2 5缺页：3--被替换为-->44 2 54 2 5end!//////////////////////////////////////////////////////////////////////////先进先出算法：先进先出置换算法（first in first out,FIFO）是淘汰最先进⼊内存的页⾯，即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计报告课程名称操作系统课题名称页面置换算法模拟设计专业通信工程班级学号姓名指导教师2014年6 月29 日湖南工程学院课程设计任务书课程名称操作系统课题页面置换算法模拟设计专业班级学生姓名学号指导老师审批任务书下达日期2014 年 6 月23 日任务完成日期2014 年 6 月29 日目录1课题概述 (4)1.1设计要求 (4)1.2 理论分析 (4)2系统分析 (6)3程序实现 (8)4程序测试 (13)5心得体会 (15)6附录 (16)7 评分表 (30)课题：页面置换算法模拟设计1课题概述1.1设计要求计算并输出下述各种算法在不同内存容量下的命中率。
A. FIFO先进先出的算法B. LRR最近最少使用算法C. OPT最佳淘汰算法（先淘汰最不常用的页地址）D. LFR最少访问页面算法E. NUR最近最不经常使用算法设计技术参数：（1）命中率=1-页面失效次数/页地址流长度（2）本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
（3）随机数产生方法，采用系统提供函数SRAND()和RAND ()来产生1.2 理论分析在进程运行过程中，若其所要访问的页面不在内存所需把他们调入内存，但内存已无空闲时，为了保证进程能够正常运行，系统必须从内存中调入一页程序或数据送磁盘的对换区中。
但应将那个页面调出，须根据一定的算法来确定。
通常，把选择换出页面的算法称为页面置换算法。
置换算法的好坏，将直接影响到系统的性能。
一个好的页面置换算法，应具有较低的页面更换频率。
从理论上将讲，应将那些以后不再访问的页面换出，或把那些较长时间内不再访问的页面调出。
目前存在着不同的算法，他们都试图更接近与理论上的目标。
拥有页面交换机制的操作系统总是把当前进程中急需处理的部分页面换入到内存当中，而把更多暂时不需要处理的页面放置在外存当中。
由于进程需要处理的页面顺序不同，因此必须要在内存与外存之间进行页面交换，页面置换算法也就应运而生。
1.先进先出（FIFO）算法这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面，即选择在内存停留时间最久的给予淘汰。
该算法实现简单，只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替代指针，使它总是指向最老的页面。
但该算法与进程实际运行的规律不相适应，因为在incheng 中，有些页面经常被访问，比如，含有全局变量，常用函数，例程等方面，FIFO 算法并不能保证这些页面不被淘汰。
当需要选择一个页面淘汰时，总是选择最先进入内存空间的那一个页面。
只要在系统中建立一个FIFO队列，以反映页面的活动情况。
被选择的页面总是处于队首的页面，而最近调入的页面永远存放在队列的尾部。
2.最近最少使用（LRR）算法FIFO置换算法的性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后不能反映页面的使用情况。
最近最少使用（LRR）的页面置换算法，是根据页面调入内存后的使用情况进行决策的。
由于无法预测各个页面将来的使用情况，只能利用“最近的过去”，作为“最近的将来”的近似。
该算法的基本思想是用最近的过去估计最近的将来。
假定在内存中的某个页面，在最近一段时间内未被使用的时间最长，那么在最近的将来也可能不再被使用。
3.理想页面置换（OPT）算法（本次程序中作两个置换算法对比作用）最佳置换算法由Belady于1966年提出，这是一种理想情况下的页面置换算法，但实际上不可能实现。
但人们目前把还无法预知一个进程在内的若干页面中，哪一个页面是未来最长时间内不再被访问，因而该算法无法实现。
基本思想是内存中每个页都用该页面首次被访问前所要执行的指令数进行标记，标记最大的页应该被置换4.OPT最佳淘汰算法（先淘汰最不常用的页地址）OPTimal replacement（OPT）它是一种理想化的算法，性能最好，但在实际上难于实现。
即选择那些永不使用的，或者是在最长时间内不再被访问的页面置换出去。
但是要确定哪一个页面是未来最长时间内不再被访问的，目前来说是很难估计的，所以该算法通常用来评价其它算法5.NUR最近最不经常使用算法为每页设置一位访问位，当每页被访问时，其访问位置 1.置换算法在替换页面时，只需要检查它的访问位，如果是0，就将该页换出，如果是1，则重新将它置为0，从而给该页第二次驻留内存的机会，再依次检查下一个页面。
如果最后一个页面依然没有被换出，则到第一个页面去重新检查。
2系统分析1．进入系统模块。
进入登陆界面，输入内存页面数和实际页数2．页面号打印模块。
打印输入的页面号。
3．菜单选择模块。
选择相应的页面的置换方式，选择相应的字母，进入相应的功能。
4．算法模块。
选择相应的页面置换算法。
5．显现输出模块。
显示页面被置换的情况。
5.缺页次数和缺页率模块。
计算页面号输入的计算结果。
6.退出系统模块。
退出置换页面。
如图2.1 模块划分:图2.1 模块划分之后进入系统模块如图2.2:图2.2 系统流程图3程序实现1. 首先贯穿全局的全局需要一系列的函数来实现本操作系统的各种功能。
需要函数自带的文件stdio.h 和stdlib.h .2.以下通过FIFO 、OPT 、LRR 三个进行举例： FIFO 页面置换和缺页次数及缺页率模块实现如下：void FIFO(){int memery[10]={0};int time[10]={0};int i,j,k,m;int max=0;int count=0;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);}LRR页面置换和缺页次数及缺页率模块实现如下：void LRR(){int memery[10]={0};int flag[10]={0};int i,j,k,m;int max=0;int count=0;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);}OPT页面置换和缺页次数及缺页率模块实现如下（本代码在页面置换中：void OPT(){int memery[10]={0};int next[10]={0};int i,j,k,l,m;int max;int count=0;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;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);}4程序测试系统刚刚进入时，有一个自己手动输入的物理块，输入要置换的页面号等，如图：图4.1 物理块如图可知：产生一组随机序列号，只要在主界面中选择我们需要的算法便可以算出我们需要的数据。
图4.2 主界面当我们选择OPT算法时，等待几秒钟，便会出现各种数据信息，如图：图4.3 OPT算法比较上述三种算法,以OPT算法的命中率最高, LRU算法次之,其次是FIFO算法。
5心得体会在这次课程设计的过程中，我了解到实践大于理论的意义，我们平时不仅要加强理论知识的积累，更要强化实践能力。
对于操作系统，实践能力更是考验一个人的能力所在。
其中也有不少汗水，但是收获大于付出。
然其中也有不少幸酸，比如，看到别的学习能力强的同学一个个都完成了老师指定的任务，自己却什么都没完成的时候，心里无比的焦急，不知该如何是好。
再比如，自己还是云里雾里的时候，内心在无数次的自责为什么自己没有别人一样好用的脑子，为什么别人经过了老师的点拨之后就一点就通，而自己对于现学的知识却什么都还是稚嫩的孩童的时候。
虽然这一切给了我打击，但是我想这不仅仅是给我在学习这条道路上给予动力，更是让我有求知欲的时候，这个时候我不会骄傲自大，我会虚心求学，我会不懂就问，我会知道自己的弱点所在。
人无完人，世界之大，青出于蓝而胜于蓝的大有人在。