页面置换算法模拟程序-附代码
页面置换算法实验(内含完整代码)
实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。
1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、简单时钟(钟表)算法（CLOCK）命中率＝１－页面失效次数／页地址流(序列)长度三、实验原理简述UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页，核心配置了四种数据结构：页表、页帧（框）号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
（1）通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：A：50%的指令是顺序执行的B：25%的指令是均匀分布在前地址部分C：25%的指令是均匀分布在后地址部分具体的实施方法是：A：在[0，319]的指令地址之间随机选取一起点mB：顺序执行一条指令，即执行地址为m+1的指令C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’D：顺序执行一条指令，其地址为m’+1E：在后地址[m’+2，319]中随机选取一条指令并执行F：重复步骤A-E，直到320次指令（2）将指令序列变换为页地址流设：页面大小为1K；用户内存（页帧）容量为4页~32页；用户虚存容量为32K。
页面置换算法模拟程序-附代码
页⾯置换算法模拟程序-附代码⽬录1．问题的提出 (2)1.1关于页⾯置换算法模拟程序问题的产⽣ (2)1.2任务分析 (2)2．需求分析 (2)3．⽅案设计 (3)4．总体设计 (4)4.1程序N-S图 (4)4.2主要的函数 (4)4.3主要流程图及代码 (5)4.3.1 FIFO（先进先出） (5)4.3.2 LRU（最近最久未使⽤） (6)4.3.3 OPT（最佳置换算法） (8)4.4实现结果 (11)5．程序测试 (14)5.1设计测试数据 (14)5.2测试结果及分析 (15)摘要随着计算机的普及⼈们的物质⽣活得到了极⼤的满⾜，⼈们在精神⽣活⽅⾯同样也需要提⾼，所以越来越多的⼈进⾏着各种各样的学习。
操作系统是计算机教学中最重要的环节之⼀，也是计算机专业学⽣的⼀门重要的专业课程。
操作系统质量的好坏，直接影响整个计算机系统的性能和⽤户对计算机的使⽤。
⼀个精⼼设计的操作系统能极⼤地扩充计算机系统的功能，充分发挥系统中各种设备的使⽤效率，提⾼系统⼯作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理，内容⽐较繁琐，具有很强的实践性。
要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果.本课程设计是学⽣学习完《操作系统教程》课程后，进⾏的⼀次全⾯的综合训练，通过课程设计，让学⽣更好地掌握操作系统的原理及实现⽅法,加深对操作系统基础理论和重要算法的理解，加强学⽣的动⼿能⼒。
熟悉页⾯置换算法及其实现，引⼊计算机系统性能评价⽅法的概念。
关键词：编制页⾯置换算法模拟程序、打印页⾯、FIFO页⾯算法、LRU页⾯置换算法、OPT页⾯置换算法。
引⾔1．问题的提出1.1关于页⾯置换算法模拟程序问题的产⽣在各种存储器管理⽅式中，有⼀个共同的特点，即它们都要求将⼀个作业全部装⼊内存⽅能运⾏，但是有两种情况：（1）有的作业很⼤，不能全部装⼊内存，致使作业⽆法运⾏；（2）有⼤量作业要求运⾏，但内存容量不⾜以容纳所有这些作业。
《操作系统》实验五：页面置换算法模拟
实验五. 请求页式存储管理的模拟[实验内容]:熟悉虚拟存储管理的各种页面置换算法，并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法（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 ,现在为你执行对应操作。
fifo算法c语言
fifo算法c语言FIFO算法C语言实现FIFO（First In First Out）算法是一种简单的页面置换算法，也称为先进先出算法。
该算法的核心思想是将最先进入内存的页面最先淘汰，即将页表中最早调入内存的页面移出内存。
本文将介绍如何使用C语言实现FIFO算法。
一、FIFO算法原理1.1 页面置换在操作系统中，为了提高程序运行效率，会将程序需要用到的数据和指令从硬盘上加载到内存中。
但是内存有限，无法容纳所有程序需要用到的数据和指令。
当内存不足时，就需要进行页面置换。
页面置换就是将当前正在使用但又不常用的页面从内存中移出，并将新的页面调入内存。
在进行页面置换时，需要选择一个合适的页面置换算法。
1.2 FIFO算法FIFO算法是一种简单而常用的页面置换算法。
它以队列为基础，将最早进入队列的页面作为被淘汰的对象。
具体来说，在FIFO算法中，操作系统会维护一个队列来记录当前正在使用的所有页面。
当需要进行页面置换时，操作系统会选择队头元素对应的页面进行淘汰，并将新调入内存中的页面插入队尾。
二、FIFO算法C语言实现2.1 算法流程FIFO算法的实现流程如下：1. 初始化页面队列，将所有页面按照调入内存的时间顺序依次插入队列；2. 当需要进行页面置换时，将队头元素对应的页面移出内存，并将新调入内存中的页面插入队尾；3. 重复执行步骤2。
2.2 代码实现下面是使用C语言实现FIFO算法的示例代码：```c#include <stdio.h>#include <stdlib.h>#define MAX_PAGE_NUM 100 // 最大页面数#define MAX_MEM_SIZE 10 // 最大内存容量int page_queue[MAX_PAGE_NUM]; // 页面队列int mem[MAX_MEM_SIZE]; // 内存int queue_head = 0; // 队头指针int queue_tail = -1; // 队尾指针// 初始化页面队列void init_page_queue(int page_num) {for (int i = 0; i < page_num; i++) {page_queue[i] = i % MAX_MEM_SIZE;}}// 页面置换函数void page_replace(int new_page) {int old_page = page_queue[queue_head]; // 获取被淘汰的页面mem[old_page] = new_page; // 将新页面调入内存中queue_tail = (queue_tail + 1) % MAX_PAGE_NUM; // 更新队尾指针queue_head = (queue_head + 1) % MAX_PAGE_NUM; // 更新队头指针}int main() {int page_num = 20; // 页面数int miss_count = 0; // 缺页次数init_page_queue(page_num);for (int i = 0; i < page_num; i++) {int page = page_queue[i];if (mem[page] == 0) { // 页面不在内存中miss_count++;page_replace(page);}}printf("缺页次数：%d\n", miss_count);return 0;}```2.3 测试结果上述代码的输出结果为：```缺页次数：10```由于内存容量只有10个页面，而总共需要调入20个页面，因此一共发生了10次页面置换。
操作系统实验 页面置换算法模拟
实验四页面置换算法模拟一、实验内容简要描述开发语言及实现平台或实验环境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();三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。
页面置换算法模拟
#include <iostream>#include <deque> //deque容器头文件#include <ctime>using namespace std;typedef struct{int id;//页面IDint stayTime;//内存中驻留时间int unUseTime; //已经多久未被使用}CPage;deque<int> RunQueue;deque<CPage> interPage; //内存中的四个页面deque<CPage> exterPage; //外存中的N个页面int presentSeat; //目前运行到了队列的第几个？int lackNum[3] ={0};int getRandNum(int range) //返回[0,range)范围内的整数{return static_cast<int>(rand()%range);}int findPageIdByCmdId(int cmdId) //判断指令属于哪个页面{return static_cast<int>(cmdId/10);}void InitDevice() //初始化运行队列按照25% 50% 25%的标准生成{srand(static_cast<int>(time(NULL)));int t_cmdNum = getRandNum(320); //随机选择第一条指令RunQueue.push_back(t_cmdNum);if(t_cmdNum < 319)RunQueue.push_back(t_cmdNum+1); //顺序执行下一条指令while(RunQueue.size() <= 320){t_cmdNum=getRandNum(t_cmdNum); //跳转到m1属于[0,m-1] RunQueue.push_back(t_cmdNum); //将m1插入队列if(t_cmdNum < 319)RunQueue.push_back(t_cmdNum+1); //将m1+1插入队列int temp = 320 - (t_cmdNum + 2);t_cmdNum = t_cmdNum+2+getRandNum(temp);//跳转到m2属于[m+2,319]RunQueue.push_back(t_cmdNum); //插入队列if(t_cmdNum < 319)RunQueue.push_back(t_cmdNum+1); //将m2+1插入队列}while(RunQueue.size() > 320)RunQueue.pop_back();}stayTime = 0;temp. void InitMemoryQueue()//初始化运行标志、内存外存页面队列{presentSeat = 0;exterPage.clear();interPage.clear();for(int i=0;i<32;i++){CPage temp;temp.id = i;temp.unUseTime = 0;exterPage.push_back(temp);}}int searchStatusOfPage(int t_PageId,bool sign)//分别在内存中查找页面存在返回位置不存在返回-1 {if(sign)for(unsigned i=0;i<interPage.size();i++){if(t_PageId == interPage[i].id)return i;}elsefor(unsigned j=0;j<exterPage.size();j++)if(t_PageId == exterPage[j].id)return j;return -1;}int searchNextStatusOfInterPage(int start, int id) //OPT算法中查找内存页面中的页面下次需要用到它的时候的队列下标{for(int i=start;i < 320;i++)if(static_cast<int>(RunQueue[i]/10) == id)return i;return -1;}int findLongestStayTimePage()//FIFO算法中查找在内存中呆了最久的页面{int max = 0;for(unsigned i=1;i<interPage.size();i++)if(interPage[i].stayTime>interPage[max].stayTime)max = i;return max;}int findLongestUnUseTimePage()//LRU算法中查找最久未使用的页面{int max = 0;for(unsigned j=0;j<interPage.size();j++)if(interPage[j].unUseTime>interPage[max].unUseTime)max = j;return max;}int findNeedLongestTimePage() //OPT算法中查找最长时间不会用到的页面{deque<int> temp;for(unsigned i=0;i < interPage.size();i++){ Int it =searchNextStatusOfInterPage(presentSeat,interPage[i].id);if(it == -1)return i;temp.push_back(it);}int max = -1,status = 0;for(unsigned j=1;j < temp.size();j++){ if(max < temp[j]) {max = temp[j];status = j; }}return status; }//返回需要最长时间才执行的页面在内存的位置void directFlod(int t_PageId) //当内存有剩余时直接调入{ int status = searchStatusOfPage(t_PageId,false);if(status == -1) return;interPage.push_back(exterPage[status]); //插入节点到内存exterPage.erase(exterPage.begin()+status); }bool Manage(int count,int t_PageId) //内存满需按三种算法调度{ int status = searchStatusOfPage(t_PageId,false);//获取执行页面在外存中的索引地址if(status == -1) return false;int targetStatus = 0;if(count == 0)targetStatus = findNeedLongestTimePage();else if(count == 1)targetStatus = findLongestStayTimePage();else if(count == 2)targetStatus = findLongestUnUseTimePage(); interPage[targetStatus].stayTime = 0;interPage[targetStatus].unUseTime = 0;swap(exterPage[status],interPage[targetStatus]); return true; }void Run(int count) //通过count来决定使用什么算法{ while(presentSeat < 320){ for(unsigned i=0;i<interPage.size();i++){ interPage[i].stayTime++;interPage[i].unUseTime++;}int t_PageId =findPageIdByCmdId(RunQueue[presentSeat++]),stat us = -1;//找到当前将要执行的指令的页面号if((status =searchStatusOfPage(t_PageId,true)) != -1) { interPage[status].unUseTime = 0;continue;}lackNum[count]++;if(interPage.size()<4)directFlod(t_PageId);elseManage(count,t_PageId);} }void main(void){InitDevice();int count = 0;while(count<3){InitMemoryQueue();Run(count);cout<<(double)lackNum[count++]/320*100<<"%"<< endl; } }。
操作系统课程设计--页面置换算法的模拟实现_
操作系统课程设计--页面置换算法的模拟实现_ 题目: 页面置换算法的模拟实现_专业计算机科学与技术学生姓名班级学号指导教师发放日期信息工程学院目录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 概述在进程运行过程中，若其所要访问的页面不在内存所需把他们调入内存，但内存已无空闲时，为了保证进程能够正常运行，系统必须从内存中调入一页程序或数据送磁盘的对换区中。
实验四页面置换算法代码（一）
实验四页面置换算法代码（一）预览说明:预览图片所展示的格式为文档的源格式展示,下载源文件没有水印,内容可编辑和复制实验四页面置换算法模拟（2）一．题目要求：设计一个虚拟存储区和内存工作区，编程序演示下述算法的具体实现过程，并计算访问命中率：要求设计主界面以灵活选择某算法，且以下算法都要实现1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)二．实验目的：1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。
2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三．相关知识：1．虚拟存储器的引入：局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
5．页面置换算法：常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
(完整word版)实验八页面置换模拟程序设计C语言实验
实验八页面置换模拟程序设计一、【实验目的】加深对请求页式存储管理实现原理的理解，掌握页面置换算法。
二、【实验内容】1．假设分给一作业的内存块数为4，每个页面中可存放10条指令。
2．用C语言设计一个程序,模拟一作业的执行过程。
设该作业共有320条指令,即它的地址空间为32页，目前它的所有页面都还未调入内存。
在模拟过程中，如果所访问的指令已经在内存，则显示其物理地址，并转下一条指令。
如果所访问的指令尚未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存.如果4个内存块中均已装入该作业的虚页面，则需进行页面置换。
最后显示其物理地址，并转下一条指令。
在所有320条指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。
3．置换算法：请分别考虑OPT、FIFO和LRU算法.4．作业中指令的访问次序要求按下述原则生成：50%的指令是顺序执行的.25％的指令是均匀分布在前地址(即低地址）部分。
25％的指令是均匀分布在后地址（即高地址）部分。
具体的实施办法是：①在［0，319］之间随机选取一条起始执行指令，其序号为m;②顺序执行下一条指令，即序号为m+1的指令；③通过随机数,跳转到前地址部分［0,m-1］中的某条指令处，其序号为m1；④顺序执行下一条指令，即序号为m1+1的指令；⑤通过随机数,跳转到后地址部分［m1+2，319]中的某条指令处,其序号为m2；⑥顺序执行下一条指令,即序号为m2+1的指令；⑦重复“跳转到前地址部分、顺序执行、跳转到后地址部分、顺序执行”的过程，直至执行完全部320条指令。
5。
随机数产生办法，Linux或UNIX系统提供函数strand(）和rand(）,分别进行初始化和产生随机数。
例如：strand (）; 语句可初始化一个随机数；a[0］=10＊rand（)/65535＊319+1; a［1］=10*rand()/65535*a[0]; 语句可用来产生a［0］与a［1］中的随机数。
实验报告页面置换算法(c语言实现)
实验三页面置换算法#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20int M; struct Proi nt num,time;};I nput(int m,Pro p[L]){i nt i,j,c;c out<<"请输入实际页面走向长度L(15<=L<=20)：";d o{c in>>m;i f(m>20||m<15)cout<<"实际页面长度须在15～20之间;请重新输入L：";e lse break;}while(1);j=time(NULL);s rand(j);c out<<"输出随机数: ";f or(i=0;i<m;i++){p[i].num=rand( )%10+1;p[i].time=0;c out<<p[i].num<<" ";}c out<<endl;r eturn m;}v oid print(Pro *page1){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++)i f(page[i].num==-1)c out<<" ";e lsec out<<page[i].num<<" ";c out<<"√"<<endl;}i nt Search(int e,Pro *page1 ){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++) if(e==page[i].num) return i; r eturn -1;}i nt Max(Pro *page1){}i nt Count(Pro *page1,int i,int t,Pro p[L]){}i nt main(){i nt c;i nt m=0,t=0;f loat n=0;P ro p[L];c out<<"********************************************* "<<endl;c out<<" * 页式存储管理*"<<endl;c out<<"********************************************* "<<endl;c out<<"请输入可用内存页面数m(3～5): ";d o{c in>>M;i f(M>5||M<3)c out<<"内存块M须在3～5之间，请重新输入M：";e lse break;}while(1);m=Input(m,p);P ro *page=new Pro[M];c out<<"^-^欢迎进入操作系统界面^-^"<<endl;c out<<"1:FIFO页面置换"<<endl;c out<<"2:LRU页面置换"<<endl;c out<<"3:OPT页面置换"<<endl;c out<<"4:退出"<<endl;d o{c out<<"按1～4键操作："<<endl;c in>>c;s ystem("cls");f or(int i=0;i<M;i++){p age[i].num=-1;p age[i].time=m-1-i;}i=0;i f(c==1){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0) {cout<<p[i].num<<" "; p[i].numc out<<"不缺页"<<endl;i++;}e lse {i f(t==M)t=0;e lse{n++;p age[t].num=p[i].num;c out<<p[i].num<<" ";p rint(page);t++;i++;}}}c out<<"缺页次数："<<n<<" }i f(c==2){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" LRU算法页面置换情况如下: "<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i nt a;t=Search(p[i].num,page);i f(t>=0){p age[t].time=0;for(a=0;a<M;a++)i f(a!=t)page[a].time++;cout<<p[i].num<<" ";c out<<"不缺页"<<endl;}e lse{n++; t=Max(page);page[t].num=p[i].num; page[t].time=0;cout<<p[i].num<<" ";p rint(page);f or(a=0;a<M;a++)i f(a!=t)page[a].time++;}i++;}c out<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}i f(c==3){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" OPT算法置换情况如下:"<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0){c out<<p[i].num<<" ";c out<<"不缺页"<<endl;i++;}e lse{i nt a=0;f or(t=0;t<M;t++)i f(page[t].num==0)a++;if(a!=0) {i nt q=M;f or(t=0;t<M;t++)i f(page[t].num==0&&q>t)q=t;p age[q].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}e lse{i nt temp=0,s;f or(t=0;t<M;t++)i f(temp<Count(page,i,t,p)){t emp=Count(page,i,t,p);s=t;}page[s].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}}}c out<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}i f(c==4){c out<<" ^-^再见！^-^ "<<endl;}}while(c==1||c==2||c==3||c==4);r eturn 0;}结果：完成相关实验并且获得预期结果.。
常用页面置换算法模拟实验
目录一、摘要 (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）计算访问命中率。
页面置换算法(FIFO算法,LRU算法)
实验四页面置换算法一、实验流程图二、实验程序#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define null 0#define len sizeof(struct page)struct page{ int num;int tag;struct page *next;};struct page *create(int n) /*建立分配的内存空间，并初始化，返回头结点*/{int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len); //开辟一个新的单元,并将malloc返回的指针转换为结构体类型的指针p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;struct page *cp,*dp,*head,*new1;int count=0;head=create(n);p=array;while(*p!=-1){ cp=dp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if (cp->num==*p) printf(" ! " );else{ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){cp->num=*p;printf(" * ");}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*new1,*endp;head=create(n);while(*p!=-1){cp=dp=rp=endp=head;for(;endp->next!=null;) endp=endp->next;for(;cp->num!=*p&&cp->next!=null;){rp=cp;cp=cp->next;}if(cp->num==*p){printf(" ! ");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;{printf(" * ");cp->num=*p;cp->tag=0;}else{new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*new1;p=array;head=create(n);while(*p!=-1){ cp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if(cp->num!=*p){ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){printf(" * ");cp->num=*p;cp->tag=0;}else{ i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){ for(;*q!=cp->num&&cp->next!=null;) cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){for(;cp->tag!=0;) cp=cp->next;printf(" %d ",cp->num);cp->num=*p;}else{ cp=head;for(;cp->tag!=0;) cp=cp->next;if(cp==head){ for(;cp->next!=null;) cp=cp->next;new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}else{ printf(" %d ",cp->num);cp->num=*p;}}cp=head;for(;cp->next!=null;) {cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf(" ! ");p++;}printf("\nQueye Zongshu : %d \n",count);}main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Cann't open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF)/*将数字字符串转化成整型-开始*/ {if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1) break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n') break;else{space=1;j++;i=0;}}}}}/*结束*/if(pt==EOF) {str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1) {printf(" %d ",page[i]);i++;}fclose(fp);printf("\n");printf(" ! : mean no moved \n * : mean have free space \n\n"); printf("FIFO ");FIFO(page,3);printf("\nLRU ");LRU(page,3);printf("\nOPT ");OPT(page,3);}。
页面置换算法模拟(原创)
}
void destroy_blockBlock.front){
Block.front=Block.front->next;
free(Block.rear);
}
free(page);
}
void init_page()//初始化页面系列
printf("页面号*");
for(i=0;i < BlockSize;i++)
printf(" ");
printf(" * 是否缺页 *\n");
printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
for(i=0;i<PageCount;i++){
}
node=Block.front;
max_node_last=node;
while(node=node->next){//寻找Block中next_order值最大的节点的上一个节点
if(node == max_node)
break;
max_node_last=node;
}
return;
}
dequeue();
enqueue(page_index);
Block.miss_flag=1;
Block.miss_count++;
}
void OPT_Replace(int page_index)//OPT置换
{
BlockNode *node;
BlockNode *max_node,*max_node_last;
操作系统实验4(虚拟内存页面置换算法)
操作系统实验报告四【实验题目】虚拟内存页面置换算法【实验目的】通过这次实验, 加深对虚拟内存页面置换概念的理解, 进一步掌握先进先出FIFO, 最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
【实验内容】问题描述:设计程序模拟先进先出FIFO, 最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m, 在进程运行过程中要访问的页面个数为n, 页面访问序列为P1, …,Pn, 分别利用不同的页面置换算法调度进程的页面访问序列, 给出页面访问序列的置换过程, 计算每种算法缺页次数和缺页率。
程序要求如下:1）利用先进先出FIFO, 最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。
2）模拟三种算法的页面置换过程, 给出每个页面访问时的内存分配情况。
3）输入：最小物理块数m, 页面个数n, 页面访问序列P1, …,Pn, 算法选择1-FIFO, 2-OPI, 3-LRU。
4）输出: 每种算法的缺页次数和缺页率。
【实验要求】1) 上机前认真复习页面置换算法, 熟悉FIFO, OPI, LRU三种页面分配和置换算法的过程；2) 上机时独立编程、调试程序；3) 根据具体实验要求, 完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图）。
【源代码】//--------------- YeMianZhiHuan.cpp -----------------#include "iostream.h"const int DataMax=100;const int BlockNum = 10;int DataShow[BlockNum][DataMax]; // 用于存储要显示的数组bool DataShowEnable[BlockNum][DataMax]; // 用于存储数组中的数据是否需要显示//int Data[DataMax]={4,3,2,1,4,3,5,4,3,2,1,5,6,2,3,7,1,2,6,1}; // 测试数据//int N = 20; // 输入页面个数int Data[DataMax]; // 保存数据int Block[BlockNum]; // 物理块int count[BlockNum]; // 计数器int N ; // 页面个数int M;//最小物理块数int ChangeTimes;void DataInput(); // 输入数据的函数void DataOutput();void FIFO(); // FIFO 函数void Optimal(); // Optimal函数void LRU(); // LRU函数///*int main(int argc, char* argv[]){DataInput();// DataInput();// FIFO();// Optimal();// LRU();// return 0;int menu;while(true){cout<<endl;cout<<"* 菜单选择*"<<endl;cout<<"*******************************************************"<<endl;cout<<"* 1-FIFO *"<<endl;cout<<"* 2-Optimal *"<<endl;cout<<"* 3-LRU *"<<endl;cout<<"* 0-EXIT *"<<endl;cout<<"*******************************************************"<<endl;cin>>menu;switch(menu){case 1: FIFO();break;case 2: Optimal();break;case 3: LRU();break;default: break;}if(menu!=1&&menu!=2&&menu!=3) break;}}//*/void DataInput(){cout<<"请输入最小物理块数: ";cin>>M;while(M > BlockNum) // 大于数据个数{cout<<"物理块数超过预定值, 请重新输入: "; cin>>M;}cout<<"请输入页面的个数: ";cin>>N;while(N > DataMax) // 大于数据个数{cout<<"页面个数超过预定值, 请重新输入: "; cin>>N;}cout<<"请输入页面访问序列: "<<endl;for(int i=0;i<N;i++)cin>>Data[i];}void DataOutput(){int i,j;for(i=0;i<N;i++) // 对所有数据操作{cout<<Data[i]<<" ";}cout<<endl;for(j=0;j<M;j++){cout<<" ";for(i=0;i<N;i++) // 对所有数据操作{if( DataShowEnable[j][i] )cout<<DataShow[j][i]<<" ";elsecout<<" ";}cout<<endl;}cout<<"缺页次数: "<<ChangeTimes<<endl;cout<<"缺页率: "<<ChangeTimes*100/N<<"%"<<endl;}void FIFO(){int i,j;bool find;int point;int temp; // 临时变量ChangeTimes = 0;for(j=0;j<M;j++)for(i=0;i<N;i++)DataShowEnable[j][i] = false; // 初始化为false, 表示没有要显示的数据for(i=0;i<M;i++){count[i] = 0; // 大于等于BlockNum, 表示块中没有数据, 或需被替换掉// 所以经这样初始化（3 2 1）, 每次替换>=3的块, 替换后计数值置1,// 同时其它的块计数值加1 , 成了（1 3 2 ）, 见下面先进先出程序段}for(i=0;i<N;i++) // 对有所数据操作{// 增加countfor(j=0;j<M;j++)count[j]++;find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] ){find = true;}}if( find ) continue; // 块中有该数据, 判断下一个数据// 块中没有该数据ChangeTimes++; // 缺页次数++if( (i+1) > M ) // 因为i是从0开始记, 而M指的是个数, 从1开始, 所以i+1{//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0; // 更新计数值// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"FIFO => "<< endl;DataOutput();}void Optimal(){int i,j,k;bool find;int point;int temp; // 临时变量, 比较离的最远的时候用ChangeTimes = 0;for(j=0;j<M;j++)for(i=0;i<N;i++)DataShowEnable[j][i] = false; // 初始化为false, 表示没有要显示的数据// for(i=0;i<M;i++)// {// count[i] = 0 ; //// }for(i=0;i<N;i++) // 对有所数据操作{find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] )find = true;}if( find ) continue; // 块中有该数据, 判断下一个数据// 块中没有该数据, 最优算法ChangeTimes++; // 缺页次数++for(j=0;j<M;j++){// 找到下一个值的位置find = false;for( k =i;k<N;k++){if( Block[j] == Data[k] ){find = true;count[j] = k;break;}}if( !find ) count[j] = N;}if( (i+1) > M ) // 因为i是从0开始记, 而BlockNum指的是个数, 从1开始, 所以i+1{//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"Optimal => "<< endl;DataOutput();}void LRU(){int i,j;bool find;int point;int temp; // 临时变量ChangeTimes = 0;for(j=0;j<M;j++)for(i=0;i<N;i++)DataShowEnable[j][i] = false; // 初始化为false, 表示没有要显示的数据for(i=0;i<M;i++){count[i] = 0 ;}for(i=0;i<N;i++) // 对有所数据操作{// 增加countfor(j=0;j<M;j++)count[j]++;find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] ){count[j] = 0;find = true;}}if( find ) continue; // 块中有该数据, 判断下一个数据// 块中没有该数据ChangeTimes++; // 缺页次数++if( (i+1) > M ) // 因为i是从0开始记, 而BlockNum指的是个数, 从1开始, 所以i+1{//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0;// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"LRU => "<< endl;DataOutput();}【效果截图】以作业为测试数据:。
操作系统之页面置换算法（最佳置换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）是淘汰最先进⼊内存的页⾯，即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
实验四 页面置换算法代码(一)
实验四页面置换算法模拟（2）一．题目要求：设计一个虚拟存储区和存工作区，编程序演示下述算法的具体实现过程，并计算访问命中率：要求设计主界面以灵活选择某算法，且以下算法都要实现1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入存的页面，即选择在存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)二．实验目的：1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。
2、熟悉存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三．相关知识：1．虚拟存储器的引入：局部性原理：程序在执行时在一较短时间仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
5．页面置换算法：常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
四．设计思想：选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换：OPT基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
页面置换算法代码实现(完整版)
实验原理：在内存运行过程中，若其所要访问的页面不在内存而需要把他们调入内存，但内存已经没有空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据送磁盘的对换区中。
但应将那个页面调出，需根据一定的算法来确定。
通常，把选择换出页面的算法成为页面置换算法。
置换算法的好坏，将直接影响到系统的性能。
一个好的页面置换算法，应具有较低的页面更换频率。
从理论上讲，应将那些以后不再会访问的页面置换出，或者把那些在较长时间内不会在访问的页面调出。
目前存在着许多种置换算法（如FIFO，OPT，LRU），他们都试图更接近理论上的目标。
实验目的：1．熟悉FIFO，OPT和LRU算法2．比较三种算法的性能优劣实验内容：写出FIFO，OPT和LRU算法的程序代码，并比较它们的算法性能。
实验步骤：代码如下：#include <>#define M 4 um =-1;mm[i].time =0;}}ime > max){max=mm[i].time ;pos=i;}}return pos;}um!=i){mm[0].time++;}if(mm[1].num!=i){mm[1].time++;}if(mm[2].num!=i){mm[2].time++;}if(mm[3].num!=i){mm[3].time++;}}for(i=0;i<M;i++){if(mm[i].time>max){max=mm[i].time;pos=i;}}return pos;}um == fold)return i;}return -1;}um == -1)return i;}return -1;}um = fold;}um = fold;mm[c].time = 0;}queue1[K++]=fold;}for(i=0;i<M;i++){if(mm[i].num != -1){mm[i].time ++;}}}void OPT(int fold){int a,b,c;a=Equation(fold);if(a == -1){um = fold;um = fold;mm[c].time = 0;}queue3[T++]=fold;}}void LRU(int fold){int i;int a,b;int p;a=Equation(fold);if(a != -1)um=mm[a+1].num;mm[3].num=fold;}else if(p<=3)um=mm[a+1].num;mm[a].num=fold;}}}else{b=Check();if(b!=-1)um=fold;elsefor(i=0;i<3;i++)mm[i].num=mm[i+1].num;mm[3].num=fold;}queue2[S++]=fold;}}void main(){int A[N],B[N];int i;INIT();printf("请依次输入%d个页面号：\n",N);for(i=0;i<N;i++){scanf("%d",&A[i]);}//FIFOfor(i=0;i<N;i++){B[i]=A[i];}for(i=0;i<N;i++){FIFO( B[i] );}printf("FIFO的");printf("调入队列为：");printf("%3d",queue1[i]);printf("\n缺页次数为：%6d\n缺页率：%16.6f\n\n",K,(float)K/N);//LRUINIT();for(i=0;i<N;i++){B[i]=A[i];}for(i=0;i<N;i++){LRU( B[i] );}printf("LRU的");printf("调入队列为：");for(i=0;i<S;i++)printf("%3d",queue2[i]);printf("\n缺页次数为：%6d\n缺页率：%16.6f\n\n",S,(float)S/N);//OPTINIT();for(i=0;i<N;i++){B[i]=A[i];}for(i=0;i<N;i++){OPT( B[i] );}printf("OPT的");printf("调入队列为：");printf("%3d",queue3[i]);printf("\n缺页次数为：%6d\n缺页率：%16.6f\n\n",T,(float)T/N); }。
内存页面置换算法模拟
页面置换算法模拟设计思想说明根据设计要求可以从以下几方面进行设计：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++ Y Y N N(2).LRU （最近最久未使用）设计原理：当需要淘汰某一页时，选择离当前时间最近的一段时间内最久没有使用过的页先淘汰。
该算法的主要出发点是，如果某页被访问了，则它可能马上还要被访问。
或者反过来说，如果某页很长时间未被访问，则它在最近一段时间也不会被访问。
算法流程图：输出当前内存块状态 结束 开始 当前p[]中第i 个元素是否已在内存页面走向存入数组p[]中，内存块用page[]表示初始化为0Page[]是否有空 把p[i]的内容直接装入最上面一个空内存块，i++ 把page[]中最近最久未使用的页面置换出去.i++输出当前内存块状态 结束i++ N N Y Y(3).OPT （最佳置换算法）设计原理：需要进行页面置换，把内存中以后一段时间都不使用或是使用时间离现在最远的页面换出。
流程图：（4）.随机数发生器#include <stdlib.h>#include <time.h> //准备用时钟函数调用库函数t=time(NULL);//取时钟时间并存入t 调用库函数srand(t);//用时间t 初始化随机数发生器调用 库函数 开始 页面走向存入数组p[]中，内存块用page[]表示初始化为0当前p[]中第i 个元素是否已在内存Page[]是否有空 把page[]中以后一段时间都不使用或是使用时间离现在最远的换出.i++把p[i]的内容直接装入最上面一个空内存块，i++ 输出当前内存块状态结束N N Y Y i++x=rand( )%10+1;//返回一个1~10之间的随机数程序清单#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20//页面走向长度最大为20int M; //内存块struct Pro//定义一个结构体{int num,time;};int Input(int m,Pro p[L])//打印页面走向状态{cout<<"请输入实际页面走向长度L（l<=20)：";do{cin>>m;if(m>20)cout<<"实际页面长度须小于等于20;请重新输入L：";else break;}while(1);int i,j;j=time(NULL);//取时钟时间srand(j);//以时钟时间x为种子，初始化随机数发生器cout<<"输出随机数: ";for(i=0;i<m;i++){p[i].num=rand( )%10+1;//产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<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,i=0;int m=0,t=0;float n=0;Pro p[L];m=Input(m,p);//调用input函数，返回m值cout<<"请输入可用内存页面数m(m<5): ";do{cin>>M;if(M>5)cout<<"内存块m须小于等于5，请重新输入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)页面置换"<<endl;cout<<" 2－－－－－－:最近最久未使用(LRU)页面置换"<<endl;cout<<" 3－－－－－－:最佳(OPT)页面置换"<<endl;cout<<"************************************************************** *************"<<endl;cin>>c;if(c==1)//FIFO页面置换{n=0;cout<<" ************************************************ "<<endl;cout<<endl;cout<<" 先进先出(FIFO)页面置换情况如下: "<<endl;cout<<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<<endl;}if(c==2)//LRU页面置换{n=0;cout<<"*************************************************** "<<endl;cout<<endl;cout<<" 最近最久未使用(LRU)页面置换情况如下: "<<endl;cout<<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<<endl;}if(c==3)//OPT页面置换{n=0;cout<<"*************************************************** "<<endl;cout<<endl;cout<<" 最佳(OPT)页面置换:"<<endl;cout<<endl;cout<<"**************************************************** "<<endl;while(i<m){if(Search(p[i].num,page)>=0)//如果已在内存块中{cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}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<<endl;}}while(c==1||c==2||c==3);return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1．问题的提出 (2)1.1关于页面置换算法模拟程序问题的产生 (2)1.2任务分析 (2)2．需求分析 (2)3．方案设计 (3)4．总体设计 (4)4.1程序N-S图 (4)4.2主要的函数 (4)4.3主要流程图及代码 (5)4.3.1 FIFO（先进先出） (5)4.3.2 LRU（最近最久未使用） (6)4.3.3 OPT（最佳置换算法） (8)4.4实现结果 (11)5．程序测试 (14)5.1设计测试数据 (14)5.2测试结果及分析 (15)摘要随着计算机的普及人们的物质生活得到了极大的满足，人们在精神生活方面同样也需要提高，所以越来越多的人进行着各种各样的学习。
操作系统是计算机教学中最重要的环节之一，也是计算机专业学生的一门重要的专业课程。
操作系统质量的好坏，直接影响整个计算机系统的性能和用户对计算机的使用。
一个精心设计的操作系统能极大地扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。
要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果.本课程设计是学生学习完《操作系统教程》课程后，进行的一次全面的综合训练，通过课程设计，让学生更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
熟悉页面置换算法及其实现，引入计算机系统性能评价方法的概念。
关键词：编制页面置换算法模拟程序、打印页面、FIFO页面算法、LRU页面置换算法、OPT页面置换算法。
引言1．问题的提出1.1关于页面置换算法模拟程序问题的产生在各种存储器管理方式中，有一个共同的特点，即它们都要求将一个作业全部装入内存方能运行，但是有两种情况：（1）有的作业很大，不能全部装入内存，致使作业无法运行；（2）有大量作业要求运行，但内存容量不足以容纳所有这些作业。
而虚拟内存技术正式从逻辑上扩充内存容量，将会解决以上两个问题。
从内存中调出一页程序或数据送磁盘的对换区中，通常，把选择换出的页面的算法称为页面置换算法（Page-Replacement Algorithms）。
进而页面置换算法模拟程序能客观的将其工作原理展现在我们面前。
1.2 任务分析首先，定义宏变量，设置所占最大内存长度。
编辑以时间为种子，初始化随即发生器。
进行相关页面输入程序的编写以及页面的打印。
尔后，寻找最近最近最久未使用的页面、记录当前内存块中页面离下次使用间隔长度等相关程序的代码编写。
最后，进行)FIFO 、LRU、 OPT三种算法的编写。
2．需求分析1.用随机数方法产生页面走向，页面走向长度为L。
2.根据页面走向，分别采用FIFO和LRU算法进行页面置换，统计缺页率；为简化操作，在淘汰一页时，只将该页在页表中抹去,而不再判断它是否被改写过，也不将它写回到辅存。
3.假定可用内存块和页表长度 (作业的页面数)分别为m和k，初始时，作业页面都不在内存。
随机数产生程序：int i,j;j=time(NULL);//取时钟时间srand(j);//以时钟时间x为种子，初始化随机数发生器cout<<"输出随机数: ";for(i=0;i<m;i++){p[i].num=rand( )%10+1;//产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}上述随机数发生函数产生的随机数为0.0～1.0，稍另变化就可得到0～n 1之间的随机数。
程序开始时，应对变量Seed (实型)赋初值。
根据页面置换算法的理论操作及要求，首先要进行页面长度的确定，定义结构体用以储存数据，进行主界面代码及FIFO、LRU、OPT页面置换算法代码的编写。
3．方案设计首先，定义宏变量，设置所占最大内存长度。
编辑以时间为种子，初始化随即发生器。
进行相关页面输入程序的编写以及页面的打印。
其次，寻找最近最近最久未使用的页面、记录当前内存块中页面离下次使用间隔长度等相关程序的代码编写。
最后，进行FIFO 、LRU、 OPT三种算法的编写。
．程序运行平台VC++6.0具体操作如下：在VC++6.0的环境下准备用时钟函数调用库函数（#include <time.h>）、取时钟时间并存入t调用库函数（t=time(NULL)）、用时间t初始化随机数发生器调用库函数（srand(t)返回一个1~10之间的随机数（x=rand( )%10+1）。
编写三种算法。
4．总体设计4.1 程序N-S图4.2 主要的函数Input(int m,Pro p[L])（打印页面走向状态）；void print(Pro *page1)（打印当前的页面）；int Search(int e,Pro *page1 )（寻找内存块中与e相同的块号）；int Max(Pro *page1)（寻找最近最长未使用的页面）；int Count(Pro *page1,int i,int t,Pro p[L])（记录当前内存块中页面离下次使用间隔长度）；int main()（主函数）；.随机数发生器#include <stdlib.h>#include <time.h> //准备用时钟函数调用库函数t=time(NULL);//取时钟时间并存入t调用库函数srand(t);//用时间t初始化随机数发生器调用库函数x=rand( )%10+1;//返回一个1~10之间的随机数4.3 主要流程图及代码4.3.1 FIFO（先进先出）设计原理：需要进行页面置换，即把内存中装入最早的那个页面淘汰，换入当前的页面。
算法流程图图4-1FIFO算法流程图代码：if(c==1)//FIFO页面置换{n=0;cout<<" ****************************************** "<<endl;cout<<endl;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<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<<endl;}4.3.2 LRU（最近最久未使用）设计原理：当需要淘汰某一页时，选择离当前时间最近的一段时间内最久没有使用过的页先淘汰该算法的主要出发点是，如果某页被访问了，则它可能马上还要被访问。
或者反过来说如果某页很长时间未被访问，则它在最近一段时间也不会被访问。
算法流程图：图4-2 LRU算法流程图代码：if(c==2)//LRU页面置换{n=0;cout<<" ******************************************"<<endl;cout<<endl;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<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<<endl;}4.3.3 OPT（最佳置换算法）设计原理：需要进行页面置换，把内存中以后一段时间都不使用或是使用时间离现在最远的页面换出。
流程图：图4-3 OPT 流程图代码： if(c==3) //OPT页面置换{n=0;cout<<" ****************************************** "<<endl;cout<<endl;cout<<" OPT算法置换情况如下:"<<endl;cout<<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<<endl;}4.4 实现结果程序在运行的情况下，进入主界面输入菜单，如图3-3所示：输入14：图4-5 输入14后的输出图输入25：图5-6输入数据25后输出图输入数据18：图5-7 输入数据18后的输出图输入数据：图5-8输出图选1，进入FIFO页面置换：图5-9 FIFO的输出图选2，进入LRU页面置换：图5-10 LRU的输出图输入3，进入OPT页面置换：图5-11 OPT的输出图5．程序测试5.1 设计测试数据A 14 25 18 ；2 6 4 ；B 1C 2D 35.2 测试结果及分析1）测试A结果及分析进入主菜单后输入14、25，显示输入不满足要求。