页面调度算法OPT的模拟实现

合集下载

页面调度算法模拟实验中遇到的问题

页面调度算法模拟实验中遇到的问题在页面调度算法模拟实验中，可能会遇到以下一些问题：
1、算法选择问题：不同的页面调度算法有不同的优势和适用场景，如FIFO、LRU、OPT等。

在实验中，选择合适的算法是一个挑战。

可能需要考虑内存大小、访问模式、页面访问频率等因素，以确定使用哪种算法进行模拟实验。

2、数据集选择问题：在模拟实验中，需要使用真实或合成的数据集来模拟页面访问的情况。

选择合适的数据集是一个关键问题，需要考虑数据集的规模、访问模式的真实性以及数据集的可用性等因素。

3、实验结果的评估问题：页面调度算法的性能可以通过不同的指标进行评估，如缺页率、命中率、平均访问时间等。

在实验中，选择合适的评估指标以及评估方法是一个重要问题。

4、实验参数的设置问题：在模拟实验中，还需要考虑一些参数的设置，如内存大小、页面大小、进程数量等。

这些参数的选择可能会对实验结果产生影响，需要合理设置以保证实验的可靠性和有效性。

5、实验结果的可视化问题：实验结果的可视化是一个重要的环节，可以通过图表、曲线等形式展示实验结果，以便于对比不同算法的性能表现。

在实验中，实现合适的可视化方式可能会遇到一些技术上的挑战。

这些问题都需要在实验前进行充分的准备和规划，以确保实验的
可靠性和有效性。

同时，也需要注意实验过程中可能遇到的其他问题，并及时进行调整和解决。

实验6 页面调度算法模拟

实验五：页面调度算法模拟一、实验目的1、熟悉操作系统页面调度算法2、编写程序模拟最佳置换、LRU等页面调度算法，体会页面调度算法原理二、实验基本原理1、页面的含义：分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。

2、页面置换算法的含义：在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。

但应将哪个页面调出，须根据一定的算法来确定。

通常，把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。

3、置换算法一个好的页面置换算法，应具有较低的页面更换频率。

从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。

常见置换算法：①最佳置换算法(Optimal)：它是由Belady于1966年提出的一种理论上的算法。

其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。

采用最佳置换算法，通常可保证获得最低的缺页率。

但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，便可以利用此算法来评价其它算法。

②先进先出(FIFO)页面置换算法：这是最早出现的置换算法。

该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。

③ LRU置换算法：LRU置换算法是选择最近最久未使用的页面予以淘汰。

二、实验参考程序先进先出页面调度算法模拟/*--------------------------------------------------------------------------- 程序说明：1、main函数在调用时会先产生一串随机数列，并存放在list[N]中；2、然后mian函数调用IsInBuf函数，把当前读到的单词x和buf[i]中的内容进行比较。

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中最先进⼊内存的页换出。

页面调度算法(FIFO,LRU,OPT)

else { for( int j = 1;j <= n;j++ )
if( CompareQueue( Q,page ) ) { t--;DeQueue(Q,e);EnQueue(Q,e);flag = 1;break; }
if( flag == 0 ) { DeQueue( Q,x );
flag = 0;
}
cout << "缺页中断数为:" << endl;
cout << "w = " << w << endl;
delete [] a;
}
main()
{
int m,n;
cout << "输入页面数：" << endl;
cin >> m;
LinkQueue Q;
int page, t = 0,flag = 0,x;
InitQueue( Q );
for( int i = 1;i <= m;i++ )
{
page = a[ i ];
t++;
if( t <= n ) { EnQueue( Q,page );
}
cout << endl;
VisitQueue( Q );
cout << ":";
}
flag = 0;
}
cout << "缺页中断数为:" << endl;
cout << "t= " << t << endl;

实验三页面调度算法

实验报告院（系）：数学与计算机科学学院专业班级：学号：姓名：实验地点：实验日期：年月日一、实验目的及要求通过本实验可以加深理解有关虚拟存储器的工作原理，进一步体会和了解页面替换算法的具体实现方法。

二、实验环境PC /Windows系统/Visual C++6.0三、实验内容①实现三种算法：先进先出；OPT；LRU②页面序列从指定的文本文件（TXT文件）中取出③输出：第一行：每次淘汰的页面号，第二行：显示缺页的总次数/*全局变量*/int mSIZE; /*物理块数*/int pSIZE; /*页面号引用串个数*/static int memery[10]={0}; /*物理块中的页号*/static int page[100]={0}; /*页面号引用串*/static int temp[100][10]={0}; /*辅助数组*//*置换算法函数*/void FIFO();void LRU();void OPT();/*辅助函数*/void print(unsigned int t);void designBy();void download();void mDelay(unsigned int Delay);/*先进先出页面置换算法*/void FIFO(){int memery[10]={0};int time[10]={0}; /*记录进入物理块的时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];time[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++; /*计算换出页*/max=time[0]<time[1]?0:1;for(m=2;m<mSIZE;m++)if(time[m]<time[max])max=m;memery[max]=page[i];time[max]=i; /*记录该页进入物理块的时间*/ for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)你temp[i][j]=memery[j];}}compute();print(count);}/*最近最久未使用置换算法*/void LRU(){int memery[10]={0};int flag[10]={0}; /*记录页面的访问时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];flag[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;elseflag[j]=i; /*刷新该页的访问时间*/ }if(k==mSIZE) /*如果不在物理块中*/{count++; /*计算换出页*/ max=flag[0]<flag[1]?0:1;for(m=2;m<mSIZE;m++)if(flag[m]<flag[max])max=m;memery[max]=page[i];flag[max]=i; /*记录该页的访问时间*/ for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}elsefor(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}compute();print(count);}/*最佳置换算法*/void OPT(){int memery[10]={0};int next[10]={0}; /*记录下一次访问时间*/int i,j,k,l,m;int max; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){ /*判断新页面号是否在物理块中*/ for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++;/*得到物理快中各页下一次访问时间*/for(m=0;m<mSIZE;m++){for(l=i+1;l<pSIZE;l++)if(memery[m]==page[l])break;next[m]=l;}/*计算换出页*/max=next[0]>=next[1]?0:1;for(m=2;m<mSIZE;m++)if(next[m]>next[max])max=m;/*下一次访问时间都为pSIZE,则置换物理块中第一个*/ memery[max]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}elsefor(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}compute();print(count);}四、实验步骤页面置换：在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。

FIFO LRU OPT页面置换算法的模拟实现(已调试)

操作系统之FIFO、LRU、OPT模拟实现1.FIFO算法#include<stdio.h>int main(int argc, char *argv[]){int i,j,k,k2,t;int n1; //memory page numberint n2; //requested page numberint pageseq[100]; //access page sequenceint mempages[10][2]; //memory pages//mempages[i][0] is page NO, mempages[i][1] is loading sequence No.int n3; //number of loaded pages in memoryint n4; //missing pages countint replacedPage;//Input dataprintf("Input memory page number for each process:");scanf("%d",&n1);if(n1<1){printf("Memory page number error!\n");return 1;}printf("Now, Input page access sequence.\n");printf("Input requested page number firstly:");scanf("%d",&n2);printf("%d pages are waiting for access.\n",n2);for(i=0 ;i<n2; i++){printf("%d-th page is:",i+1);scanf("%d",&t);pageseq[i] = t;}//FIFOn3 = 0;//number of loaded pages in memoryn4 = 0;//missing page count//replace pagesfor(i = 0; i<n2; i++){for(j = 0 ;j<n3; j++){if(mempages[j][0] == pageseq[i]) //page is in memorybreak;}if(j == n3 && n3 < n1) //not found in memory,but there are empty memory pages{mempages[n3][0] = pageseq[i];mempages[n3][1] = i+1;n3++;n4++;}else if(j == n3) //page is not in memory,pick up one for replacement{//find the page with minimal loading sequence No.int minv;minv = mempages[0][1];k2 = 0;for(k=1; k<n3; k++){if(minv > mempages[k][1]){k2 = k;minv = mempages[k][1];}}//replace mempages[k2][0] by pageseq[i]replacedPage = mempages[k2][0];mempages[k2][0] = pageseq[i];mempages[k2][1] = i+1;n4++; //missing page countingprintf("page %d in, page %d out. %d-th missing page.\n",pageseq[i],replacedPage,n4);}else{//page is in memoryprintf("page %d is in memory.\n",pageseq[i]);}}printf("Totally %d missing pages!\n",n4);return 0;}2.LRU#include<stdio.h>int main(int argc, char *argv[]){int i,j,k,k2,t;int n1; //memory page numberint n2; //requested page numberint pageseq[100]; //access page sequenceint mempages[10][2]; //memory pages//mempages[i][0] is page NO, mempages[i][1] is loading sequence No.int n3; //number of loaded pages in memoryint n4; //missing pages countint replacedPage;//Input dataprintf("Input memory page number for each process:");scanf("%d",&n1);if(n1<1){printf("Memory page number error!\n");return 1;}printf("Now, Input page access sequence.\n");printf("Input requested page number firstly:");scanf("%d",&n2);printf("%d pages are waiting for access.\n",n2);for(i=0 ;i<n2; i++){printf("%d-th page is:",i+1);scanf("%d",&t);pageseq[i] = t;}//LRUn3 = 0;//number of loaded pages in memoryn4 = 0;//missing page count//replace pagesfor(i = 0; i<n2; i++){for(j = 0 ;j<n3; j++){if(mempages[j][0] == pageseq[i]) //page is in memory{mempages[j][1]=i+1;break;}}if(j == n3 && n3 < n1) //not found in memory,but there are empty memory pages{mempages[n3][0] = pageseq[i];mempages[n3][1] = i+1;n3++;n4++;}else if(j == n3) //page is not in memory,pick up one for replacement{//find the page with minimal loading sequence No.int minv;minv = mempages[0][1];k2 = 0;for(k=1; k<n3; k++){if(minv > mempages[k][1]){k2 = k;minv = mempages[k][1];}}//replace mempages[k2][0] by pageseq[i]replacedPage = mempages[k2][0];mempages[k2][0] = pageseq[i];mempages[k2][1] = i+1;n4++; //missing page countingprintf("page %d in, page %d out. %d-th missing page.\n",pageseq[i],replacedPage,n4);}else{//page is in memoryprintf("page %d is in memory.\n",pageseq[i]);}}printf("Totally %d missing pages!\n",n4);return 0;}3.OPT#include<stdio.h>int main(int argc, char *argv[]){int i,j,k,k2,t;int n1; //memory page numberint n2; //requested page numberint pageseq[100]; //access page sequenceint mempages[10][2]; //memory pages//mempages[i][0] is page NO, mempages[i][1] is loading sequence No.int n3; //number of loaded pages in memoryint n4; //missing pages countint replacedPage;//Input dataprintf("Input memory page number for each process:");scanf("%d",&n1);if(n1<1){printf("Memory page number error!\n");return 1;}printf("Now, Input page access sequence.\n");printf("Input requested page number firstly:");scanf("%d",&n2);printf("%d pages are waiting for access.\n",n2);for(i=0 ;i<n2; i++){printf("%d-th page is:",i+1);scanf("%d",&t);pageseq[i] = t;}//FIFOn3 = 0;//number of loaded pages in memoryn4 = 0;//missing page count//replace pagesfor(i = 0; i < n2; i++){for(j = 0 ;j < n3; j++){if(mempages[j][0] == pageseq[i]) //page is in memorybreak;}if(j == n3 && n3 < n1) //not found in memory,but there are empty memory pages{mempages[n3][0] = pageseq[i];mempages[n3][1] = i+1;n3++;n4++;}else if(j == n3) //page is not in memory,pick up one for replacement{//find the page with minimal loading sequence No.int max;int t;for(j = 0 ;j < n3; j++){for( t = i+1; t < n2; t++){if( mempages[j][0] == pageseq[t] ){mempages[j][1] = t;break;}}if( t == n2 )mempages[j][1] = n2+1;}//int max;max = mempages[0][1];k2 = 0;for(k=1; k<n3; k++){if( mempages[k][1] > max ){k2 = k;max = mempages[k][1];}}//replace mempages[k2][0] by pageseq[i]replacedPage = mempages[k2][0];mempages[k2][0] = pageseq[i];//mempages[k2][1] = i+1;n4++; //missing page countingprintf("page %d in, page %d out. %d-th missing page.\n",pageseq[i],replacedPage,n4);}else{//page is in memoryprintf("page %d is in memory.\n",pageseq[i]);}}printf("Totally %d missing pages!\n",n4);return 0;}。

操作系统——页面调度算法

操作系统——页⾯调度算法在之前系列的博客中介绍了页⾯调度算法的原理：这⾥编写代码模拟⼀些页⾯调度算法的实现。

（1）最佳淘汰算法——OPT(Optimal)这是Belady贝莱迪于1966年提出的⼀种理论上的算法。

该算法每次都淘汰以后永不使⽤的，或者过最长的时间后才会被访问的页⾯。

显然，采⽤这种算法会保证最低的缺页率，但它是⽆法实现的，因为它必须知道页⾯“将来”的访问情况。

不过，该算法仍有⼀定意义，可作为衡量其他算法优劣的⼀个标准。

（2）先进先出淘汰算法——FIFO这是最早出现的淘汰算法。

总是淘汰最先进⼊内存的页⾯。

它实现简单，只需把进程中已调⼊内存的页⾯，按先后次序链成⼀个队列，并设置⼀个所谓的替换指针，使它总是指向内存中最⽼的页⾯。

（3）最近最久未使⽤算法——(LRU, Least Recently Used）根据页⾯调⼊内存后的使⽤情况，选择内存中最久未使⽤的页⾯被置换。

这是局部性原理的合理近似，性能接近最佳算法。

OPT算法使⽤页⾯将要被访问的时间，LRU算法使⽤页⾯最后⼀次被访问的时间。

⼆者唯⼀的差别是：OPT是向前看的，⽽LRU是向后看的。

#include<cstdio>#include<cstring>#include<algorithm>using namespace std;int N;//进程虚页数int M;//内存块个数int page[100];//进程虚页int block[100];//内存块int weight[100];//当前内存块在后⾯出现的次数int success;//命中次数int fail;//未命中次数void FIFO(){int i,j;int flag;int pos=0;int success=0;int fail=0;for(i=0; i<N; i++){flag =0;for(j=1; j<=M; j++){if(page[i]==block[j])//命中{flag=1;success++;pos--;break;}}if(flag==0){fail++;block[pos%M+1]=page[i];}pos++;for(j=1; j<=M; j++){printf("%d ",block[j]);}printf("\n");}printf("命中次数为：%d\n",success);printf("未命中次数为：%d\n",fail);}void OPT(){int i,j,k;int flag;int success=0;int fail=0;int needReplace;for(i=0; i<N; i++){flag=0;for(j=1; j<=M; j++){if(page[i]==block[j])//命中{flag=1;success++;}}if(flag==0)//未命中{fail++;for(j=1; j<=M; j++) //若内存块未满，先将内存块填满 {if(block[j]==0){block[j]=page[i];break;}}int minCnt=100;memset(weight,0,sizeof(weight));if(j>M)//若内存块已满，需要进⾏调度{for(k=i+1; k<N; k++) //向后{for(j=1; j<=M; j++){if(block[j]==page[k]){weight[j]=N-k;//越靠近，权值越⼤break;}}}for(j=1; j<=M; j++) //找权值最⼩的那⼀个{if(weight[j]<=minCnt){minCnt=weight[j];needReplace=j;}}block[needReplace]=page[i];//替换掉权值最⼩的 }}for(j=1; j<=M; j++){printf("%d ",block[j]);}printf("\n");}printf("命中次数为：%d\n",success);printf("未命中次数为：%d\n",fail);}void LRU(){int i,j;int flag;int success=0;int fail=0;int needReplace;for(i=0; i<N; i++){flag=0;for(j=1; j<=M; j++){if(page[i]==block[j])//命中{flag=1;success++;}}if(flag==0)//未命中{fail++;for(j=1; j<=M; j++) //现将内存块填满{if(block[j]==0){block[j]=page[i];break;}}if(j>M)//内存块已满，需要进⾏调度{//向前找,需要替换的页⾯为i-MneedReplace=page[i-M];for(j=1; j<=M; j++){if(block[j]==needReplace)//找到后替换掉 {block[j]=page[i];break;}}}}for(j=1; j<=M; j++){printf("%d ",block[j]);}printf("\n");}printf("命中次数为：%d\n",success);printf("未命中次数为：%d\n",fail);}int main(){printf("请输⼊进程执⾏时页⾯访问个数：\n");scanf("%d",&N);printf("请输⼊空闲内存块的个数：\n");scanf("%d",&M);printf("请输⼊进程执⾏时页⾯访问次序：\n");memset(page,0,sizeof(page));memset(block,0,sizeof(block));int i;int needReplace;for(i=0; i<N; i++){scanf("%d",&page[i]);}printf("采⽤最佳淘汰算法OPT:\n");OPT();memset(block,0,sizeof(block));printf("采⽤先进先出淘汰算法FIFO:\n");FIFO();memset(block,0,sizeof(block));printf("采⽤最近最久未使⽤淘汰算法LRU:\n");LRU();return0;}/*123232152453252*/。

请求页式管理缺页中断模拟设计--FIFO、OPT

请求页式管理缺页中断模拟设计--FIFO、OPT1.程设计目的与功能2.1 目的实现请求页式管理缺页中断FIFO、OPT算法，掌握页式存储管理系统的相关理论知识。

2.2 功能实现指定淘汰算法。

能够处理一下情形：2.2.1能够输入给作业分配的内存块数；2.2.2 能够输入给定的页面，并计算发生缺页的次数以及缺页率；2.2.3 缺页时，如果发生页面置换，输出淘汰的页号。

2.需求分析，数据结构或模块说明(功能与框图)2.1算法的原理描述:2.1.1先进先出页面置换（FIFO）FIFO法基本思想：选择在内存驻留时间最长的页将其淘汰。

FIFO 算法认为先调入内存的页不再被访问的可能性要比其他页大，因而选择最先调入内存的页换出。

2.1.2理想型淘汰页面置换算法（OPT）OPT法基本思想：当要调入一新页而必须淘汰一旧页时，所淘汰的页是以后不再使用的，或者是以后相当长的时间内不会使用的。

这样，淘汰掉该页将不会造成因需要访问该页而又立即把它调入的现象。

该算法无法实现，因为，它要求必须预先知道每一个进程的访问串。

2.2 本次课程设计中的算法流程图2.2.1 FIFO算法的流程图如下图所示：2.2.2 OPT算法的流程图如下图所示：3.源程序的主要部分3.1 程序中要到的全局变量说明#define M 40//最大的访问页面序列数目int N;//内存页面块数3.2 结构体说明struct Pro{int num;//num 记录页面序列号};3.3主函数说明及注释void main(){ cin>>N;// 请输入可用内存物理块数:";Pro p[M];//最大的访问页面序列数目Pro *page=new Pro[N];char c;int m=0,t=0;float n=0;int fifoout[M];//记录FIFO算法淘汰的页面int optout[M];//记录OPT算法淘汰的页面int f=0,o=0;m=Input(m,p);//m返回输入的访问页面总书目do{for(int i=0;i<N;i++){page[i].num=0;//初试化内存页面}i=0;cout<<"****请选择页面置换的(f代表FIFO,o代表OPT)****策略"<<endl;cout<<"f:FIFO页面置换"<<endl;cout<<"o:OPT页面置换"<<endl;cout<<"其他键退出"<<endl;cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"******FIFO页面置换算法运行结果如下:******"<<endl;cout<<"FIFO页面置换情况为: "<<endl;while(i<m)//i为当前页面在输入序列中的位置{if(Search(p[i].num,page)>=0)//判断当前输入页面p[i].num 是否已经在内存中,若在则返回其在内存页面块中的位置{i++;//找到相同的页面}else{if(t==N)//N为内存页面数目，t记录是那个页面最先进入内存页面，用来判断内存页面块是否已满t=0;else{n++;//记录缺页次数fifoout[f]=page[t].num;//记录淘汰页面f++;page[t].num=p[i].num;//换入print(page);//输出当前内存页面分配情况t++;}}}cout<<"采用FIFO算法时依次淘汰的页面为：";for(i=0;i<f;i++)//输出淘汰页面号{if(fifoout[i]==0)continue;elsecout<<fifoout[i]<<" ";}cout<<"采用FIFO算法时的缺页次数为："<<n<<endl;cout<<"采用FIFO算法时的缺页率为: "<<(double)n/m<<endl;}if(c=='o')//OPT算法页面置换情况{n=0;cout<<"******OPT页面置换算法运行结果如下:******"<<endl;cout<<"OPT页面置换情况为: "<<endl;int count=0;while(i<m)//i为当前页面在输入序列中的位置{if(Search(p[i].num,page)>=0)//判断当前输入页面p[i].num 是否已经在内存中,若在则返回其在内存页面块中的位置{i++;}else{count++;if(count<=N)//判断内存页面是否有空空闲页面{page[count-1].num=p[i].num;//进入空闲内存n++;print(page);continue;}int temp=0,cn;for(t=0;t<N;t++)//t记录是那个页面最先进入内存页面{if(temp<Compfu(page,i,t,p))//在以后不回访问内存{temp=Compfu(page,i,t,p);cn=t;}}optout[o]=page[cn].num;//输出淘汰页面o++;page[cn].num=p[i].num;//页面置换n++;print(page);i++;}}cout<<"采用OPT算法时依次淘汰的页面为：";for(i=0;i<o;i++){if(optout[i]==0)continue;elsecout<<optout[i]<<" ";}cout<<"采用OPT算法时的缺页次数为："<<n<<endl;cout<<"采用OPT算法时的缺页率："<<(double)n/m<<endl;}else{exit;}}while(c=='f'||c=='o');}3.4输入函数Input(int m,Pro p[M])int Input(int m,Pro p[M]){ cout<<"请输入访问页面目数：";do{cin>>m;//访问页面数目if(m>M)cout<<"数目太多，请重试"<<endl;elsebreak;}while(1);cout<<"请输入访问页面号序列:";for(int i=0;i<m;i++){cin>>p[i].num;//依次输入页面访问顺序}return m;//返回输入的访问页面总数目}3.5输出函数print(Pro *page1)void print(Pro *page1)//输出当前内存块中的访问页面{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)cout<<page[i].num<<" ";cout<<endl;}3.6 Search(int e,Pro *page1 ) 函数int Search(int e,Pro *page1 )// 用于查找当前页面是否已在内存块中{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)if(e==page[i].num)return i;//返回页面号为e的页面在那个内存页面中return -1;//若不在则返回-1}3.7 Compfu(Pro *page1,int i,int t,Pro p[M]) 函数int Compfu(Pro *page1,int i,int t,Pro p[M])//i为当前页面在输入序列中的位置，t记录页面进入内存的顺序,此函数判断内存快中的页面page[t]在后续访问序列中出现的次数{Pro *page=new Pro[N];page=page1;int count=0;//记录当前页面的未来访问的次数for(int j=i;j<M;j++)//{if(page[t].num==p[j].num )break;//页面已经在内存中else count++;}return count;//返回当前页面在未来还要出现的次数}4、测试用例，运行结果与运行情况分析4.1测试用例设计4.1.1用例1设计：内存物理块数：N=3页面引用序列中总页面个数为：m=12页面引用序列为：4、3、2、1、4、3、5、4、3、2、1、54.1.2用例2设计：内存物理块数：N=4页面引用序列中总页面个数为：m=15页面引用序列为：3、7、4、8、3、1、6、7、8、3、1、2、9、3、5 4.2运行结果及运行情况分析4.2.1测试用例1运行结果如下：4.2.1.1 FIFO算法的运行结果：缺页率＝缺页次数/ 总访问次数＝9 / 12＝75%依次淘汰的页面号为：4、3、2、1、4、34.2.1.2 OPT算法的运行结果为：缺页率＝缺页次数/ 总访问次数＝7 / 12＝58.33%依次淘汰的页面号为：2、1、4、24.2.2测试用例2运行结果如下：4.2.2.1 FIFO算法运行结果如下：缺页率＝缺页次数/ 总访问次数＝12/ 15＝80%依次淘汰的页面号为：3、7、4、8、1、6、7、3 4.2.2.2 OPT算法运行结果缺页率＝缺页次数/ 总访问次数＝10/ 15＝66.67%以此淘汰的页面号为：4、1、7、4、2、35、自我评价与总结本周我们进行了《操作系统》的课程设计，在拿到题目以后便着手准备，通过查阅课本和相关的资料，对本次课程设计要实现的功能有了深刻的了解，在此基础上写起实验代码变得心应手。

页面调度算法模拟

页⾯调度算法模拟模拟实现的算法：FIFO，Optimal（最佳置换），LRU，Clock，改进的Clock算法⼀、先⼊先出（FIFO）:最简单的页⾯置换算法是先⼊先出（FIFO）法。

这种算法的实质是，总是选择在主存中停留时间最长（即最⽼）的⼀页置换，即先进⼊内存的页，先退出内存。

理由是：最早调⼊内存的页，其不再被使⽤的可能性⽐刚调⼊内存的可能性⼤。

建⽴⼀个FIFO队列，收容所有在内存中的页。

被置换页⾯总是在队列头上进⾏。

当⼀个页⾯被放⼊内存时，就把它插在队尾上。

这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不⾼。

因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“⽼”⽽不得不被置换出去。

FIFO的另⼀个缺点是，它会产⽣Belady现象,即在增加存储块的情况下，反⽽使缺页中断率增加了。

模拟算法如下：1package paging;23import java.util.LinkedList;45/**6 * FIFO(先进先出)页⾯置换算法7 *8 * @author wz9 * @date 15/11/30.10*/11public class FIFO {12private LinkedList<Integer> memoryBlock;1314void pageReplacement(int[] pageString, int memBlockNum) {15 memoryBlock = new LinkedList<>();16int pageFaultCount = 0, pageReplaceCount = 0;17for (int i = 0; i < pageString.length; i++) {18if (memoryBlock.contains(pageString[i]))19continue;20if (memoryBlock.size() >= memBlockNum) {21 memoryBlock.pollFirst();22// memoryBlock.set(0, pageString[i]);23 pageReplaceCount++;24 }25 memoryBlock.add(pageString[i]);26 pageFaultCount++;27 }28 System.out.println("缺页中断率: "+pageFaultCount/(double)pageString.length);29 System.out.println("页⾯置换次数: "+pageReplaceCount);30 }31 }⼆、Optimal（最佳置换）这是⼀种理想情况下的页⾯置换算法，但实际上是不可能实现的。

opt页面调度算法

opt页面调度算法OPT（最佳置换）页面调度算法是一种页面置换算法，目标是使发生页面缺失的次数最小化。

在OPT算法中，每次发生页面缺失时，选择未来最长时间内不再使用的页面进行置换。

OPT算法的思想是通过预测未来的页面访问情况来优化页面置换。

具体实现步骤如下：1.首先记录页面访问序列。

这可以通过检测进程的访存指令或者通过日志记录来获取。

2.创建一个空的页面表，用于存储当前内存中的页面。

3.依次扫描页面访问序列，对于每个页面访问请求：a.如果该页面已经在页面表中，说明页面已经在内存中，不需要做任何操作。

b.如果页面不在页面表中，说明该页面发生了页面缺失。

c.在页面表中查找空闲的页面框。

如果有空闲页面框，则将页面调入该页面框，更新页面表。

d.如果没有空闲页面框，需要进行页面置换操作。

遍历页面表中的页面框，对于每个页面框，找出未来最长时间内不再使用的页面进行置换。

4.继续处理下一个页面请求，直到所有的页面请求都被处理完毕。

OPT算法的优点是通过最优的置换策略，可以达到最小化页面缺失的目标。

然而，这种算法在实际应用中有一定的局限性：1.预测未来页面访问情况是不可能完全准确的，因此无法实现真正的最佳置换策略。

2.OPT算法需要事先获得完整的页面访问序列，这在实际中是很难实现的。

3.对于具有大量页面的系统，遍历页面表来寻找未来最长时间内不再使用的页面是非常耗时的操作，会导致算法的效率较低。

4.由于OPT算法需要对未来的页面访问进行预测，因此它的实现难度相对较高。

在实际应用中，OPT算法很少直接使用，主要是用作参考和比较其他页面调度算法的性能。

常用的页面调度算法包括FIFO（先进先出）、LRU （最近最少使用）和LFU（最近最少使用）等。

总之，OPT页面调度算法通过预测未来的页面访问情况来优化页面置换策略，以达到最小化页面缺失的目标。

然而，由于预测的不准确性和实现的难度，OPT算法在实际应用中有一定的局限性。

什么是OPT(Optimal)页面调度算法

什么是OPT（Optimal）页面调度算法
OPT（Optimal）页面调度算法是一种理论上的最佳页面调度算法，它基于未来的页面访问序列，选择在未来最长时间内不会被访问的页面进行置换。

其基本思想是找到最佳的置换策略，以最小化页面缺页率。

1. 预测未来页面访问序列：OPT算法需要预测未来的页面访问序列，这是实现OPT算法的难点之一。

通常可以通过统计历史访问序列的频率、利用机器学习算法或者模拟预测等方法来估计未来的页面访问情况。

2. 选择最佳置换页面：根据预测的未来页面访问序列，对于当前需要置换的页面，选择在未来最长时间内不会被访问的页面进行置换。

即选择离当前时间最远的未来访问页面进行置换。

3. 更新页面访问信息：在进行页面置换后，更新页面访问信息，包括页面的访问时间戳、访问频率等信息，以便下一次页面置换时使用。

OPT算法的优点是能够达到最佳的页面置换效果，最小化页面缺页率。

但是，由于需要准确预测未来的页面访问序列，实际中很难完全实现OPT算法。

因此，OPT算法主要用作理论分析的基准，实际系统中常采用近似算法如FIFO、LRU等来进行页面置换。

操作系统_页面置换算法FIFO,OPT,LRU实现

for(intk = 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;
}
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;

opt页面调度算法

Opt页面调度算法1. 简介Opt页面调度算法是一种用于优化页面调度的算法。

页面调度是指操作系统中将内存中的页面（页面是内存中的最小单位）调入或调出物理内存的过程。

Opt算法通过分析页面未来的访问模式，选择最佳的页面替换策略，以提高系统的性能和效率。

2. 页面调度算法的背景在计算机系统中，内存是有限的资源，操作系统需要智能地管理内存，以便为应用程序提供足够的内存空间。

当内存中的页面不足时，操作系统需要选择哪些页面调入内存，哪些页面调出内存。

页面调度算法就是为了解决这个问题而设计的。

3. 页面调度算法的分类页面调度算法可以分为以下几种：3.1 FIFO算法FIFO（First In First Out）算法是最简单的页面调度算法之一。

它的原理是将最早进入内存的页面替换出去。

然而，FIFO算法存在一个问题，即它没有考虑页面的访问模式，可能会导致频繁访问的页面被替换出去，从而降低系统的性能。

3.2 LRU算法LRU（Least Recently Used）算法是一种基于页面访问时间的页面调度算法。

它的原理是将最近最少使用的页面替换出去。

LRU算法考虑了页面的访问模式，相对于FIFO算法，它能够更好地适应应用程序的访问特点，提高系统的性能。

3.3 Opt算法Opt（Optimal）算法是一种理论上最优的页面调度算法。

它的原理是通过分析页面未来的访问模式，选择最佳的页面替换策略。

Opt算法需要预先知道应用程序的访问模式，因此在实际应用中很难实现。

然而，Opt算法可以作为其他页面调度算法的性能参考。

4. Opt算法的实现Opt算法的实现步骤如下：4.1 收集页面访问模式数据为了实现Opt算法，需要预先知道应用程序的访问模式。

可以通过对应用程序的运行进行监测和分析，收集页面访问模式数据。

这些数据可以包括页面的访问频率、访问顺序等信息。

4.2 分析页面访问模式数据通过对页面访问模式数据的分析，可以得出页面的访问规律和趋势。

opt页面调度算法

opt页面调度算法opt页面调度算法是一种常用的页面置换算法，用于解决操作系统中的页面调度问题。

在操作系统中，内存被划分为若干个固定大小的页面，而进程的地址空间也被划分为若干个页面。

当进程需要访问一个页面时，如果该页面已经在内存中，则直接访问；如果该页面不在内存中，则需要将一个页面从内存中换出，然后将需要访问的页面换入内存。

opt页面调度算法的核心思想是根据未来的页面访问情况来进行页面置换。

具体来说，opt算法会预测未来一段时间内每个页面的访问情况，然后选择最长时间内不会被访问的页面进行置换。

这样可以最大程度地减少页面置换的次数，提高系统的性能。

在实际应用中，opt算法需要根据过去的页面访问历史来预测未来的访问情况。

一种常用的方法是通过分析程序的代码和数据结构来预测页面访问模式。

例如，如果一个程序在循环中反复访问同一个页面，那么该页面很可能会在未来的循环中继续被访问。

另外，还可以通过统计页面的访问频率来预测未来的访问情况。

如果一个页面在过去的一段时间内一直没有被访问过，那么它很可能在未来的一段时间内也不会被访问。

然而，opt算法也存在一些问题和局限性。

首先，opt算法需要准确地预测未来的页面访问情况，但是这是一个非常困难的任务。

即使是最先进的预测算法，也无法完全准确地预测未来的访问模式。

其次，opt算法需要维护一个页面访问历史记录，这会占用一定的内存空间。

对于内存有限的系统来说，这可能会导致内存不足的问题。

此外，opt 算法的实现也比较复杂，需要对页面访问历史进行分析和预测，增加了系统的开销。

尽管opt算法存在一些问题，但是在某些特定的场景下，它仍然是一种有效的页面调度算法。

例如，在一些需要高性能和低延迟的应用中，opt算法可以通过减少页面置换的次数来提高系统的响应速度。

此外，opt算法还可以与其他页面调度算法结合使用，以充分发挥各种算法的优势。

总之，opt页面调度算法是一种常用的页面置换算法，通过预测未来的页面访问情况来进行页面置换。

操作系统实验(四)实验报告--虚拟内存

操作系统实验(四)实验报告--虚拟内存操作系统实验（四）虚拟内存1、实验题目页面置换算法模拟——OPT、FIFO和LRU算法2、实验目的了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法，如最佳（Optimal）置换算法、先进先出（Fisrt In First Out）置换算法和最近最久未使用（Least Recently Used）置换算法3、实验内容1）OPT算法：需要发生页面置换时，算法总是选择在将来最不可能访问的页面进行置换。

2）FIFO算法：算法总是选择在队列中等待时间最长的页面进行置换。

3）LRU算法：如果某一个页面被访问了，它很可能还要被访问；相反，如果它长时间不被访问，那么，在最近未来是不大可能被访问的。

4、程序代码#include<iostream>#include <cstdlib>#include <time.h>#include <cstdio>#define L 30///页面走向长度最大为30using namespace std;int M=4; ///内存块struct P///定义一个结构体{int num,time;}p[30];int Input(int m,P p[L])///打印页面走向状态{m=30;int i,j;j=time(NULL);///取时钟时间srand(j);///以时钟时间x为种子，初始化随机数发生器cout<<"页面走向: ";for(i=0; i<m; i++){p[i].num=rand( )%10;///产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;return m;}void print(P *page1)///打印当前的页面{P *page=new P[M];page=page1;for(int i=0; i<M; i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,P *page1 )///寻找内存块中与e相同的块号{P *page=new P[M];page=page1;for(int i=0; i<M; i++)if(e==page[i].num)return i; ///返回i值return -1;}int Max(P *page1)///寻找最近最长未使用的页面用于OPT算法{P *page=new P[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(P *page1,int i,int t,P p[L])///记录当前内存块中页面离下次使用间隔长度用于OPT算法{P *page=new P[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=1;int m=0,t=0;float n=0;///缺页次数m=Input(m,p);///调用input函数，返回m值M=4;P *page=new P[M];///dowhile(c==1||c==2||c==3){int i=0;for(i=0; i<M; i++) ///初试化页面基本情况{page[i].num=0;page[i].time=m-1-i;}cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"3:OPT页面置换"<<endl;cout<<"按其它键结束程序；"<<endl;cin>>c;if(c==1)///FIFO页面置换///FIFO();{n=0;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<<" ="<<n/m<<endl;}if(c==2)///LRU页面置换,最近最久未使用{n=0;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<<" = "<<n/m<<endl;}if(c==3)///OPT页面置换{n=0;cout<<" OPT算法置换情况如下:"<<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<<" = "<<n/m<<endl;}}///while(c==1||c==2||c==3);return 0;}5、心得体会通过该实验，是我对虚拟内存更加了解，对最佳置换算法、先进先出算法、最近最久算法更加了解。

操作系统之页面置换算法（最佳置换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）是淘汰最先进⼊内存的页⾯，即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。

实验3-页面调度算法

实验报告院（系）：专业班级：学号:姓名:实验地点:实验日期:课程名称实验项目名称实验学时实验类型计算机操作系统页面调度算法 2 验证型一、实验目的及要求通过本实验可以加深理解有关虚拟存储器的工作原理，进一步体会和了解页面替换算法的具体实现方法。

二、实验环境PC /Windows系统/Visual C++6.0三、实验内容①实现三种算法：先进先出；OPT；LRU②页面序列从指定的文本文件（TXT文件）中取出③输出：第一行：每次淘汰的页面号，第二行：显示缺页的总次数四、实验步骤1．先进先出(FIFO)置换算法的思路该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序连接成一个队列，并设置一个替换指针，使它总指向最老的页面。

2．最近久未使用(LRU)置换算法的思路最近久未使用置换算法的替换规则，是根据页面调入内存后的使用情况来进行决策的。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。

3.最佳（OPT）置换算法的思路其所选择的被淘汰的页面，将是以后不使用的，或者是在未来时间内不再被访问的页面，采用最佳算法，通常可保证获得最低的缺页率。

4、流程图如下图所示：五、调试过程程序结构分析：程序共有以下九个部分：int findSpace(void);//查找是否有空闲内存int findExist(int curpage);//查找内存中是否有该页面开始取一条指令取指令中访问的页号=>L查页表页标记=1？形成绝对地址是“存”指令？置L 页修改标记“1”输出绝对地址输出“*页号”有后继指令？取一条指令结束J:=P[k]J 页的修改标记输出“OUTj ”输出“INL ”P[k]:=L k:=(k+1) mod m修改页面是否是否否（产生缺页中断）是否int findReplace(void);//查找应予置换的页面void display(void);//显示void FIFO(void);//FIFO算法void LRU(void);//LRU算法void OPT(void);//OPT算法；void BlockClear(void);//BLOCK清空，以便用另一种方法重新演示int main() //主程序六、实验结果及分析程序源代码：#include <iostream.h>#define Bsize 3#define Psize 20struct pageInfor{int content;//页面号int timer;//被访问标记};class PRA{public:PRA(void);int findSpace(void);//查找是否有空闲内存int findExist(int curpage);//查找内存中是否有该页面int findReplace(void);//查找应予置换的页面void display(void);//显示void FIFO(void);//FIFO算法void LRU(void);//LRU算法void Optimal(void);//OPTIMAL算法void BlockClear(void);//BLOCK恢复pageInfor * block;//物理块pageInfor * page;//页面号串private:};PRA::PRA(void){int QString[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};block = new pageInfor[Bsize];for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}page = new pageInfor[Psize];for(i=0; i<Psize; i++){page[i].content = QString[i];page[i].timer = 0;}}int PRA::findSpace(void){for(int i=0; i<Bsize; i++)if(block[i].content == -1)return i;//找到空闲内存，返回BLOCK中位置return -1;}int PRA::findExist(int curpage){for(int i=0; i<Bsize; i++)if(block[i].content == page[curpage].content)return i;//找到内存中有该页面，返回BLOCK中位置return -1;}int PRA::findReplace(void){int pos = 0;for(int i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i;//找到应予置换页面，返回BLOCK中位置return pos;}void PRA::display(void){for(int i=0; i<Bsize; i++)if(block[i].content != -1)cout<<block[i].content<<" "; cout<<endl;}void PRA::Optimal(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){ cout<<"不缺页"<<endl; }else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{for(int k=0; k<Bsize; k++)for(int j=i; j<Psize; j++){if(block[k].content != page[j].content){ block[k].timer = 1000; }//将来不会用，设置TIMER为一个很大数else{block[k].timer = j;break;}}position = findReplace();block[position] = page[i];display();}}}}void PRA::LRU(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;block[exist].timer = -1;//恢复存在的并刚访问过的BLOCK中页面TIMER为-1}else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;}}void PRA::FIFO(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;}else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中所有页面TIMER++ }}void PRA::BlockClear(void){for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}}void main(void){cout<<"|----------页面置换算法----------|"<<endl;cout<<"|---power by kangyan(1318064008)---|"<<endl;cout<<"|-------------------------------------|"<<endl;cout<<"页面号引用串:7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1"<<endl; cout<<"----------------------------------------------------"<<endl;cout<<"选择<1>应用Optimal算法"<<endl;cout<<"选择<2>应用FIFO算法"<<endl;cout<<"选择<3>应用LRU算法"<<endl;cout<<"选择<0>退出"<<endl;int select;PRA test;while(select){cin>>select;switch(select){case 0:break;case 1:cout<<"Optimal算法结果如下:"<<endl;test.Optimal();test.BlockClear();cout<<"----------------------"<<endl;break;case 2:cout<<"FIFO算法结果如下:"<<endl;test.FIFO();test.BlockClear();cout<<"----------------------"<<endl;break;case 3:cout<<"LRU算法结果如下:"<<endl;test.LRU();test.BlockClear();cout<<"----------------------"<<endl;break;default:cout<<"请输入正确功能号"<<endl;break;}}}实验截图如下图所示：<—键入1选择运行LRU算法的置换<—初始化信息：3个页块，20个页面号引用串<—存入前三个页，有空闲内存，无需置换<—3，4页已经在内存中无需再写入<—因为3是最久的页面所以将其置换下面原理相同<—所有命中的页面数<—命中率0.5七、总结页面置换算法的思想可以说比较简单，易懂，但是在实现的时候，也遇到了很多的问题，比如说在找空闲物理块的时候，起初我是比较物理块是否等于0，若为0，则直接把页面放入，后来发现不论什么时候都是把0替换出去，才恍然大悟，既然页面标号有0，就不能用0来表示空闲物理块，后来就换成用-1来表示物理块空闲了。

页面调度算法OPT的模拟实现

页面调度算法模拟实验中遇到的问题

实验6 页面调度算法模拟

OPT、FIFO、LRU算法的实现

操作系统页面置换算法（opt,lru,fifo,clock）实现

页面调度算法(FIFO,LRU,OPT)

实验三 页面调度算法

FIFO LRU OPT页面置换算法的模拟实现(已调试)

操作系统——页面调度算法

请求页式管理缺页中断模拟设计--FIFO、OPT

页面调度算法模拟

opt页面调度算法

什么是OPT(Optimal)页面调度算法

操作系统_页面置换算法FIFO,OPT,LRU实现

opt页面调度算法

opt页面调度算法

操作系统实验(四)实验报告--虚拟内存

操作系统之页面置换算法（最佳置换OPT，先进先出FIFO，最近最久未使用LRU）

实验3-页面调度算法

实验三页面调度算法