页面置换算法(FIFO算法 LRU算法)
页面置换算法(FIFO,LRU,最佳,Clock)
#include<iostream>using namespace std;void Print(int bc[],int blockCount){for(int i=0;i<blockCount;i++){cout<<bc[i]<<" ";}cout<<endl;}bool Travel(int bc[],int blockCount,int x){bool is_found=false;int i;for(i=0;i<blockCount;i++){if(bc[i]==x){is_found=true;break;}}return is_found;}void FIFO(int pc[],int bc[],int pageCount,int blockCount) {cout<<"0：FIFO置换算法"<<endl;int i;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int p=0;for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{if(p==blockCount){p=0;}bc[p]=pc[i];p++;}noPage++;cout<<"物理快情况：";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;}}int FoundMaxNum(int a[],int n){int k,j;k=a[0];j=0;for (int i=0;i<n;i++){if(a[i]>=k){k=a[i];j=i;}}return j;}void LRU(int pc[],int bc[],int pageCount,int blockCount){cout<<"1：LRU置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j,m;int *bc1=new int[blockCount];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];for(int p=0;p<=i;p++){bc1[p]++;}}else{for(j=0;j<blockCount;j++){bc1[j]++;}int k=FoundMaxNum(bc1,blockCount);bc[k]=pc[i];bc1[k]=1;}noPage++;cout<<"物理快情况：";Print(bc,blockCount);}else if(Travel(bc,blockCount,pc[i])){if(i<blockCount){for(j=0;j<=i;j++){bc1[j]++;}for(m=0;m<=i;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}else{for(j=0;j<blockCount;j++){bc1[j]++;}for(m=0;m<blockCount;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;delete bc1;}}void Optiomal(int pc[],int bc[],int pageCount,int blockCount){cout<<"2：最佳置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j,k;for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{int max=0;int blockIndex;;for(j=0;j<blockCount;j++){for(k=i;k<pageCount;k++){if(bc[j]==pc[k]){break;}}if(k>=max){max=k;blockIndex=j;}}bc[blockIndex]=pc[i];}noPage++;cout<<"物理快情况：";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;}}void NRU(int pc[],int bc[],int pageCount,int blockCount){cout<<"3：Clock置换算法"<<endl;if(pageCount<=blockCount){cout<<"缺页次数为"<<0<<endl;cout<<"缺页率为"<<0<<endl;}else{int noPage=0;int i,j;int *bc1=new int[blockCount];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){cout<<"引用页："<<pc[i]<<endl;if(!Travel(bc,blockCount,pc[i])){for(j=0;j<blockCount;j++){if(bc1[j]==1){bc1[j]=0;}else if(bc1[j]==0){break;}if(j==blockCount-1){j=-1;}}bc[j]=pc[i];bc1[j]=1;noPage++;cout<<"物理快情况：";Print(bc,blockCount);}cout<<endl;}cout<<"缺页次数为:"<<noPage<<endl;cout<<"缺页率为:"<<(float)noPage/pageCount<<endl;delete bc1;}}int main(){int pageCount,blockCount,i;cout<<"输入页面数"<<endl;cin>>pageCount;int *pc=new int[pageCount];cout<<"输入页面走向"<<endl;for(i=0;i<pageCount;i++){cin>>pc[i];}cout<<"输入物理块数"<<endl;cin>>blockCount;cout<<"0：FIFO置换算法"<<endl;cout<<"1：LRU置换算法"<<endl;cout<<"2：最佳置换算法"<<endl;cout<<"3：Clock置换算法"<<endl;cout<<"按数字选择算法类别："<<endl;int n;while(cin>>n){if(n==0){int *bc=new int[blockCount];FIFO(pc,bc,pageCount,blockCount);delete bc;}else if(n==1){int *bc=new int[blockCount];LRU(pc,bc,pageCount,blockCount);delete bc;}else if(n==2){int *bc=new int[blockCount];Optiomal(pc,bc,pageCount,blockCount);delete bc;}else if(n==3){int *bc=new int[blockCount];for(i=0;i<blockCount;i++){bc[i]=-1;}NRU(pc,bc,pageCount,blockCount);delete bc;}else break;}delete pc;return 0;}。
fifo算法和lru算法
fifo算法和lru算法FIFO算法和LRU算法是计算机领域中两种常用的置换算法，它们被广泛应用于操作系统和缓存管理中。
本文将详细介绍FIFO算法和LRU算法的原理、应用场景以及优缺点，并比较它们在不同场景下的性能表现。
一、FIFO算法FIFO算法（First-In-First-Out）是一种简单直观的置换算法，它根据页面调入内存的先后顺序，选择最早进入内存的页面进行置换。
具体而言，当系统需要为新的页面腾出空间时，FIFO算法会选择最早进入内存的页面进行替换，以此保证内存空间的有效利用。
FIFO算法的工作原理如下：1. 系统维护一个页面队列，用于记录页面进入内存的顺序。
2. 当新的页面需要调入内存时，系统将其加入页面队列的末尾。
3. 当页面置换发生时，FIFO算法选择队列中最早进入内存的页面进行替换，即选择队列中的第一个页面。
FIFO算法的优点是简单且易于实现，适用于实时应用场景和对页面访问顺序没有严格要求的场景。
然而，FIFO算法也存在一些缺点。
首先，它无法利用页面的访问频率信息进行优化，导致可能会把频繁被访问的页面置换出去。
其次，FIFO算法对于长时间保留在内存中的页面和短时间仅被访问一次的页面一视同仁，无法根据页面的使用模式进行智能调整。
二、LRU算法LRU算法（Least Recently Used）是一种基于页面访问模式的置换算法，它根据页面最近被访问的时间顺序，选择最长时间未被访问的页面进行置换。
具体而言，当系统需要为新的页面腾出空间时，LRU算法会选择最长时间未被访问的页面进行替换，以此提高缓存命中率。
LRU算法的工作原理如下：1. 系统维护一个页面访问历史链表，用于记录页面的访问顺序。
2. 当页面被访问时，系统将其移动到链表的末尾。
3. 当页面置换发生时，LRU算法选择链表中最早进入的页面进行替换，即选择链表中的第一个页面。
LRU算法的优点是能够较好地适应页面访问模式，并做出相应调整。
【算法】页面置换算法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和OPT页面置换算法
目录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 课程设计总结 (9)7 参考文献 (10)8 附录：源程序清单 (10)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)
#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20//页面走向长度最大为20int M; //内存块struct Pro//定义一个结构体{ int num,time;};Input(int m,Pro p[L])//打印页面走向状态{ cout<<"请输入实际页走向长度L(15<=L<=20)：";do{ cin>>m;if(m>20||m<15)cout<<"实际页长度须在15～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;int m=0,t=0;float n=0;Pro p[L];m=Input(m,p);//调用input函数，返回m值cout<<"请输入可用内存页面数m(3～5): ";do{ cin>>M;if(M>5||M<3)cout<<"内存块m须在3～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<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"按其它键结束程序；"<<endl;cin>>c;system("cls");if(c==1)//FIFO页面置换{ n=0;cout<<" ****************************************** "<<endl;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<"****************************************** "<<endl;while(i<m){ if(Search(p[i].num,page)>=0) //当前页面在内存中{ cout<<p[i].num<<" "; //输出当前页p[i].numcout<<"不缺页"<<endl;i++; //i加1}else //当前页不在内存中{ if(t==M)t=0;else{ n++; //缺页次数加1page[t].num=p[i].num;//把当前页面放入内存中cout<<p[i].num<<" ";print(page); //打印当前页面t++; //下一个内存块i++; //指向下一个页面}}}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}if(c==2)//LRU页面置换{ n=0;cout<<" ******************************************"<<endl;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<" ******************************************"<<endl;while(i<m){int a;t=Search(p[i].num,page);if(t>=0)//如果已在内存块中{ page[t].time=0;//把与它相同的内存块的时间置0for(a=0;a<M;a++)if(a!=t)page[a].time++;//其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else //如果不在内存块中{ n++; //缺页次数加1t=Max(page); //返回最近最久未使用的块号赋值给tpage[t].num=p[i].num; //进行替换page[t].time=0; //替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0;a<M;a++)if(a!=t)page[a].time++; //其它的时间加1}i++;}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}}while(c==1||c==2||c==3);return 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算法是虚拟内存管理中常用的页面替换算法，它们各自具有不同的原理和应用场景。
在实际应用中，需要根据具体的需求和场景选择合适的算法，以实现最优的内存管理效果。
内存FIFO、LRU页面置换算法的设计
内存FIFO、LRU页面置换算法的设计设计目的：通过对内存页面置换算法的设计，深入理解虚拟存储管理的原理设计内容：-内容：实现教材4.8节中所描述的FIFO置换算法-要求：假设系统采用固定分配局部置换策略，某进程的总页面数为8（分别以数字0－7来代表）；运行时，输入分配给该进程的页块数（如：3）和一个20位长的页面访问序列（如：70120,30423,03212,01701），输出缺页次数和缺页率。
运行环境：VC6附：一下代码经过再三修改，保证完整的。
如果有错的，再联系我。
设计代码：#include <iostream.h>#include<string>const int Bsize=10;const int Psize=20;typedef struct page{int content;//页面号int timer;//被访问标记}page;page block[Bsize];//物理块page page[Psize];//页面号串void Init(int QString[],int Bsize){//初始化for(int i=0; i<Bsize; i++){block[i].content = -1;//找到空闲内存block[i].timer = 0;}for(i=0; i<Psize; i++){page[i].content = QString[i];page[i].timer = 0;}}int findSpace(int Bsize){//查找是否有空闲内存for(int i=0; i<Bsize; i++)if(block[i].content == -1)return i;//找到空闲内存，返回BLOCK中位置return -1;}int findExist(int curpage, int Bsize){//查找内存中是否有该页面for(int i=0; i<Bsize; i++)if(block[i].content == page[curpage].content)return i;//找到内存中有该页面，返回BLOCK中位置return -1;}int findReplace(int Bsize){//查找应予置换的页面int pos = 0;for(int i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i;//找到应予置换页面，返回BLOCK中位置return pos;}void display(int Bsize){//显示for(int i=0; i<Bsize; i++)if(block[i].content != -1)//非空闲内存cout<<block[i].content<<" ";cout<<endl;}void FIFO(int Bsize){//先进先出页面置换算法int exist,space,position ;float score=0;for(int i=0; i<Psize; i++){exist = findExist(i,Bsize);if(exist != -1)//内存中有该页面{cout<<"不缺页"<<endl;score+=1;//统计不缺页次数}else{space = findSpace(Bsize);if(space != -1)//找到空闲内存{block[space] = page[i];display(Bsize);}else{position = findReplace(Bsize);//找到应予置换页面block[position] = page[i];display(Bsize);}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中所有页面timer++}cout<<"缺页次数为："<<20-score<<endl;cout<<"缺页率为："<<(20-score)*100/20<<"%"<<endl; }void LRU(int Bsize){//最近最久未使用置换算法int exist,space,position ;float score=0;for(int i=0; i<Psize; i++){exist = findExist(i,Bsize);if(exist != -1){block[exist].timer=0;cout<<"不缺页"<<endl;score+=1;}else{space = findSpace(Bsize);if(space != -1){block[space] = page[i];display(Bsize);}else{position = findReplace(Bsize);block[position] = page[i];display(Bsize);}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中所有页面TIMER++}cout<<"缺页次数为："<<20-score<<endl;cout<<"缺页率为："<<(20-score)*100/20<<"%"<<endl;}void BlockClear(int Bsize){for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}}void main(void){cout<<"|----------页面置换算法----------|"<<endl;cout<<"请输入20个数：\n";int i,QString[20],Bsize;for(i=0;i<20;i++){cin>>QString[i];}cout<<"页面号引用串: ";for(i=0;i<20;i++){cout<<QString[i]<<" ";}cout<<endl<<"------------------------------------------------------"<<endl; cout<<"选择<1>应用FIFO算法"<<endl;cout<<"选择<2>应用LRU算法"<<endl;cout<<"选择<0>退出"<<endl;cout<<"请选择：";int select;while(select){cin>>select;switch(select){case 0:break;case 1:cout<<"请输入分配的物理块数的大小: ";cin>>Bsize;Init(QString,Bsize);cout<<"FIFO算法结果如下:"<<endl;FIFO(Bsize);BlockClear(Bsize);cout<<"----------------------"<<endl;break;case 2:cout<<"请输入分配的物理块数的大小: ";cin>>Bsize;Init(QString,Bsize);cout<<"LRU算法结果如下:"<<endl;LRU(Bsize);BlockClear(Bsize);cout<<"----------------------"<<endl;break;default:cout<<"请输入正确功能号"<<endl;break;}}}运行结果：。
页面置换算法(FIFO算法_LRU算法)
实验四页面置换算法一、实验目的理解并掌握模拟分页式虚拟存储管理的缺页中断，以及选择页面调度算法处理缺页中断。
二、实验内容及要求选择一种或几种页面置换算法进行编程以实现该算法。
三、实验流程图四、实验程序1、FIFO算法#include"stdio.h"#define n 20#define m 4void main(){int ym[n],i,j,q,mem[m]={0},table[m][n];char flag,f[n];printf("请输入页面访问序列\n");for(i=0;i<n;i++)scanf("%d",&ym[i]);printf("\n");for(i=0;i<n;i++) //查页表，看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页，则置标志flag为‘*’else flag='';if(flag=='*'){for(j=m-1;j>0;j--) //淘汰最先调入的页面调入当前访问的mem[j]=mem[j-1];mem[0]=ym[i];}for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表（0代表为空，*代表有缺页）：\n");for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);}2、LRU算法#include"stdio.h"#define n 20#define m 5void main(){int ym[n],i,j,q,mem[m]={0},table[m][n];char flag,f[n];printf("请输入页面访问序列\n");for(i=0;i<n;i++)scanf("%d",&ym[i]);printf("\n");for(i=0;i<n;i++) //查页表，看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页，则置标志flag为‘*’else flag=' ';for(j=q;j>0;j--)mem[j]=mem[j-1];mem[0]=ym[i];for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表（0代表为空，*代表有缺页）：\n");for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);}五、实验结果1、FIFO(四内存块)2、LRU(五内存块)。
操作系统——模拟页面置换算法（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。
操作系统：Java实现页面置换算法（OPT,FIFO,LRU）
操作系统：Java实现页⾯置换算法（OPT,FIFO,LRU）前⾔代码有很多冗余，因为是写作业时写的，不过代码简单易懂，看看就可以改了。
置换算法介绍页⾯置换算法（也称为页⾯淘汰算法）是⽤来选择换出页⾯的算法。
在请求页式存储管理⽅式中，由于⼀个进程运⾏的时候不是所有的页⾯都在内存中，所以会出现缺页中断。
当缺页的时候内存没有空闲的物理块时就需要换出内存中的⼀页，具体换出哪⼀页⾯是由页⾯置换算法决定的，页⾯置换算法的优劣直接影响到系统的效率要注意把页⾯置换和连续分配⽅式中的交换区别开来，页⾯置换的单位是页⾯⽽不是整个进程，交换的单位是整个进程当发⽣缺页中断后，系统不⼀定会执⾏页⾯置换算法。
因为发⽣缺页中断仅仅说明需要执⾏的页⾯没有在内存中，如果内存空间中还有空闲块的话，只需要⽤缺页中断处理程序把需要的页⾯从外存调⼊内存即可。
不需要页⾯置换算法：只有内存中没有空闲块的时候才需要页⾯置换算法。
所以，缺页中断不⼀定导致执⾏页⾯置换算法。
1. 最佳置换算法（OPT）在预知⼀个进程的页⾯号引⽤串的情况下，每次都淘汰以后不再使⽤的或以后最迟再被使⽤的页⾯，这种算法就是最佳置换算法显然，最佳置换算法是最优的，具有最低的缺页率。
但由于实际操作中往往⽆法事先知道以后会引⽤到所有页⾯的信息，所以最佳置换算法⽆法实现，只能作为⼀个标准来衡量其他置换算法的优劣2. 先进先出算法（FIFO）FIFO算法是最简单的页⾯置换算法，每次总是淘汰最先进⼊内存的页⾯，也就是将在内存存驻留时间最长的页⾯淘汰掉该算法实现简单，⽤⼀个队列的数据结构就可以实现，将页⾯按照次序排成⼀个队列，并设置指针指向最先进⼊的页⾯，每次需要淘汰页⾯时，将指针所指的页⾯淘汰即可，不过FIFO算法可能会产⽣Belady⼀场（缺页次数随着分配的物理块号的增加⽽增加），⽽且由于FIFO算法与进程实际运⾏规律不符，可能会选择淘汰程序经常使⽤的界⾯，实际效果不好3. 最近最少使⽤算法（LRU）选择最近最久没有被使⽤的页⾯予以淘汰，其思想是⽤以前的页⾯引⽤情况来预测将来会出现页⾯引⽤情况，也就是假设⼀个页⾯刚被访问，那么不久该页⾯还会被访问。
先进先出（FIFO）页面置换算法C语言实现、最近最久未使用（LRU）页面置换算法C语言实现
先进先出（FIFO）页⾯置换算法C语⾔实现、最近最久未使⽤（LRU）页⾯置换算法C语⾔实现1.实现效果2.实现源代码1 #include<iostream>2 #include<process.h>3 #include<stdlib.h>4 #include<ctime>5 #include<conio.h>6 #include<stdio.h>7 #include<string.h>8using namespace std;910#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")/*表格控制*/11#define bsize 4 //物理块⼤⼩12#define psize 16 //进程⼤⼩13void chushihua();//初始化函数14void ymzh();16void changeaddr(struct Page p[], int logaddr);17void dizhizhuanhuan();18void menu();19int wang();2021int yemianliu[32]={0};//全局变量数组,地址流22int p;23struct Page {24int pno;//页号25int flag;//标志位26int cno;//主存号27int modf;//修改位28int addr;//外存地址29 }Page; //全局变量p是⼀共有多少地址流3031 typedef struct pagel32 {33int num; /*记录页⾯号*/34int time; /*记录调⼊内存时间*/35 }Pagel; /*页⾯逻辑结构,⽅便算法实现*/3637 Pagel b[bsize]; /*内存单元数*/38int c[bsize][psize];/*保存内存当前的状态:缓冲区*/39int queue[100];/*记录调⼊队列*/40int k;/*调⼊队列计数变量*/41int phb[bsize]={0};//物理块标号42int pro[psize]={0};//进程序列号43int flag[bsize]={0};//进程等待次数(存放最久未被使⽤的进程标志)*/ 44int i=0,j=0;//i表⽰进程序列号,j表⽰物理块号*/45int m =-1,n =-1;//物理块空闲和进程是否相同判断标志*/46int mmax=-1, maxflag=0;//标记替换物理块进程下标*/47int count =0; //统计页⾯缺页次数4849void chushihua() //初始化函数50 {51int t;52 srand(time(0));//随机产⽣指令序列53 p=12+rand()%32;54 cout<<"地址流序列:";55 cout<<endl;56for(i=0; i<p; i++)57 {58 t=1+rand()%9;59 yemianliu[i]=t;//将随机产⽣的指令数存⼊页⾯流60 }61for (i=p-1;i>=0;i--)62 {63 cout<<yemianliu[i]<<"";64 }65 cout<<endl;66 }67void ymzh()68 {69 chushihua();70 yemianzhihuan();71 }7273void yemianzhihuan()74 {75int a;76 printf("----------------------------------\n");77 printf("☆☆欢迎使⽤分页模拟实验系统☆☆\n");78 printf("----------------------------------");79 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");80 printf("☆☆1.进⼊硬件地址变换算法☆☆\n");81 printf("☆☆------------------------☆☆\n");82 printf("☆☆2.进⼊页⾯置换算法☆☆\n");83 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");84 printf("请输⼊您的选择:");85switch(a)86 {87case1:88 ymzh();89break;90case2:91 wang();92break;93default:94 cout<<"输⼊有误,请重新输⼊!"<<endl;95break;96 }97 }98100int j=logaddr/64;//对应的块号101int k=logaddr%64; //对应的偏移量102int flag=0;103int addr;104for(int i=0;i<8;i++)105 {106if(p[i].pno==j)//找到对应的页号107 {108if(p[i].flag==1)//页⾯标志为1109 {110 addr=p[i].cno*64+k;111 cout<<"物理地址为:"<<addr<<endl;112 cout<<"详细信息:"<<"\t页⾯号:"<<p[i].pno<<"\t 主存号："<<p[i].cno<<"\t偏移量:"<<k<<endl; 113 flag=1;114break;115 }116 }117 }118119if(flag==0)120 cout<<"该页不在主存,产⽣缺页中断"<<endl;121 }122123void dizhizhuanhuan()124 {125int a;126int ins;//指令逻辑地址127struct Page p[8];128 p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;129 p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;130 p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;131 p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;132 p[4].pno=4;p[4].flag=0;p[4].addr=017;133 p[5].pno=5;p[5].flag=0;p[5].addr=025;134 p[6].pno=6;p[6].flag=0;p[6].addr=212;135 p[7].pno=7;p[7].flag=0;p[7].addr=213;136 printf("\t\t\t--------------------------------\n");137 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");138 printf("\t\t\t---------------------------------\n");139 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");140 printf("\t\t\t☆☆1.输⼊指令☆☆\n");141 printf("\t\t\t☆☆------------------------☆☆\n");142 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");143 printf("\t\t\t☆☆------------------------☆☆\n");144 printf("\t\t\t☆☆0.EXIT ☆☆\n");145 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");146while(a!=0)147 {148 cout<<endl<<"请输⼊您的选择:";149 cin>>a;150151 cout<<"页号"<<"标记位"<<"外存地址"<<"主存号"<<endl;152for(int i=0;i<8;i++)153 {154 cout<<p[i].pno<<"\t"<<p[i].flag<<"\t"<<p[i].addr<<"\t";155if(p[i].flag)156 cout<<p[i].cno;157 cout<<endl;158 }159160switch(a)161 {162case0:printf("\t\t\t再见!\t\t\t\n"); break;163case1:164 cout<<"请输⼊指令的逻辑地址:";165 cin>>ins;166 changeaddr(p, ins);break;167case2: system("CLS"); a=wang();break;168default:cout<<"输⼊有误,请重新输⼊!"<<endl;break;169 }170 }171 }172173void menu()174 {175int a;176 printf("\t\t\t--------------------------------\n");177 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");178 printf("\t\t\t---------------------------------\n");179 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");180 printf("\t\t\t☆☆1.输⼊指令☆☆\n");181 printf("\t\t\t☆☆------------------------☆☆\n");182 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");184 printf("\t\t\t☆☆0.EXIT ☆☆\n");185 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n"); 186 printf("请选择所要执⾏的操作:");187 scanf("%d",&a);188switch(a)189 {190case0: printf("\t\t\t-再见!-\t\t\t\n");break;191case1: dizhizhuanhuan (); break;192case2: wang (); break;193default:cout<<"输⼊有误,请重新输⼊!"<<endl;break; 194 }195 }196int main()197 {198 menu();199 }200201//****************随机产⽣序列号函数202int* build()203 {204 printf("随机产⽣⼀个进程序列号为:\n");205int i=0;206for(i=0; i<psize; i++)207 {208 pro[i]=10*rand()/(RAND_MAX+1)+1;209 printf("%d ", pro[i]);210 }211 printf("\n");212return(pro);213 }214215//***************************************查找空闲物理块216int searchpb()217 {218for (j=0;j<bsize; j++)219 {220if(phb[j] == 0)221 {222 m=j;223return m;224break;225 }226 }227return -1;228 }229//************************************查找相同进程230int searchpro()231 {232for(j=0;j< bsize;j++)233 {234if(phb[j] =pro[i])235 {236 n=j;237return j;238 }239 }240return -1;241 }242243//*************************初始化内存244void empty()245 {246for(i=0;i<bsize;i++)247 phb[i]=0;248 count=0; //计数器置零249 } //******先进先出页⾯置换算法250void FIFO()251 {252for( i=0; i<psize; i++)253 {254// m=searchpb();255// n=searchpro();256//找到第⼀个空闲的物理快257for(j=0;j<bsize;j++) {258if(phb[j] == 0){259 m=j;260break;261 }262 }263//找与进程相同的标号264for(j=0;j<bsize;j++) {265if(phb[j] == pro[i]){266 n=j;268 }269270//找flag值最⼤的271for(j=0;j<bsize;j++)272 {273if(flag[j]>maxflag)274 {275 maxflag = flag[j];276 mmax = j;277 }278 }279280if(n == -1)//不存在相同进程281 {282if(m != -1)//存在空闲物理块283 {284 phb[m]=pro[i];//进程号填⼊该空闲物理块285// count++;286 flag[m]=0;287for (j=0;j<=m; j++)288 {289 flag[j]++;290 }291 m=-1;292 }293else//不存在空闲物理块294 {295 phb[mmax] =pro[i];296 flag[mmax] =0;297for (j=0;j<bsize;j++)298 {299 flag[j]++;300 }301 mmax = -1;302 maxflag = 0;303 count++;304 }305 }306else//存在相同的进程307 {308 phb[n] = pro[i];309for(j=0;j<bsize;j++)310 {311 flag[j]++;312 }313 n=-1;314 }315for(j=0;j < bsize;j++)316 {317 printf("%d ", phb[j]);318 }319 printf("\n");320 }321 printf("缺页次数为:%d\n",count);322 printf("缺页率 :%16. 6f",(float)count/psize);323 printf("\n");324 }325/*初始化内存单元、缓冲区*/326void Init(Pagel *b,int c[bsize][psize])327 {328int i,j;329for (i=0;i<psize;i++)330 {331 b[i].num=-1;332 b[i].time=psize-i-1;333 }334for(i=0;i<bsize;i++)335for(j=0;j<psize;j++)336 c[i][j]=-1;337 }338/*取得在内存中停留最久的页⾯,默认状态下为最早调⼊的页⾯*/ 339int GetMax(Pagel *b)340 {341int i;342int max=-1;343int tag=0;344for(i=0;i<bsize;i++)345 {346if(b[i].time>max)347 {348 max=b[i].time;349 tag= i;350 }353 }354355/*判断页⾯是否已在内存中*/356int Equation(int fold, Pagel *b)357 {358int i;359for(i=0;i<bsize;i++)360 {361if(fold==b[i]. num)362return i;363 }364return -1;365 }366/*LRU核⼼部分*/367void Lruu(int fold, Pagel *b)368 {369int i;370int val;371 val=Equation(fold, b);372if (val>=0)373 {374 b[val].time=0;375for(i=0;i<bsize;i++)376if (i!=val)377 b[i].time++;378 }379else380 {381 queue[++k]=fold;/*记录调⼊页⾯*/382 val=GetMax(b);383 b[val].num=fold;384 b[val].time=0;385for (i=0;i<bsize;i++){386387// URLcount++;388if (i!=val)389 b[i].time++;390 }391 }392 }393394void LRU()395 {396int i,j;397 k=0;398 Init(b, c);399for(i=0; i<psize; i++)400 {401 Lruu(pro[i],b);402 c[0][i]=pro[i];403/*记录当前的内存单元中的页⾯*/404for(j=0;j<bsize;j++)405 c[j][i]=b[j].num;406 }407408/*结果输出*/409 printf("内存状态为:\n");410 Myprintf;411for(j=0;j<psize;j++)412 printf("|%2d", pro[j]);413 printf("|\n");414 Myprintf;415416for(i=0;i<bsize;i++)417 {418for(j=0; j<psize; j++)419 {420if(c[i][j]==-1)421 printf("|%2c",32);422else423 printf("|%2d",c[i][j]);424 }425 printf("|\n");426 }427428 Myprintf;429// printf("\n调⼊队列为:");430// for(i=0;i<k;i++)431// printf("%3d", queue[i]);432433 printf("\n缺页次数为:%6d\n 缺页率 :%16. 6f", k+1,(float)(k+1)/psize); 434 }437int wang()438 {439int sel;440do{441 printf("\t\t\t--------------------------------\n");442 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");443 printf("\t\t\t---------------------------------\n");444 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");445 printf("\t\t\t☆☆虚拟内存☆☆\n");446 printf("\t\t\t☆☆------------------------☆☆\n");447 printf("\t\t\t☆☆1.产⽣随机序列☆☆\n");448 printf("\t\t\t☆☆------------------------☆☆\n");449 printf("\t\t\t☆☆2.最近最久未使⽤☆☆\n");450 printf("\t\t\t☆☆------------------------☆☆\n");451 printf("\t\t\t☆☆3.先进先出☆☆\n");452 printf("\t\t\t☆☆------------------------☆☆\n");453 printf("\t\t\t☆☆0.退出☆☆\n");454 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");455 printf("请选择所要执⾏的操作:");456 scanf("%d",&sel);457switch(sel)458 {459case0: printf("\t\t\t再见!t\t\t\n"); break;460case1: build(); break;461case2: printf("最近最久未使⽤\n"); LRU();empty(); printf("\n");break; 462case3: printf("先进先出算法\n"); FIFO();empty();printf("\n");break; 463default:printf("请输⼊正确的选项号!");printf("\n\n");break;464 }465 }while(sel !=0 );466return sel;467 }。
模拟页面置换算法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;}}return -1;}/*** 页面转换* @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算法定义选择在内存中驻留时间最久的页面予以淘汰，对于内存中的驻留时间理解复杂了不知道如何下手。
操作系统_页面置换算法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;
页面置换算法(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);}。
操作系统_页面置换算法FIFO,OPT,LRU实现
操作系统第六次上机在一个请求分页系统中，设页面大小占100个单元，假如系统分配给一个作业的物理块数为3，试求出用FIFO，LRU，OPT三种算法在程序访问过程中所发生的缺页次数及缺页率，每次中断时都需要打印出来或者标示出来。
（假设最初页面都在外存）1. 假定此作业的访问地址序列为202，313，252，111，546，217，444，544，365，223，398，111。
2. 输入任意的访问序列，也必须正确显示。
/*代码尚需完善：1.应由用户输入数组，且应根据题目要求对每个数/100，得到页块标号。
2.在动态输入的情况下，通过sizeof,获得数组长度，实现任意输入的处理。
3.FIFO算法实现，why？4.在OPT实现中，mark属性设置，以及向后遍历的参数设置？*///前三个页块单独处理，需注意前三个页块也可能重复。
已做出修改！#include<iostream>usingnamespace std;int input[12] = { 2,3,2,1,5,2,4,5,3,2,3,1 };class page{public:int num;int mark;page(){num = 0;mark = -1;}};void FIFO(){cout<<"------FIFO-----------"<<endl;int error = 0;page frame[3]; //页帧bool flag = true;int check = 0;for (int i = 0; i<3; i++) //处理前三个引用{for (int k = 0; k <i; k++) {if (input[i] == input[k])flag = false;}if (flag == true) {frame[i].num = input[i];frame[i].mark = i;error++;cout<< frame[i].num<<" | ";for (int j = 0; j <= i; j++)cout<< frame[j].num<<' ';cout<<endl;}else{check++;}}for (int i = 3-check; i<12; i++){int j;for (j = 0; j<3; j++)if (input[i] == frame[j].num){cout<< input[i] <<endl;break;}if (j == 3){error++;frame[((error - 1) % 3)].num = input[i]; //换掉最旧的页//？？？？cout<< input[i] <<" | ";for (int k = 0; k<3; k++)cout<< frame[k].num<<' ';cout<<endl;}}cout<<"FIFO:"<<endl;cout<<"Error次数:"<< error <<endl;cout<<"Frame Error:"<< (error/12.0) <<endl<<endl; }void OPT(){cout<<"------OPT------------"<<endl;int error = 0;page frame[3];bool flag = true;int check = 0;for (int i = 0; i<3; i++) //处理前三个引用{for (int k = 0; k <i; k++) {if (input[i] == input[k])flag = false;}if (flag == true) {frame[i].num = input[i];error++;cout<< frame[i].num<<" | ";for (int j = 0; j <= i; j++)cout<< frame[j].num<<' ';cout<<endl;}else{check++;}}for (int i = 3-check; i<12; i++){int j;for (j = 0; j<3; j++)if (input[i] == frame[j].num){cout<< input[i] <<endl;break;}if (j == 3){error++;for (j = 0; j<3; j++){frame[j].mark = 21; //？？？for (int k =20; k >= i; k--) //向后遍历，找到最长时间不用的页//k =20？？？貌似修改后会出问题{if (frame[j].num == input[k])frame[j].mark = k;}}if (frame[0].mark>frame[1].mark&&frame[0].mark>frame[2].mark)frame[0].num = input[i];elseif (frame[1].mark>frame[0].mark&&frame[1].mark>frame[2].mark)frame[1].num = input[i];elseframe[2].num = input[i];cout<< input[i] <<" | ";for (int k = 0; k<3; k++)cout<< frame[k].num<<' ';cout<<endl;}}cout<<"OPT:"<<endl;cout<<"Error次数:"<< error <<endl;cout<<"Frame Error:"<< (error / 12.0) <<endl<<endl;}void LRU(){cout<<"------LRU------------"<<endl;int error = 0;page frame[3];bool flag = true;int check = 0;for (int i = 0; i<3; i++)//处理前三个引用{for (int k = 0; k <i; k++) {if (input[i] == input[k])flag = false;}if (flag == true) {frame[i].num = input[i];error++;cout<< frame[i].num<<" | ";for (int j = 0; j <= i; j++)cout<< frame[j].num<<' ';cout<<endl;}else{check++;}}for (int i = 3-check; i<12; i++){int j;for (j = 0; j<3; j++)if (input[i] == frame[j].num){cout<< input[i] <<endl;break;}if (j == 3){error++;for (j = 0; j<3; j++){frame[j].mark = -1;for (int k = 0; k <= i; k++)//向前遍历，找到最近最少使用的{if (frame[j].num == input[k])frame[j].mark = k;}}if (frame[0].mark<frame[1].mark&&frame[0].mark<frame[2].mark)frame[0].num = input[i];elseif (frame[1].mark<frame[0].mark&&frame[1].mark<frame[2].mark) frame[1].num = input[i];elseframe[2].num = input[i];cout<< input[i] <<" | ";for (int k = 0; k<3; k++)cout<< frame[k].num<<' ';cout<<endl;}}cout<<"LRU:"<<endl;cout<<"Error次数:"<< error <<endl;cout<<"Frame Error:"<< (error / 12.0)<<endl<<endl;}int main(){FIFO();OPT();LRU(); }。
存储管理的页面置换算法详解
存储管理的页面置换算法存储管理的页面置换算法在考试中常常会考到，操作系统教材中主要介绍了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等。
同时，还会详细介绍实验步骤和设置的参数。
实验环境操作系统：Windows 10编程语言：C++开发环境：Visual。
2019页面置换算法FIFO（First-In-First-Out）算法：按照先进先出的原则置换页面，最早进入内存的页面会被置换出去。
LRU（Least Recently Used）算法：根据页面的使用情况，置换最长时间没有被访问过的页面。
OPT（Optimal）算法：理论上最优的页面置换算法，根据未来一段时间内页面的访问情况，选择最少使用的页面进行置换。
实验步骤创建一个模拟操作系统的C++程序。
设定内存大小、页面大小和页面数等参数。
实现FIFO算法，将其应用于模拟操作系统中的页面置换过程。
实现LRU算法，将其应用于页面置换过程。
实现OPT算法，将其应用于页面置换过程。
运行模拟程序，观察不同页面置换算法的效果。
分析比较不同算法的页面置换结果，评估其优缺点。
参数设置内存大小：512MB页面大小：4KB页面数：128以上是本次实验的实验设计，将通过创建模拟操作系统程序，实现FIFO、LRU和OPT等页面置换算法，并对其结果进行比较和评估。
本实验展示了页面置换算法的不同性能，并分析了各种算法的优缺点。
实验结果表明，不同的页面置换算法对系统性能有显著影响。
以下是对各种算法的性能分析：先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。
先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。
页面置换算法实验总结
页面置换算法实验总结
在操作系统中，页面置换算法是为了解决内存不足的问题，当内存中的页面不足时，需要选择一些页面进行置换，将其换出到磁盘上，从而为新的页面腾出空间。
在本次实验中，我实现了三种页面置换算法，分别是FIFO（先进先出）、LRU（最近最少使用）和OPT（最佳置换）。
下面是对这三种算法的总结：
1. FIFO算法：FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。
实验结果显示，FIFO算法在某些情况下可能会导致“抖动”现象，即不断发生页面置换，性能较差。
2. LRU算法：LRU算法是根据页面的使用历史进行置换，将最长时间没有被使用的页面置换出去。
实验结果显示，LRU算法相比于FIFO算法在减少页面抖动方面表现更好，但是实现起来较为复杂，需要维护一个访问历史记录的数据结构。
3. OPT算法：OPT算法是一种理想情况下的页面置换算法，它通过预测未来的页面访问情况来选择最佳的页面进行置换。
实验结果显示，OPT算法在减少页面抖动方面表现最好，但是实现起来较为困难，需要对未来的页面访问情况进行预测。
综上所述，不同的页面置换算法在不同的场景下有着不同的表现。
FIFO算法简单易实现，但性能较差；LRU算法在某些情况下能够较好地减少页面抖动；OPT算法在理论上是最佳的页面置换算法，但实现起来较为困难。
实际中的选择需要根据具体的应用场景
和系统需求来确定。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
q=0;
while((ym[i]!=mem[q])&&(q!=m)) q++;
if(q==m) flag='*';
//缺页，则置标志flag为‘*’
else flag=' ';
for(j=q;j>0;j--)
mem[j]=mem[j-1];
mem[0]=ym[i];
for(j=0;j<m;j++)
实验四 页面置换算法
一、 实验目的
理解并掌握模拟分页式虚拟存储管理的缺页中断，以及选择页面调度算法处 理缺页中断。
二、 实验内容及要求
选择一种或几种页面置换算法进行编程以实现该算法。
三、 实验流程图
输入页面访问序列
取访问的页号
查页表
是
否
是否缺页？
置缺页标志 flag 为’*’
按算法不同淘汰一页面 调入所访问的页面
scanf("%d",&ym[i]);
printf("\n");
for(i=0;i<n;i++)
//查页表，看是否缺页
{
q=0;
while((ym[i]!=mem[q])&&(q!=m)) q++;
if(q==m) flag='*';
//缺页，则置标志flag为‘*’
else flag=' ';
if(flag=='*')
{
for(j=0;j<n;j++)
printf("%3d",table[i][j]);
printf("\n");
}
for(i=0;i<n;i++)
printf("%3c",f[i]);
}
2、LRU 算法
#include "stdio.h"
#define n 20
#define m 5
void main()
{
int ym[n],i,j,q,mem[m]={0},table[m][n];
char flag,f[n];
printf("请输入页面访问序列\n");
for(i=0;i<n;i++)
scanf("%d",&ym[i]);
printf("\n");
for(i=0;i<n;i++)
//查页表，看是否缺页
table[j][i]=mem[j];
f[i]=flag;
}
printf("输出结果为下表（0代表为空，*代表有缺页）：\n");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
printf("%3d",table[i][j]);
printf("\n");
}
for(i=0;i<n;i++)
四、 实验程序
1、FIFO算法
#include "stdio.h"
#define n 20
#define m 4
void main()
{
int ym[n],i,j,q,mem[m]={0},table[m][n];
char flag,f[n];
printf("请输入页面访问序列\n");
for(i=0;i<n;i+&>0;j--)
//淘汰最先调入的页面调入当前访问的
mem[j]=mem[j-1];
mem[0]=ym[i];
}
for(j=0;j<m;j++)
table[j][i]=mem[j];
f[i]=flag;
}
printf("输出结果为下表（0代表为空，*代表有缺页）：\n");
for(i=0;i<m;i++)
printf("%3c",f[i]);
}
五、 实验结果
1、FIFO(四内存块)
2、LRU(五内存块)
六、 实验心得
通过这次实验，进一步了解了什么是缺页中断，以及处理缺页中断的 调度算法。通过自己编程，加深了对理论学习的理解。