三种页面置换算法-(FIFO-LRU-OPT)
页面置换算法实验报告实验心得
页面置换算法实验报告实验心得
页面置换算法是操作系统中用来管理内存的一种重要算法。
在本次实验中，我们通过模拟内存的分配和释放过程，探索了三种典型的页面置换算法：FIFO（先进先出）、LRU（最近最少使用）和OPT（最优置换）。
在实验过程中，我发现FIFO算法虽然简单易懂，但容易产生“抖动”现象，即容易出现频繁的页面置换，导致系统效率低下。
LRU算法则能够有效避免抖动现象，但需要记录每个页面最近一次的使用时间，算法实现较为复杂。
OPT算法是一种理论上的最优算法，但由于需要预测未来的页面使用情况，实际中难以实现。
通过对三种算法的实验数据分析，我发现在不同的内存使用情况下，不同的页面置换算法表现也不同。
例如在内存使用较少的情况下，FIFO算法的效率可能会更高，但在内存使用较多的情况下，LRU算法则能够更好地发挥作用。
因此，在实际应用中，需要根据实际情况选择合适的页面置换算法。
总之，本次页面置换算法的实验让我更加深入地了解了操作系统中内存管理的相关知识，也加深了我对算法选择的理解和实际应用的思考。
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条指令。
操作系统页面置换算法（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中最先进⼊内存的页换出。
常见的页面置换算法
常见的页面置换算法1.概述页面置换算法是操作系统中用于管理内存的一种算法，其目的是确保可用内存的最大化并实现对内存的高效使用。
在操作系统中，当进程所需的内存空间超出了可用的物理内存空间时，操作系统就需要从主存中选择一些页面腾出空间来装载进程所需的页面。
这就需要使用页面置换算法。
2.常见的页面置换算法2.1最优页面置换算法(OPT)最优页面置换算法是一种理论上的置换算法。
它的核心思想是通过计算进程未来访问各个页面的时间和距离，来推断出离当前时间最久的页面。
这种算法的优点是能够保证页面置换的最优性，但是它需要预先知道进程未来所有的页面调度情况，这在实际应用中是不可行的。
2.2先进先出(FIFO)置换算法先进先出置换算法是一种很简单的置换算法，它选取主存中驻留时间最长的页面作为替换目标。
优点是实现简单，但是缺点是可能会引发置换震荡问题。
2.3最近最久未使用算法(LRU)最近最久未使用算法是一种比较常用的页面置换算法，其核心思想是将驻留时间久且最近一次使用时间早的页面视为需要置换的页面。
相对于FIFO算法，LRU算法能够保证更高的页面命中率和更小的置换次数。
2.4时钟置换算法(Clock)时钟置换算法是一种改进型的FIFO算法。
该算法使用一个环形队列来存储主存中的页面位置信息。
当需要置换页面时，指针先指向队列首位置，遍历队列并且在第一遍扫描时，将页框的访问位ACC设置为0。
第一遍扫描结束后，如果有页面的ACC位为0，就将其替换出去。
如果找不到未访问页面，指针再回到队列首位置，以此类推，直到找到为止。
3.总结以上所述的几种页面置换算法是操作系统中常见的算法。
它们各有优点和缺点，在实际应用中，需要根据实际情况进行选择。
在选择算法后，还需要对其进行适当的调整，以满足实际需求。
概述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算法是虚拟内存管理中常用的页面替换算法，它们各自具有不同的原理和应用场景。
在实际应用中，需要根据具体的需求和场景选择合适的算法，以实现最优的内存管理效果。
页面置换算法实验报告
页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程，了解不同算法的优缺点，掌握算法的实现方法，以及对算法的性能进行评估。
二、实验原理页面置换算法是操作系统中的一个重要概念，它是为了解决内存不足的问题而产生的。
当系统中的进程需要使用内存时，如果内存已经被占满，就需要将一些页面从内存中置换出去，以便为新的页面腾出空间。
页面置换算法就是用来决定哪些页面应该被置换出去的算法。
常见的页面置换算法有以下几种：1. 最佳置换算法（OPT）最佳置换算法是一种理论上的最优算法，它总是选择最长时间内不会被访问的页面进行置换。
但是，由于无法预测未来的页面访问情况，因此最佳置换算法无法在实际中使用。
2. 先进先出置换算法（FIFO）先进先出置换算法是一种简单的置换算法，它总是选择最先进入内存的页面进行置换。
但是，这种算法容易出现“抖动”现象，即频繁地将页面置换出去，然后再将其置换回来。
3. 最近最久未使用置换算法（LRU）最近最久未使用置换算法是一种比较常用的置换算法，它总是选择最长时间未被访问的页面进行置换。
这种算法可以避免“抖动”现象，但是实现起来比较复杂。
4. 时钟置换算法（Clock）时钟置换算法是一种改进的FIFO算法，它通过维护一个环形链表来实现页面置换。
当需要置换页面时，算法会从当前位置开始扫描链表，如果找到一个未被访问的页面，则将其置换出去。
如果扫描一圈后都没有找到未被访问的页面，则将当前位置的页面置换出去。
三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序，可以模拟上述四种算法的过程，并输出算法的性能指标。
程序的主要流程如下：1. 读取输入文件，获取页面访问序列和内存大小等参数。
2. 根据选择的算法，初始化相应的数据结构。
3. 遍历页面访问序列，模拟页面置换的过程。
4. 输出算法的性能指标，包括缺页率、页面置换次数等。
下面分别介绍四种算法的实现方法。
1. 最佳置换算法（OPT）最佳置换算法需要预测未来的页面访问情况，因此需要遍历整个页面访问序列，找到最长时间内不会被访问的页面。
操作系统——模拟页面置换算法（FIFO——先入先出、LRU——最近最少使用、LFU——最近。。。
操作系统——模拟页⾯置换算法（FIFO——先⼊先出、LRU——最近最少使⽤、LFU——最近。
操作系统——模拟页⾯置换算法（FIFO——先⼊先出、LRU——最近最少使⽤、LFU——最近最不常使⽤），计算置换率（包含程序框图）导语：1. FIFO页⾯置换算法：最简单的页⾯置换算法。
这种算法的基本思想是：当需要淘汰⼀个页⾯时，总是选择驻留主存时间最长的页⾯进⾏淘汰，即先进⼊主存的页⾯先淘汰。
(看时间)2. LRU页⾯置换算法：最近最少使⽤，简单来说就是将数据块中，每次使⽤过的数据放在数据块的最前端，然后将存在的时间最长的，也就是数据块的末端的数据置换掉。
(看时间)3. LFU页⾯置换算法：近期最少使⽤算法，选择近期最少访问的页⾯作为被替换的页⾯，如果⼀个数据在最近⼀段时间内使⽤次数很少，那么在将来⼀段时间内被使⽤的可能性也很⼩。
(看次数)4. 置换率与与缺页率不同。
置换率⽤置换次数算，缺页率⽤缺页中断次数算。
FIFO页⾯置换算法：Linux效果图（采⽤UOS + VScode + g++）程序框图C++代码(FIFO)：#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int *analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int a[],int n,int x) //判断数组中是否已有x，若有返回其下标值，没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换，y是⽤来置换的页⾯，x是被置换的页⾯ {int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}int main() {int i;int maxanalogblock=-1;//模仿队列的定义int x;cout<<"请输⼊页框⼤⼩物理块数：\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数：\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}analogblock=new int[mnum];block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=-1;for (i=0;i<mnum;i++) block[i]=-1;///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下：\n";srand( (unsigned)time( NULL ) );//以time函数值（即当前时间）作为种⼦数，保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"先进先出(FIFO)页⾯置换算法，结果： \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[maxanalogblock]=process[x];//新元素从尾部插⼊block[maxanalogblock]=process[x];//新元素从尾部插⼊cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//队列法插⼊(尾部元素出，新元素从头部⼊)cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0]<<endl; replace(process[x],mnum,analogblock[0]);//置换物理块中页⾯for (i=0;i<mnum-1;i++)LRU 页⾯置换算法：Linux 效果图（采⽤UOS + VScode + g++）程序框图C++代码(LRU)： analogblock[i]=analogblock[i+1];analogblock[mnum-1]=process[x];//////////////////maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值count++;} else //若数组中存在待插⼊元素 {maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}}}//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1) cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}cout<<endl<<"页⾯换算次数为："<<count<<endl;cout<<"置换率为："<<(float)count/pnum<<endl;return 0;}//g++ test71.cpp -o test71 -lpthread&&./test71#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int *analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int a[],int n,int x) //判断数组中是否已有x ，若有返回其下标值，没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换，y是⽤来置换的页⾯，x是被置换的页⾯ { int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}void move(int a[],int n,int i) //移动下标为i的元素到尾部 {int j;int m=a[i];for (j=i;j<n-1;j++)a[j]=a[j+1];a[n-1]=m;}int main() {int i;int maxanalogblock=-1;//模仿栈的定义int x;cout<<"请输⼊页框⼤⼩物理块数：\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数：\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}analogblock=new int[mnum];block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=-1;///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下：\n";srand( (unsigned)time( NULL ) );//以time函数值（即当前时间）作为种⼦数，保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"最近最少使⽤(LRU)页⾯置换算法，结果： \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1LFU 页⾯置换算法：Linux 效果图（采⽤UOS + VScode + g++）程序框图 if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[maxanalogblock]=process[x];//新元素从尾部插⼊block[maxanalogblock]=process[x];//新元素从尾部插⼊cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断 调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {move(analogblock,maxanalogblock,judge(analogblock,mnum,process[x]));//移动下标为i 的元素到尾部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//栈法插⼊(第⼀个元素出，后⾯元素前移，新元素从尾部⼊)cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断 页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0]<<endl; replace(process[x],mnum,analogblock[0]);//物理块中页⾯置换for (i=0;i<mnum-1;i++)analogblock[i]=analogblock[i+1];analogblock[mnum-1]=process[x];//////////////////maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值count++;} else //若数组中存在待插⼊元素 {move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i 的元素到尾部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock 值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在 直接访问"<<endl;}}}//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i]!=-1)cout<<analogblock[i]<<" ";}cout<<endl<<"页⾯换算次数为："<<count<<endl;cout<<"置换率为："<<(float)count/pnum<<endl;return 0;}//g++ test72.cpp -o test72 -lpthread&&./test72C++代码(LFU)：#include<iostream>using namespace std;static int mnum;//物理块数static int pnum;//页⾯⾛向static int count=0;//页⾯置换次数static int **analogblock;//模拟物理块static int *block;//物理块static int *process;//随机页⾯访问序列int judge(int *a[],int n,int x) //判断数组中是否已有x，若有返回其下标值，没有则返回-1 {int i;for (i=0;i<n;i++)if(x==a[i][0])return i;return -1;}void replace(int y,int mnum,int x)//⽤于物理块页⾯置换，y是⽤来置换的页⾯，x是被置换的页⾯ { int i;for (i=0;i<mnum;i++)if(x==block[i])block[i]=y;}void move(int *a[],int n,int i) //移动下标为i的元素，⽐较访问次数次多少进⾏前进 {int j;int m=a[i][0];int m2=a[i][1];for (j=i;j<n-1;j++) {if(m2>=a[j+1][1]) {a[j][0]=a[j+1][0];a[j][1]=a[j+1][1];a[j+1][0]=m;a[j+1][1]=m2;}}}int main() {int i;int maxanalogblock=-1;//模仿栈的定义int x;//动态数组初始化cout<<"请输⼊页框⼤⼩物理块数：\n";cin>>mnum;if(mnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}cout<<"⾃动⽣成的内存块需求序列个数：\n";cin>>pnum;if(pnum>999999) {cout<<"输⼊超出控制⼤⼩！"<<endl;return 0;}analogblock=(int**) (new int[mnum]);block=new int[mnum];process=new int[pnum];for (i=0;i<mnum;i++) analogblock[i]=(int*) new int[2];//⽤于保存页⾯号和访问次数for (i = 0; i < mnum; i++) {analogblock[i][0]=-1;analogblock[i][1]=0;}///////////////////////随机产⽣页⾯⾛向序列cout<<"产⽣随机序列如下：\n";srand( (unsigned)time( NULL ) );//以time函数值（即当前时间）作为种⼦数，保证两次产⽣序列的随机性for (i=0; i<pnum; i++) {process[i] = rand()%10;cout<<process[i]<<" ";}cout<<endl;//////////////////////cout<<"最近最不常使⽤(LFU)页⾯置换算法，结果： \n\n";//////////////////////for (x=0;x<pnum;x++) //⾃动读数 {//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i][0]!=-1)cout<<analogblock[i][0]<<" ";//<<"访问次数"<<analogblock[i][1]<<" "}//////////////////////////maxanalogblock++;//读数后maxanalogblock⾃动+1if(maxanalogblock<mnum) //若在物理块范围内 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {analogblock[0][0]=process[x];//新元素从头部插⼊analogblock[0][1]=1;block[maxanalogblock]=process[x];//新元素从尾部插⼊move(analogblock,mnum,0);//移动下标为i的元素到相同访问次数页⾯的顶部cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断调⼊页⾯"<<process[x]<<endl;} else //若数组中存在待插⼊元素 {// move(analogblock,maxanalogblock,judge(analogblock,mnum,process[x]));//移动下标为i的元素到尾部analogblock[judge(analogblock,mnum,process[x])][1]++;move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i的元素到相同访问次数页⾯的顶部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在直接访问"<<endl;}} else //超过物理块数的元素 {if(judge(analogblock,mnum,process[x])==-1)//若数组中不存在待插⼊元素 {//栈法插⼊(新元素从头部⼊，替换掉头部)cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 缺页中断页⾯"<<process[x]<<"置换出页⾯"<<analogblock[0][0]<<endl; replace(process[x],mnum,analogblock[0][0]);//物理块中页⾯置换analogblock[0][0]=process[x];analogblock[0][1]=1;move(analogblock,mnum,0);//移动下标为i的元素相同访问次数页⾯的顶部//////////////////maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值count++;} else //若数组中存在待插⼊元素 {analogblock[judge(analogblock,mnum,process[x])][1]++;move(analogblock,mnum,judge(analogblock,mnum,process[x]));//移动下标为i的元素到相同访问次数页⾯的顶部maxanalogblock--;//因为没有插⼊新元素，回滚maxanalogblock值cout<<" 第"<<x+1<<"次访问，页⾯"<<process[x]<<" 已存在直接访问"<<endl; }}}//读⼀个序列号，输出当前数组元素cout<<"真实物理块情况：";for (i=0;i<mnum;i++) {if(block[i]!=-1)cout<<block[i]<<" ";}cout<<"模拟物理块情况：";for (i=0;i<mnum;i++) {if(analogblock[i][0]!=-1)cout<<analogblock[i][0]<<" ";}cout<<endl<<"页⾯换算次数为："<<count<<endl;cout<<"置换率为："<<(float)count/pnum<<endl;return 0;}//g++ test73.cpp -o test73 -lpthread&&./test73。
页面置换算法实验报告
页面置换算法实验报告背景页面置换算法是计算机操作系统中的一个重要概念，它用于解决操作系统需要共享有限的物理内存资源给多个进程使用的问题。
在操作系统中，每个进程都有自己的虚拟地址空间，但实际的物理内存资源是有限的。
当物理内存不足时，操作系统需要根据一定的策略将一部分进程暂时从内存中移出，以便为其他进程让出空间，而后再从外存中将其重新加载到内存中。
这个过程就是页面置换。
页面置换算法有很多种，比如最优页面置换算法（Optimal）、先进先出页面置换算法（FIFO）、最近最久未使用页面置换算法（LRU）等等。
不同的算法对于系统性能、响应时间等指标有着不同的影响，因此在实际应用中需要选择合适的算法来平衡各种需求。
本实验旨在通过模拟页面置换算法，并对不同算法进行性能分析，以便了解各种算法的优缺点，为实际系统的选择提供依据。
分析在实验中，我们选择了三种常用的页面置换算法，分别是FIFO、LRU和Optimal。
下面对这三种算法进行详细的分析和说明。
先进先出页面置换算法（FIFO）FIFO算法是最简单和最直观的页面置换算法。
它按照页面进入内存的顺序来选择被淘汰的页面。
当内存不足时，选择最早进入内存的页面进行置换，即将其从内存中移出。
FIFO算法不需要进行进一步的页面访问计算，只需要维护一个页面进入内存的队列即可，因此实现起来比较简单。
然而，由于FIFO算法没有考虑页面的访问频率和重要性，所以可能会导致被频繁访问的页面被淘汰出内存，从而影响系统的性能。
最近最久未使用页面置换算法（LRU）LRU算法是一种基于”最近使用原则”的页面置换算法。
它根据页面最近被访问的时间来选择被淘汰的页面。
当内存不足时，选择最长时间未被访问的页面进行置换，即将其从内存中移出。
LRU算法需要维护一个页面访问时间的记录，以便在需要置换时能够快速找到最近最久未使用的页面。
相比于FIFO算法，LRU算法更加合理地利用了页面的访问情况，但实现起来相对复杂一些。
操作系统：Java实现页面置换算法（OPT,FIFO,LRU）
操作系统：Java实现页⾯置换算法（OPT,FIFO,LRU）前⾔代码有很多冗余，因为是写作业时写的，不过代码简单易懂，看看就可以改了。
置换算法介绍页⾯置换算法（也称为页⾯淘汰算法）是⽤来选择换出页⾯的算法。
在请求页式存储管理⽅式中，由于⼀个进程运⾏的时候不是所有的页⾯都在内存中，所以会出现缺页中断。
当缺页的时候内存没有空闲的物理块时就需要换出内存中的⼀页，具体换出哪⼀页⾯是由页⾯置换算法决定的，页⾯置换算法的优劣直接影响到系统的效率要注意把页⾯置换和连续分配⽅式中的交换区别开来，页⾯置换的单位是页⾯⽽不是整个进程，交换的单位是整个进程当发⽣缺页中断后，系统不⼀定会执⾏页⾯置换算法。
因为发⽣缺页中断仅仅说明需要执⾏的页⾯没有在内存中，如果内存空间中还有空闲块的话，只需要⽤缺页中断处理程序把需要的页⾯从外存调⼊内存即可。
不需要页⾯置换算法：只有内存中没有空闲块的时候才需要页⾯置换算法。
所以，缺页中断不⼀定导致执⾏页⾯置换算法。
1. 最佳置换算法（OPT）在预知⼀个进程的页⾯号引⽤串的情况下，每次都淘汰以后不再使⽤的或以后最迟再被使⽤的页⾯，这种算法就是最佳置换算法显然，最佳置换算法是最优的，具有最低的缺页率。
但由于实际操作中往往⽆法事先知道以后会引⽤到所有页⾯的信息，所以最佳置换算法⽆法实现，只能作为⼀个标准来衡量其他置换算法的优劣2. 先进先出算法（FIFO）FIFO算法是最简单的页⾯置换算法，每次总是淘汰最先进⼊内存的页⾯，也就是将在内存存驻留时间最长的页⾯淘汰掉该算法实现简单，⽤⼀个队列的数据结构就可以实现，将页⾯按照次序排成⼀个队列，并设置指针指向最先进⼊的页⾯，每次需要淘汰页⾯时，将指针所指的页⾯淘汰即可，不过FIFO算法可能会产⽣Belady⼀场（缺页次数随着分配的物理块号的增加⽽增加），⽽且由于FIFO算法与进程实际运⾏规律不符，可能会选择淘汰程序经常使⽤的界⾯，实际效果不好3. 最近最少使⽤算法（LRU）选择最近最久没有被使⽤的页⾯予以淘汰，其思想是⽤以前的页⾯引⽤情况来预测将来会出现页⾯引⽤情况，也就是假设⼀个页⾯刚被访问，那么不久该页⾯还会被访问。
操作系统_页面置换算法FIFO,OPT,LRU实现
cout <<frame[k].num <<' ';
cout <<endl;
}
}
cout <<“LRU:”<<endl;
cout <<“Error次数:”<<error <<endl;
cout <<“Frame Error:”<<(error / 12.0)<<endl <<endl;
}
intmain()
{
FIFO();
OPT();
LRU();
}
（以上为实现页面置换算法FIFO,OPT,LRU的代码）
frame[0].num = input[i];
elseif(frame[1].mark>frame[0].mark&&frame[1].mark>frame[2].mark)
frame[1].num = input[i];
else
frame[2].num = input[i];
cout <<input[i] <<“ | “;
3.FIFO算法实现。
4.在OPT实现中,mark属性设置,以及向后遍历的参数设置。
代码如下:
#include
usingnamespacestd;
intinput[12] = { 2,3,2,1,5,2,4,5,3,2,3,1 };
classpage
{
public:
intnum;
intmark;
c++中用于页面置换的算法
c++中用于页面置换的算法
在C++ 中，常用的页面置换算法有以下几种：
1. 先进先出算法（FIFO）：该算法是最简单的页面置换算法，它总是选择最早进入内存的页面进行替换。
该算法的缺点是无法利用页面的访问模式，因此可能会出现“抖动”现象。
2. 最近最久未使用算法（LRU）：该算法根据页面最近被访问的时间来进行置换，即选择最近最久未使用的页面进行替换。
该算法需要记录每个页面最近的访问时间，因此需要额外的开销。
3. 时钟算法（Clock）：该算法是对FIFO 算法的改进，它使用一个指针指向内存中的页面，每次访问页面时，将该页面的访问位设置为1。
当需要进行页面置换时，从指针指向的页面开始扫描，如果该页面的访问位为0，则选择该页面进行替换；否则将该页面的访问位设置为0，并继续扫描。
该算法的优点是较好地利用了页面的访问模式，但需要额外的访问位开销。
4. 最不经常使用算法（LFU）：该算法根据页面被访问的频率来进行置换，即选择最不经常使用的页面进行替换。
该算法需要记录每个页面被访问的次数，因此需要额外的开销。
5. 最佳置换算法（OPT）：该算法是一种理论上的最优算法，它选择未来最长时间内不会被访问的页面进行替换。
由于需要预测未来的访问模式，因此该算法无法实现。
以上是常用的几种页面置换算法，每种算法都有其优缺点，需要根据具体情况进行选择。
存储管理的页面置换算法详解
存储管理的页面置换算法存储管理的页面置换算法在考试中常常会考到，操作系统教材中主要介绍了3种常用的页面置换算法，分别是：先进先出法（FIFO）、最佳置换法（OPT）和最近最少使用置换法（LRU）。
大家要理解3种置换算法的含义，然后能熟练地运用在具体的练习中就可以了。
1.为什么要进行页面置换在请求分页存储管理系统中，由于使用了虚拟存储管理技术，使得所有的进程页面不是一次性地全部调入内存，而是部分页面装入。
这就有可能出现下面的情况：要访问的页面不在内存，这时系统产生缺页中断。
操作系统在处理缺页中断时，要把所需页面从外存调入到内存中。
如果这时内存中有空闲块，就可以直接调入该页面；如果这时内存中没有空闲块，就必须先淘汰一个已经在内存中的页面，腾出空间，再把所需的页面装入，即进行页面置换。
有助于理解的关键词有：请求分页、虚拟存储、缺页中断、页面置换。
2.常用的页面置换算法教材中介绍的常用页面置换算法有：先进先出法（FIFO）、最佳置换法（OPT）和最近最少使用置换法（LRU）。
（1）先进先出法（FIFO）算法描述：由于认为最早调入内存的页不再被使用的可能性要大于刚调入内存的页，因此，先进先出法总是淘汰在内存中停留时间最长的一页，即先进入内存的页，先被换出。
先进先出法把一个进程所有在内存中的页按进入内存的次序排队，淘汰页面总是在队首进行。
如果一个页面刚被放入内存，就把它插在队尾。
【例1】教材第4章课后习题。
考虑下述页面走向：1，2，3，4，2，1，5，6，2，1，2，3，7，6，3，2，1，2，3，6。
当内存块数量分别为3，5时，试问先进先出置换算法（FIFO）的缺页次数是多少？（注意，所有内存块最初都是空的，凡第一次用到的页面都产生一次缺页。
）解打叉的表示发生了缺页，共缺页16次。
提示：当FIFO算法执行到蓝色的4号页面时，这时内存中有三个页面，分别是1，2，3。
按照FIFO算法，在内存中停留时间最长的页面被淘汰。
页面置换算法实验总结
页面置换算法实验总结
在操作系统中，页面置换算法是为了解决内存不足的问题，当内存中的页面不足时，需要选择一些页面进行置换，将其换出到磁盘上，从而为新的页面腾出空间。
在本次实验中，我实现了三种页面置换算法，分别是FIFO（先进先出）、LRU（最近最少使用）和OPT（最佳置换）。
下面是对这三种算法的总结：
1. FIFO算法：FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。
实验结果显示，FIFO算法在某些情况下可能会导致“抖动”现象，即不断发生页面置换，性能较差。
2. LRU算法：LRU算法是根据页面的使用历史进行置换，将最长时间没有被使用的页面置换出去。
实验结果显示，LRU算法相比于FIFO算法在减少页面抖动方面表现更好，但是实现起来较为复杂，需要维护一个访问历史记录的数据结构。
3. OPT算法：OPT算法是一种理想情况下的页面置换算法，它通过预测未来的页面访问情况来选择最佳的页面进行置换。
实验结果显示，OPT算法在减少页面抖动方面表现最好，但是实现起来较为困难，需要对未来的页面访问情况进行预测。
综上所述，不同的页面置换算法在不同的场景下有着不同的表现。
FIFO算法简单易实现，但性能较差；LRU算法在某些情况下能够较好地减少页面抖动；OPT算法在理论上是最佳的页面置换算法，但实现起来较为困难。
实际中的选择需要根据具体的应用场景
和系统需求来确定。
操作系统之页面置换算法（最佳置换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）是淘汰最先进⼊内存的页⾯，即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
常见的页面置换 电梯算法
常见的页面置换电梯算法
电梯算法是一种常用于操作系统中的页面置换算法，它可以有效地管理计算机内存，保证系统的稳定性和高效性。
在电梯算法中，页面在内存中的位置类似于电梯中的乘客在不同楼层中的位置，根据页面使用的频率和优先级，系统可以将页面从内存中置换出来，从而为新的页面腾出空间。
常见的页面置换策略包括FIFO（先进先出）、LRU（最近最少使用）、LFU（最不经常使用）、Clock（时钟置换）、OPT（最优置换）等。
其中，FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序将最先进入内存的页面置换出去；LRU算法则是根据页面最近的访问时间来判断哪些页面最有可能被再次使用，将最近最少使用的页面置换出去。
LFU算法则是根据页面使用的频率来进行置换，频率最低的页面被置换出去；Clock算法则是将内存中的页面放置在一个环中，每个页面有一个使用位，如果页面被访问，则把使用位设置为1，如果页面没有被访问，则使用位为0。
每次置换页面时，找到第一个使用位为0的页面进行置换。
最优置换算法则是根据未来的访问情况来预测哪些页面可能会被再次访问，将最长时间内不会被访问的页面置换出去。
虽然最优置换算法可以保证系统的最佳性能，但是它需要对未来的访问情况进行预测，因此在实际应用中难以实现。
总之，不同的页面置换算法都有其优缺点，需要根据具体应用场
景进行选择。
在操作系统中，通常会采用多种页面置换策略相结合的方式来管理内存，以达到最优的系统性能和稳定性。
时钟页面置换算法
时钟页⾯置换算法⼀、局部：时钟置换算法：1.最优置换算法：理论上的，预测最晚调⽤的页⾯。
2.LRU算法，置换掉最久未使⽤的。
⼀个链表。
⼀个页⾯被调⽤的话，会被从链表中（它原本的位置）移动到链表⾸，⽽每次缺页，则会将链表尾部元素置换。
3.FIFO算法，置换掉在内存中时间最长的。
（性能低 同是⼀个链表，每次缺页置换最早进⼊页⾯（时间排序）链⾸的。
新页⾯放在链表尾部。
4.clock 算法， 环形链表，不再排序⽽是使⽤2个标记，0和1， 第⼀个次加载页⾯的时候，页⾯标记被设置为0，调⽤内存中驻留的页⾯时，标记该页⾯为1， 出现缺页时，指针从当前位置循环查找环形链表，如果遇到标记为1的，标记为0，如果遇到标记为0的，置换它。
5.最不常⽤算法 标记不再是0和1，每次调⽤，标记值+1，缺页时，置换标记值最⼩的页⾯ 优化版本：定期减⼩数字clock 算法虽然不能像LRU（least recently used）算法⼀样精确的记录访问顺序，但是，开销较⼩。
改进版的clock 算法，只在访问同⼀个页⾯的时候，做写回操作，在缺页的时候，会跳过已经被改变的。
下⾯是⼀个⼩练习function clock(load){//假设同时可以加载的数⽬let workRow =3; //储存标记位let m = new Map(); //当前加载的let res=[]; //当前加载的index，workRow个let pointer = 0;//初始化for(var i=0;i<load.length;i++){if( res.length<workRow && !m.has(load[i]) ){//如果没满，初始化res.push(load[i])//设置为1m.set(load[i],0);//如果满了，⽽且需要加载的就在⾥⾯（重复）不⽤再加载}else if(m.has(load[i])){console.log('loaded what has been there',load[i]) m.set(load[i],1)}else{//缺页异常，需要置换loading(load[i],i)console.log(load[i] , res)}}function loading(task,idx){let wait = true;//检查当前指针，如果是1，标记为0，如果找到为0的，扔掉，其余移动向下，把要加载的，加载进来，设置为1，结束while(wait){pointer = idx%(workRow-1)if(m.get(res[pointer])==1){m.set(res[pointer],0)}else if(m.get(res[pointer])==0){m.delete(res[pointer])res[pointer]=taskm.set(task,1)wait = false; }pointer++;}} //内存中最后的内容return res;}clock(['a','b','b','d','b','e','c','d','e'])⼆、全局：置换算法1.尽量不更改常驻集⼤⼩的（假设⼯作集⼤⼩趋于稳定），⼯作集置换算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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(b,m,pag,n);
cout<<endl<<endl;
}
else if(chose==2)
{
LRU(b,m,pag,n);
cout<<endl<<endl;
}
else if(chose==3)
{
for (mm=0;mm<n;mm++)
{
for (mn=j+1;mn<m;mn++)
{
if (b[mm].pagenum==p[mn].num)
{
b[mm].age=mn;
break;
{
int i,j,k,mm,mn,flag=0;
int maxage=-1,c=0;
for (j=0;j<m;j++)
{
for (mm=0;mm<n;mm++)
{
if(b[mm].pagenum==p[j].num)
flag=1;
{
OPT(b,m,pag,n);
cout<<endl<<endl;
}
else if(chose==0)
{
exit(0);
}
}
}
break;
}
}
for (mm=0;mm<n;mm++)
{
if (p[mn].num==b[mm].pagenum)
{
k=mm;
break;
}
}
if(flag==1) cout<<endl<<"此次未出现缺页(NF)"<<endl;
else if (flag==0)
{ c++;
cout<<endl<<"出现缺页(F)\n";
for(i=0;i<n;i++)
{
if(b[i].state==0)
p[j].state=1;
}
}
}
cout<<"页面序列为:"<<endl;
for (mm=0;mm<n;mm++)
{
cout<<b[mm].pagenum<<" ";
}
cout<<endl<<endl;
{
maxage=b[k].age;
mm=k;
}
}
b[mm].pagenum=p[j].num;
b[mm].age=0;
p[j].blocknum=b[mm].num;
{
if(b[mm].pagenum==p[j].num)
flag=1;
}
if(flag==1) cout<<endl<<"此次未出现缺页(NF)"<<endl;
else if (flag==0)
{ c++;
cout<<endl<<"出现缺页(F)\n";
int blocknum;
}page ;
typedef struct node2/*内存块的数据结构 */
{
int num;
int state;
int pagenum;
int age;
}Block;
void FIFO(Block b[],int n,page p[],int m)/*先进先出页面置换算法*/
p[j].state=1;
p[k].state=0;
p[k].blocknum=-1;
}
}
for(mm=0;mm<n;mm++)
{
if(b[mm].pagenum!=-1)
b[mm].age++;
}
cout<<"页面调序列为:";
for (mm=0;mm<n;mm++)
{
cout<<b[mm].pagenum<<" ";
}
cout<<endl<<endl;
flag=0;
maxage=-1;
}
cout<<"缺页总次数:"<<c<<endl;
{
cout<<b[mm].pagenum<<" ";
}
cout<<endl<<endl;
flag=0;
num=0;
}
cout<<"缺页总次数:"<<c<<endl;
}
void OPT(Block b[],int n,page p[],int m)/*最优页面置换算法 */
pag[i].state=0;
pag[i].blocknum=-1;
}
for(i=0;i<m;i++)
{
b[i].num=i;
b[i].state=0;
b[i].pagenum=-1;
b[i].age=0;
}
cout<<"1. FIFO替换算法\n"<<"2. LRU替换算法\n"<<"3. OPT替换算法\n"<<"0. 退出"<<endl;
}
b[k].pagenum=p[j].num;
b[k].age=0;
p[j].blocknum=b[mm].num;
p[j].state=1;
}
}
}
cout<<"页面调序列为:";
for (mm=0;mm<n;mm++)
}
}
if(mn>=m)
{
b[mm].age=100;
}
}
for(k=0;k<n;k++)
{
if(maxage<b[k].age)
else if (flag==0)
{ c++;
cout<<endl<<"出现缺页(F)\n";
if (p[j].state==0)
{
for(i=0;i<n;i++)
{
if(b[i].state==0)
{
p[j].blocknum=b[i].num;
p[j].state=1;
b[i].pagenum=p[j].num;
b[i].state=1;
break;
}
}
if(i>=n)
{
int i,j,k,mm,mn,flag=0;
int maxage=-1,c=0;
for (j=0;j<m;j++)
{
for (mm=0;mm<n;mm++)
{
if(b[mm].pagenum==p[j].num)
flag=1;
}
if(flag==1) cout<<endl;