页式虚拟存储管理FIFO、LRU和OPT页面置换算法
详解页式管理置换算法FIFO_LRU_OPT
页式管理OPT、LRU、FIFO置换算法详解指令：1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6若内存最多容纳4个页面，则……一、OPT（理想型淘汰）算法该算法无法实现。
置换规则：（1）淘汰内存中以后不再访问的页面；（2）如果没有（1），则淘汰将要访问指令之后的将来最迟被访问的指令的页面。
分析：（1）当访问5时，内存1,2,3,4,发生第5次中断，淘汰不再访问的4，换入5，内存1,2,3,5；（2）当访问6时，内存1,2,3,5,发生第6次中断，淘汰不再访问的5，换入6，内存1,2,3,6；（3）当访问7时，内存1,2,3,6,发生第7次中断，由于之后的指令（1、2、3、6）都是现在内存页面都存在的指令，无法淘汰，但可以根据指令访问顺序，先淘汰将来最迟被访问的1，换入7，置换后的内存7,2,3,6；（4）当访问1时，内存7,2,3,6,发生第8次中断，淘汰不再访问的7，换入1，内存1,2,3,6；即OPT算法一共会出现8次缺页中断。
二、LRU（最近最久未使用）算法该算法利用堆栈实现，每次访问都调整堆栈中页面顺序。
把被访问页面从栈移出再压入栈顶。
置换规则：（1）栈顶始终为最新访问过的页面；（2）栈底始终为最近最久未被访问的页面；（3）访问存在的页面要调到栈顶。
分析：（1）访问第5个指令2时，由于内存页面中已经存在2，所以不置换，但调整2在栈中顺序，即将2调到栈顶，其它页面依次后置。
调整前内存4,3,2,1,调整后内存2,4,3,1；（2）访问第7个指令5时，发生第5次中断，原内存1,2,4,3,淘汰栈底3，栈顶调入5，调整后内存5,1,2,4；（3）访问第8个指令6时，发生第6次中断，原内存5,1,2,4,，淘汰栈底4，栈顶调入6，调整后内存6,5,1,2；……即LRU算法一共会出现10次缺页中断。
三、FIFO（先进先出）算法该算法利用队列实现。
FIFO与LRU的区别是FIFO遇到内存中存在的页面不需要调换页面顺序。
OPT、FIFO、LRU算法的实现
OPT、FIFO、LRU算法的实现⼀、实验⽬的1. 了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中⼏种基本页⾯置换算法的基本思想和实现过程，并⽐较它们的效率。
2. 了解程序设计技术和内存泄露的原因⼆、实验内容模拟实现请求页式存储管理的⼏种基本页⾯置换算法最佳淘汰算法（OPT）先进先出的算法（FIFO）最近最久未使⽤算法（LRU）三、实验原理1. 虚拟存储系统UNIX中，为了提⾼内存利⽤率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进⾏；⼀个进程只需将其⼀部分（段或页）调⼊内存便可运⾏；还⽀持请求调页的存储管理⽅式。
当进程在运⾏中需要访问某部分程序和数据时，发现其所在页⾯不在内存，就⽴即提出请求（向CPU发出缺中断），由系统将其所需页⾯调⼊内存。
这种页⾯调⼊⽅式叫请求调页。
为实现请求调页，核⼼配置了四种数据结构：页表、页框号、访问位、修改位、有效位、保护位等。
2. 页⾯置换算法当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转⼊缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调⼊内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出⼀页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调⼊，修改页表。
利⽤修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页⾯的调⼊过程对⽤户是透明的。
最佳淘汰算法（OPT）：选择永不使⽤或在未来最长时间内不再被访问的页⾯予以替换。
先进先出的算法（FIFO）：选择在内存中驻留时间最久的页⾯予以替换。
最近最久未使⽤算法（LRU）：选择过去最长时间未被访问的页⾯予以替换。
3. ⾸先⽤srand( )和rand( )函数定义和产⽣指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
（1）通过随机数产⽣⼀个指令序列，共320条指令。
【算法】页面置换算法FIFO、LRU和LFU的概述以及实现方式
【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式页⾯置换算法，我们最常⽤的页⾯置换算法包括FIFO先来先服务，LRU最近最久未被使⽤，LFU最近最少被使⽤以及我们的时钟置换算法。
⼀、FIFO算法——先来先服务1、简述FIFO算法FIFO算法是我们⽐较简单的置换算法，就是先来先服务或者说是先进先出。
也就是说在进⾏页⾯置换的时候，最先来的那个会被最先置换出去。
先进⼊的指令先完成并引退，跟着才执⾏第⼆条指令。
2、FIFO算法的简单实现FIFO算法的简单实现：可以通过维护⼀个链表结构去存储当前调⼊的页⾯；将最先进⼊的页⾯维护在链表的最前，最后进⼊的页⾯维护在链表的最后；这样，当发⽣缺页中断时，需要进⾏置换的时候，淘汰表头的页⾯并将新调⼊的页⾯加到链表的尾部；当然除了链表以外我们还可以采⽤数组或者队列等来进⾏实现。
3、FIFO算法的特点（1）FIFO算法实现简单，易于理解易于编程。
FIFO算法实现简单，⽆须硬件⽀持，只需要⽤循环数组管理物理块即可。
（2）FIFO算法可能会出现Belady现象。
也就是在FIFO算法中，如果未分配够⼀个进程所要求的页⾯，有时就会出现分配的页⾯数增多，却也率反⽽增加Belady现象。
（3）FIFO算法可能会置换调重要的页⾯，其效率不⾼。
（4）在FIFO算法可能中会导致多次的页⾯置换。
当页⾯置换的时间⼤于所要操作的时间的时候，这时候其效率就会很低。
当其不停的进⾏页⾯置换的时候会出现⼤量的系统抖动现象。
⼆、LRU算法——最近最久未被使⽤1、简述LRU算法LRU算法是最近最久未被使⽤的⼀种置换算法。
也就是说LRU是向前查看。
在进⾏页⾯置换的时候，查找到当前最近最久未被使⽤的那个页⾯，将其剔除在内存中，并将新来的页⾯加载进来。
2、LRU算法的实现LRU的实现就相对于FIFO的实现复杂⼀点。
我们可以采⽤哈希映射和链表相结合。
操作系统页面置换算法（opt,lru,fifo,clock）实现
操作系统页⾯置换算法（opt,lru,fifo,clock ）实现选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种（以下来⾃操作系统课本）。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的，因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串： 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时，先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时，产⽣缺页中断，根据最佳置换算法，选择第18次访问才需调⼊的页⾯7予以淘汰。
然后，访问页⾯0时，因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推，如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到，发⽣缺页中断的次数为9，页⾯置换的次数为6。
图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。
该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。
图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例，⾤⽤FIFO 算法进⾏页⾯置换。
进程访问页⾯2时，把最早进⼊内存的页⾯7换出。
然后访问页⾯3时，再把2, 0, 1中最先进⼊内存的页换出。
三种页面置换算法-(FIFO-LRU-OPT)
p[j].blocknum=b[i].num;
p[j].state=1;
b[i].pagenum=p[j].num;
b[i].state=1;
b[i].age=p[j].age;
break;
}
{
if (p[mm].num==b[mn].pagenum)
{
k=mn;
break;
}
}
b[mn].pagenum=p[j].num;
b[mn].age=0;
p[j].blocknum=b[mn].num;
for (j1=mn+1;j1<=j-1;j1++)
{
if(p[mn].num==p[j1].num)
{
num--;
}
}
}
if (num==n)
{
b[i].state=1;
break;
}
}
if(i>=n)
{
for (mn=j-1;mn>=0;mn--)
{
if(num<n)
{
num++;
#include<iostream>
#include<malloc.h>
using namespace std;
#define M 9
#define N 20
typedef struct node1/*页面的数据结构*/
{
int num;
int age;
int state;
if(chose==1)
常见的页面置换 电梯算法
常见的页面置换电梯算法
电梯算法是一种常用于操作系统中的页面置换算法，它可以有效地管理计算机内存，保证系统的稳定性和高效性。
在电梯算法中，页面在内存中的位置类似于电梯中的乘客在不同楼层中的位置，根据页面使用的频率和优先级，系统可以将页面从内存中置换出来，从而为新的页面腾出空间。
常见的页面置换策略包括FIFO（先进先出）、LRU（最近最少使用）、LFU（最不经常使用）、Clock（时钟置换）、OPT（最优置换）等。
其中，FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序将最先进入内存的页面置换出去；LRU算法则是根据页面最近的访问时间来判断哪些页面最有可能被再次使用，将最近最少使用的页面置换出去。
LFU算法则是根据页面使用的频率来进行置换，频率最低的页面被置换出去；Clock算法则是将内存中的页面放置在一个环中，每个页面有一个使用位，如果页面被访问，则把使用位设置为1，如果页面没有被访问，则使用位为0。
每次置换页面时，找到第一个使用位为0的页面进行置换。
最优置换算法则是根据未来的访问情况来预测哪些页面可能会被再次访问，将最长时间内不会被访问的页面置换出去。
虽然最优置换算法可以保证系统的最佳性能，但是它需要对未来的访问情况进行预测，因此在实际应用中难以实现。
总之，不同的页面置换算法都有其优缺点，需要根据具体应用场
景进行选择。
在操作系统中，通常会采用多种页面置换策略相结合的方式来管理内存，以达到最优的系统性能和稳定性。
概述fifo,opt,lru算法
概述fifo,opt,lru算法一、算法简介FIFO（FirstInFirstOut，先进先出）、OPT（OptimalPageReplacement）和LRU（LeastRecentlyUsed）算法是三种常见的页面替换算法，用于计算机中的虚拟内存管理。
这些算法在处理内存中数据块的替换时，需要考虑内存的容量、程序的需求以及数据的历史访问情况等因素。
二、算法原理1.FIFO算法：此算法将页面按照进入的顺序依次存放在内存中。
当有新的页面需要被加载时，如果内存中没有该页面，就需要从磁盘上加载。
当所有的页面都按照进入的顺序被加载完毕后，再按照同样的顺序将页面从内存中逐出，以腾出空间存放新的页面。
这种算法简单易行，但过于依赖页面的进入顺序，如果页面进入的顺序不合理，可能会导致频繁的页面替换。
2.OPT算法：此算法在每次需要加载新页面时，会根据一些准则（如最大错误率、最小错误率、最坏情况等）选择一个最优的页面进行替换。
相比于FIFO算法，OPT算法能更好地适应不同的页面访问情况，从而减少页面的替换频率。
然而，由于需要考虑到各种复杂的因素，OPT算法的实现难度相对较高。
3.LRU算法：此算法将最近最少使用的页面替换出内存，以腾出空间存放新的页面。
当有新的页面需要被加载时，如果内存中没有该页面，就需要从磁盘上加载。
而在加载完成后，会将该页面标记为最近最少使用的状态。
这种算法能够有效地提高内存的使用效率，减少页面的替换次数。
三、应用场景这三种算法在许多实际应用场景中都有应用，如操作系统中的虚拟内存管理、缓存系统等。
不同的应用场景可能需要不同的算法来满足特定的需求，如对于需要频繁访问的页面，可能更适合使用LRU算法；而对于访问模式较为固定的场景，可能更适合使用OPT算法。
四、总结FIFO、OPT和LRU算法是虚拟内存管理中常用的页面替换算法，它们各自具有不同的原理和应用场景。
在实际应用中，需要根据具体的需求和场景选择合适的算法，以实现最优的内存管理效果。
操作系统课设报告页面置换算法
武汉轻工大学数学与计算机学院《操作系统》课程设计说明书题目：页式虚拟存储管理页面置换算法专业：班级：学号：姓名：指导老师：2015年5月26日目录一、设计目的二、设计内容三、基本原理和解决方案四、实验内容五、流程图六、源代码七、运行结果八、实验总结（心得体会）一、设计目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二、设计内容阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。
模拟实现页式虚拟存储管理的三种页面置换算法（OPT、FIFO和LRU），并通过比较性能得出结论。
前提：（1）页面分配采用固定分配局部置换。
（2）作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。
三、基本原理和解决方案存储管理是操作系统进行资源管理的一个重要功能。
现代操作系统广泛采用虚拟存储的技术对内存进行扩充。
实现虚拟存储的一个主要技术手段就是将辅存和主存统一管理，在二者之间进行对换，从而形成物理上两级而逻辑上一级的存储管理系统。
一个置换算法的好坏对这个逻辑上的单级虚存的性能起着极其重要的作用，而且会影响处理机的调度性能。
对于本任务规定的前提：页面分配采用固定分配局部置换，则置换发生的时机是作业已经将操作系统分配的固定数目的物理块全部用完且发生缺页的时候。
此时必须要将已经装入内存的部分逻辑页面换出以便将所缺的页面调入内存。
置换算法就是一个决定将内存中“哪一个”页面换出的算法。
四、实验内容1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1 需求分析 (2)1.1 目的和要求 (2)1.2 研究内容 (2)2 概要设计 (2)2．1 FIFO算法 (3)2．2 LRU算法 (3)2．3 OPT算法 (3)2．4 输入新的页面引用串 (3)3 详细设计 (4)3．1 FIFO（先进先出）页面置换算法： (4)3．2 LRU（最近最久未使用）置换算法： (4)3．3 OPT（最优页）置换算法 (4)4 测试 (5)5 运行结果 (5)6 课程设计总结 (10)7 参考文献 (10)8 附录：源程序清单 (11)1 需求分析1.1 目的和要求在熟练掌握计算机虚拟存储技术的原理的基础上，利用一种程序设计语言模拟实现几种置换算法，一方面加深对原理的理解，另一方面提高学生通过编程根据已有原理解决实际问题的能力，为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。
1.2 研究内容模拟实现页式虚拟存储管理的三种页面置换算法（FIFO(先进先出)、LRU（最近最久未使用）和OPT（最长时间不使用）），并通过比较性能得出结论。
前提：（1）页面分配采用固定分配局部置换。
（2）作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。
2 概要设计本程序主要划分为4个功能模块，分别是应用FIFO算法、应用LRU算法、应用OPT算法和页面引用串的插入。
1.1各模块之间的结构图2．1 FIFO 算法该模块的主要功能是对相应页面引用串进行处理，输出经过FIFO 算法处理之后的结果。
2．2 LRU 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过LRU 算法处理之后的结果。
2．3 OPT 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过OPT 算法处理之后的结果。
2．4 输入新的页面引用串该模块的主要功能是用户自己输入新的页面引用串，系统默认的字符串是0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0，用户可以自定义全新的20个数字页面引用串。
主界面FIFO 算法LRU 算法 OPT 算法 新的页面引用串3 详细设计在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。
但应将哪个页面调出，须根据一定的算法来确定。
一个好的页面置换算法，应具有较低的页面更换频率。
从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。
3．1 FIFO（先进先出）页面置换算法：这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO 算法并不能保证这些页面不被淘汰。
3．2 LRU（最近最久未使用）置换算法：FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。
最近最久未使用（LRU）置换算法，是根据页面调入内存后的使用情况进行决策的。
由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t,，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。
3．3OPT（最优页）置换算法最优页置换算法是所有算法中产生页错误率最低的，而且绝对没有Belady 异常的问题。
它会置换最长时间不会使用的页。
最优页（OPT）置换算法，是根据最长时间不会使用的页来决策的。
这就意味着，需要注意内存中的页面和页面的距离了。
因此OPT算法是选择最久未使用的页面进行淘汰的。
该算法赋予内存中每个页面一个访问字段，用来记录距离此处的最近页面的距离，这样通过比较，就能把最久未使用的页面淘汰掉。
4测试程序在设计过程中，曾经出过这样或者那样的问题，最让我纠结的问题是在设计OPT算法时出现的，当我认为没有问题的时候程序一运行就没有想要的结果，很明显不是语法上的错误，由于在程序编写过程中没有截图，此处没有图片说明了。
都是逻辑上的错误，最让人难以接受的是，不是程序的逻辑，还是思维的逻辑，也就是从一开始编写程序时，自己的想法的错误了，我说怎么老是显示不出正确的结果，后来改正后结果就显示正常了。
5运行结果5.1 主界面5.2 输入错误的选择5.3 选择4的时候自己输入新的页面号引用串，此处输入书上的例子5.4 确认后首部分的页面号引用串改变5.5 选择FIFO算法，相关设置之后5.6 选择LRU算法之后5.7 选择OPT算法之后5.8 如果你选择的物理模块是其他的数量，此处用4个模块，OPT算法为例6 课程设计总结1、通过完成该课程设计，使我了解了什么是缺页中断，以及处理缺页中断的调度算法。
通过自己编程，加深了对理论学习的理解。
自己动手的编写对缺页终端的调度算法了解加深了不少了解，使我也明白了，真理是在实践中证明的。
程序中也出现过这样或者那样的问题，我也曾经颓废过，为了一个简单的逻辑问题纠结了好久，真正弄明白之后才发现自己是那么的蠢，一种豁然开朗的感觉涌上心头。
2、程序执行是稳定的，高效的。
在LRU算法中，要找出最近最久未使用的页面的话，就必须设置有关的访问记录项，且每一次访问这些记录项，页面都必须更新这些记录项。
这个记录项在此程序中为typedef struct page{int yemian;//页面号int biaoji;//被访问标记}page; /* 页面逻辑结构，结构为方便算法实现设计*/如此显然要花费较大的系统开销(包括时间和空间上的)，这也是实际系统中不直接采用LRU算法作为页面置换算法的直接原因，但由于其在页面置换的优越性，实际系统常使用LRU的近似算法。
7 参考文献《操作系统概念》第七版8 附录：源程序清单#include<iostream.h>#include<stdlib.h>//7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1书上的例子const int Nsize=10;const int Psize=20;typedef struct page{int yemian;//页面号int biaoji;//被访问标记}page; /* 页面逻辑结构，结构为方便算法实现设计*/page block[Nsize];//物理块page page[Psize];//页面号串void Init(int QString[],int Nsize){//初始化内存单元、缓冲区for(int i=0; i<Nsize; i++){block[i].yemian = -1;//找到空闲内存block[i].biaoji = 0;}for(i=0; i<Psize; i++){page[i].yemian = QString[i];page[i].biaoji = 0;}}int findSpace(int Nsize){//查找是否有空闲内存for(int i=0; i<Nsize; i++){if(block[i].yemian == -1){return i;//找到空闲内存，返回BLOCK中位置}}return -1;}int findExist(int curpage, int Nsize){//查找内存中是否有该页面for(int i=0; i<Nsize; i++){if(block[i].yemian == page[curpage].yemian){return i;//找到内存中有该页面，返回BLOCK中位置}}return -1;}int findReplace(int Nsize){//查找应予置换的页面int a = 0;for(int i=0; i<Nsize; i++){if(block[i].biaoji >= block[a].biaoji){a = i;//找到应予置换页面，返回BLOCK中位置}}return a;}void display(int Nsize){//显示for(int i=0; i<Nsize; i++){if(block[i].yemian != -1)//非空闲内存{cout<<block[i].yemian<<" ";}}cout<<endl;}/*FIFO核心部分*/void FIFO(int Nsize){//先进先出页面置换算法int exist,space,aition ;float score=0;for(int i=0; i<Psize; i++){exist = findExist(i,Nsize);if(exist != -1)//内存中有该页面{cout<<"不缺页"<<endl;score+=1;//统计不缺页次数}else{space = findSpace(Nsize);if(space != -1)//找到空闲内存{block[space] = page[i];display(Nsize);}else{aition = findReplace(Nsize);//找到应予置换页面block[aition] = page[i];display(Nsize);}}for(int j=0; j<Nsize; j++){block[j].biaoji++;//BLOCK中所有页面biaoji++}}cout<<"缺页次数为："<<20-score<<endl;cout<<"缺页率为："<<(20-score)*100/20<<"%"<<endl;}/*LRU核心部分*/void LRU(int Nsize){//最近最久未使用置换算法int exist,space,aition ;float score=0;for(int i=0; i<Psize; i++){exist = findExist(i,Nsize);if(exist != -1){block[exist].biaoji=0;cout<<"不缺页"<<endl;score+=1;}else{space = findSpace(Nsize);if(space != -1){block[space] = page[i];display(Nsize);}else{aition = findReplace(Nsize);block[aition] = page[i];display(Nsize);}}for(int j=0; j<Nsize; j++){block[j].biaoji++;//BLOCK中所有页面biaoji++}}cout<<"缺页次数为："<<20-score<<endl;cout<<"缺页率为："<<(20-score)*100/20<<"%"<<endl; }/*OPT算法核心部分*/void OPT(int Nsize){//最优页置换算法int exist,space,aition;float score=0;for(int i=0; i<Psize; i++){exist = findExist(i,Nsize);if(exist != -1)//内存中有该页面{cout<<"不缺页"<<endl;score+=1;//统计不缺页次数}else{space = findSpace(Nsize);if(space != -1)//找到空闲内存{block[space] = page[i];display(Nsize);}else{for(int j=0; j<Nsize; j++){for(int l =i;l<Psize;l++){if(block[j].yemian==page[l].yemian)//计算谁是最长时间没使用的{block[j].biaoji=l-i;break;}else{block[j].biaoji=Psize-i;}}}aition = findReplace(Nsize);//找到应予置换页面block[aition] = page[i];display(Nsize);}}}cout<<"缺页次数为："<<20-score<<endl;cout<<"缺页率为："<<(20-score)*100/20<<"%"<<endl;}void BlockClear(int Nsize){//块清除for(int i=0; i<Nsize; i++){block[i].yemian = -1;block[i].biaoji = 0;}}/*主程序*/void main(void){int i,select,Nsize,QString[Psize]={0};while(select){cout<<"页面号引用串: ";for(i=0;i<20;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"+******************************+"<<endl; cout<<"+------------欢迎--------------+"<<endl;cout<<"+--------页面置换算法----------+"<<endl;cout<<"+-----选择<1>应用FIFO算法------+"<<endl; cout<<"+-----选择<2>应用LRU算法-------+"<<endl; cout<<"+-----选择<3>应用OPT算法-------+"<<endl; cout<<"+---选择<4>插入新的页面号引用串+"<<endl; cout<<"+-------选择<0>退出------------+"<<endl;cout<<"+******************************+"<<endl; cout<<"请选择：";cin>>select;switch(select){case 0:break;case 1:cout<<"请输入分配的物理块数的大小: ";cin>>Nsize;while(1){if(Nsize>0&&Nsize<=10){Init(QString,Nsize);cout<<"页面号引用串: ";for(i=0;i<Psize;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"FIFO算法结果如下:"<<endl;FIFO(Nsize);BlockClear(Nsize);cout<<"----------------------"<<endl;system("pause");system("cls");break;}else{cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:";cin>>Nsize;}}break;case 2:cout<<"请输入分配的物理块数的大小: ";cin>>Nsize;while(1){if(Nsize>0&&Nsize<=10){Init(QString,Nsize);cout<<"页面号引用串: ";for(i=0;i<Psize;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"LRU算法结果如下:"<<endl;LRU(Nsize);BlockClear(Nsize);cout<<"----------------------"<<endl;system("pause");system("cls");break;}else{cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:";cin>>Nsize;}}break;case 3:cout<<"请输入分配的物理块数的大小: ";cin>>Nsize;while(1){if(Nsize>0&&Nsize<=10){Init(QString,Nsize);cout<<"页面号引用串: ";for(i=0;i<Psize;i++){cout<<QString[i]<<" ";}cout<<endl;cout<<"OPT算法结果如下:"<<endl;OPT(Nsize);BlockClear(Nsize);cout<<"----------------------"<<endl;system("pause");system("cls");break;}else{cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:";cin>>Nsize;}}break;case 4:cout<<"请输入20个数：\n";for(i=0;i<20;i++){cin>>QString[i];}system ("cls");break;default:cout<<"提示:功能号错误!"<<endl;cout<<"----------------------"<<endl;system("pause");system("cls");break;}}}21。