计算机操作系统分页算法 FIFO,LRU,OPT的C++实现算法

合集下载

OPT、FIFO、LRU算法的实现

OPT、FIFO、LRU算法的实现⼀、实验⽬的1. 了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中⼏种基本页⾯置换算法的基本思想和实现过程，并⽐较它们的效率。

2. 了解程序设计技术和内存泄露的原因⼆、实验内容模拟实现请求页式存储管理的⼏种基本页⾯置换算法最佳淘汰算法（OPT）先进先出的算法（FIFO）最近最久未使⽤算法（LRU）三、实验原理1. 虚拟存储系统UNIX中，为了提⾼内存利⽤率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进⾏；⼀个进程只需将其⼀部分（段或页）调⼊内存便可运⾏；还⽀持请求调页的存储管理⽅式。

当进程在运⾏中需要访问某部分程序和数据时，发现其所在页⾯不在内存，就⽴即提出请求（向CPU发出缺中断），由系统将其所需页⾯调⼊内存。

这种页⾯调⼊⽅式叫请求调页。

为实现请求调页，核⼼配置了四种数据结构：页表、页框号、访问位、修改位、有效位、保护位等。

2. 页⾯置换算法当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转⼊缺页中断处理程序。

该程序通过查找页表，得到该页所在外存的物理块号。

如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调⼊内存，然后修改页表。

如果内存已满，则须按某种置换算法从内存中选出⼀页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调⼊，修改页表。

利⽤修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。

整个页⾯的调⼊过程对⽤户是透明的。

最佳淘汰算法（OPT）：选择永不使⽤或在未来最长时间内不再被访问的页⾯予以替换。

先进先出的算法（FIFO）：选择在内存中驻留时间最久的页⾯予以替换。

最近最久未使⽤算法（LRU）：选择过去最长时间未被访问的页⾯予以替换。

3. ⾸先⽤srand( )和rand( )函数定义和产⽣指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。

（1）通过随机数产⽣⼀个指令序列，共320条指令。

【算法】页面置换算法FIFO、LRU和LFU的概述以及实现方式

【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式【算法】页⾯置换算法FIFO、LRU和LFU的概述以及实现⽅式页⾯置换算法，我们最常⽤的页⾯置换算法包括FIFO先来先服务，LRU最近最久未被使⽤，LFU最近最少被使⽤以及我们的时钟置换算法。

⼀、FIFO算法——先来先服务1、简述FIFO算法FIFO算法是我们⽐较简单的置换算法，就是先来先服务或者说是先进先出。

也就是说在进⾏页⾯置换的时候，最先来的那个会被最先置换出去。

先进⼊的指令先完成并引退，跟着才执⾏第⼆条指令。

2、FIFO算法的简单实现FIFO算法的简单实现：可以通过维护⼀个链表结构去存储当前调⼊的页⾯；将最先进⼊的页⾯维护在链表的最前，最后进⼊的页⾯维护在链表的最后；这样，当发⽣缺页中断时，需要进⾏置换的时候，淘汰表头的页⾯并将新调⼊的页⾯加到链表的尾部；当然除了链表以外我们还可以采⽤数组或者队列等来进⾏实现。

3、FIFO算法的特点（1）FIFO算法实现简单，易于理解易于编程。

FIFO算法实现简单，⽆须硬件⽀持，只需要⽤循环数组管理物理块即可。

（2）FIFO算法可能会出现Belady现象。

也就是在FIFO算法中，如果未分配够⼀个进程所要求的页⾯，有时就会出现分配的页⾯数增多，却也率反⽽增加Belady现象。

（3）FIFO算法可能会置换调重要的页⾯，其效率不⾼。

（4）在FIFO算法可能中会导致多次的页⾯置换。

当页⾯置换的时间⼤于所要操作的时间的时候，这时候其效率就会很低。

当其不停的进⾏页⾯置换的时候会出现⼤量的系统抖动现象。

⼆、LRU算法——最近最久未被使⽤1、简述LRU算法LRU算法是最近最久未被使⽤的⼀种置换算法。

也就是说LRU是向前查看。

在进⾏页⾯置换的时候，查找到当前最近最久未被使⽤的那个页⾯，将其剔除在内存中，并将新来的页⾯加载进来。

2、LRU算法的实现LRU的实现就相对于FIFO的实现复杂⼀点。

我们可以采⽤哈希映射和链表相结合。

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

操作系统页⾯置换算法（opt,lru,fifo,clock ）实现选择调出页⾯的算法就称为页⾯置换算法。

好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。

常见的置换算法有以下四种（以下来⾃操作系统课本）。

1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。

但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的，因⽽该算法⽆法实现。

最佳置换算法可以⽤来评价其他算法。

假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串： 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时，先将7, 0, 1三个页⾯依次装⼊内存。

进程要访问页⾯2时，产⽣缺页中断，根据最佳置换算法，选择第18次访问才需调⼊的页⾯7予以淘汰。

然后，访问页⾯0时，因为已在内存中所以不必产⽣缺页中断。

访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推，如图3-26所⽰。

从图中可以看出⾤⽤最佳置换算法时的情况。

可以看到，发⽣缺页中断的次数为9，页⾯置换的次数为6。

图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。

该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。

但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。

图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例，⾤⽤FIFO 算法进⾏页⾯置换。

进程访问页⾯2时，把最早进⼊内存的页⾯7换出。

然后访问页⾯3时，再把2, 0, 1中最先进⼊内存的页换出。

三种页面置换算法-(FIFO-LRU-OPT)

{
p[j].blocknum=b[i].num;
p[j].state=1;
b[i].pagenum=p[j].num;
b[i].state=1;
b[i].age=p[j].age;
break;
}
{
if (p[mm].num==b[mn].pagenum)
{
k=mn;
break;
}
}
b[mn].pagenum=p[j].num;
b[mn].age=0;
p[j].blocknum=b[mn].num;
for (j1=mn+1;j1<=j-1;j1++)
{
if(p[mn].num==p[j1].num)
{
num--;
}
}
}
if (num==n)
{
b[i].state=1;
break;
}
}
if(i>=n)
{
for (mn=j-1;mn>=0;mn--)
{
if(num<n)
{
num++;
#include<iostream>
#include<malloc.h>
using namespace std;
#define M 9
#define N 20
typedef struct node1/*页面的数据结构*/
{
int num;
int age;
int state;
if(chose==1)

页式虚拟存储管理FIFO、LRU和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,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和OPTIMAL置换算法,操作系统实验vc2010代码

实验报告4课程计算机操作系统实验名称分页式存储管理第 1 页班级11计本学号105032011130 姓名风律澈实验日期：2013年12月10日报告退发(订正、重做)一、实验目的通过编写分页式存储管理的模拟程序，加深对页式存储管理方式的理解，熟悉逻辑地址到物理地址的转换过程，掌握虚拟存储管理中的页面调度算法，认识分页式虚拟存储系统中缺页中断的处理过程。

二、实验内容1、设计一个分页式虚拟存储系统，用程序模拟实现，假设页面大小为1K，每个作业分配三个块。

2、页面调度分别采用FIFO调度算法和最佳置换算法。

（淘汰页面时直接将该页面从内存中直接淘汰，不考虑该页面是否被修改，是34、假设逻辑指令格式为：操作符页号1 页内地址1 页号2 页内地址2表示将页面1内地址为011单元的内容和页面2中地址为051的单元的内容相加。

5面调度算法，淘汰相应页。

6、要求每执行上述指令流中的一条逻辑指令，输出相应的物理指令，若页表有修改，则显示修改后的页表。

三、实验过程 //way.h// // //数据类型定义 // /******页表定义*******/ typedef struct{ int pagenumber; int mark;int blocknumber; int modify;string location; }_pagetable;/****操作序列定义*****/typedef struct{string operate;int page_number1;string page1_interaddress;int page_number2;string page2_interaddress;}_order;/****修改次数跟踪定义*****/int k=1;/****使用何种算法表示量****/int fifo_or_optimal=1;/****FIFO需求定义*****/int old=0;//指向先入页号的指针int list[3]={0,1,2};//预设先入队列/****optmal需求定义*****/int find=0;int chose[3]={0,1,2};// ////关键函数 ///****输出整个页表信息*****/void coutpagetable(_pagetable pagetable[6]){cout<<"页号"<<" "<<"标志"<<" "<<"主存块号";cout<<" "<<"修改标志"<<" "<<"磁盘位置"<<endl;for(int i=0;i<6;i++){cout<<pagetable[i].pagenumber;cout<<" "<<pagetable[i].mark;cout<<" "<<pagetable[i].blocknumber;cout<<" "<<pagetable[i].modify;cout<<" "<<pagetable[i].location;cout<<endl;}}/****修改表格*****/void modifypagetable(int i,int j,_pagetable pagetable[6]){ pagetable[i].mark=1;pagetable[i].modify=k;pagetable[i].blocknumber=pagetable[j].blocknumber;pagetable[j].location=pagetable[i].location;pagetable[i].location="NULL";pagetable[j].blocknumber=-1;pagetable[j].modify=k;pagetable[j].mark=0;coutpagetable(pagetable);}/****FIFO算法*****/void FIFO(int i,_pagetable pagetable[6]){/******表格的相关修改********/modifypagetable(i,list[old],pagetable);/*******跟踪数据的修改******/k++;list[old]=i;//先入队列修改if(old!=2)//使old始终指向最先使用的页号old++;elseold=0;}/***与chose中的页表号进行匹配********/void compare_chose(int i){for(int j=0;j<3;j++){if(i==chose[j])find=j;}}/*****更新最近不使用块next算法******/void reflesh_find(int i,_order order[5],int type){ if(type=1)compare_chose(order[i].page_number2);for(i=i+1;i<5;i++){compare_chose(order[i].page_number1);compare_chose(order[i].page_number2);}}/*****optimal算法****/void optimal(int i,_pagetable pagetable[6]){modifypagetable(i,chose[find],pagetable);k++;chose[find]=i;find=0;}/****获取块号函数*****/int getblocknumber(int pagenumber,_pagetable pagetable[6]){ int i=pagenumber;if(pagetable[i].mark==1)//如果信息在内存内，直接获取块号return pagetable[i].blocknumber;else{//否则使用置换算法if(fifo_or_optimal==1)FIFO(i,pagetable);else if(fifo_or_optimal==2)optimal(i,pagetable);elsecout<<"wrong input!=.="<<endl;return pagetable[i].blocknumber;}}/****模拟执行置换算法*****/void carryout(int i,_order order[5],_pagetable pagetable[6]){ /****i1为第一对象块号，i2为第二对象块号*****/reflesh_find(i,order,1);int i1=getblocknumber(order[i].page_number1,pagetable);reflesh_find(i,order,2);int i2=getblocknumber(order[i].page_number2,pagetable);/****输出。

页面调度算法(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;

操作系统课程设计-页面置换算法C语言

页面置换算法一．题目要求：通过实现页面置换算法的FIFO和LRU两种算法，理解进程运行时系统是怎样选择换出页面的，对于两种不同的算法各自的优缺点是哪些。

要求设计主界面以灵活选择某算法，且以下算法都要实现1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。

2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。

4) 最不经常使用算法(LFU)二．实验目的：1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。

2、熟悉内存分页管理策略。

3、了解页面置换的算法。

4、掌握一般常用的调度算法。

5、根据方案使算法得以模拟实现。

6、锻炼知识的运用能力和实践能力。

三、设计要求1、编写算法，实现页面置换算法FIFO、LRU；2、针对内存地址引用串，运行页面置换算法进行页面置换；3、算法所需的各种参数由输入产生（手工输入或者随机数产生）；4、输出内存驻留的页面集合，页错误次数以及页错误率；四．相关知识：1．虚拟存储器的引入：局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。

2．虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。

3．虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。

请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。

4．页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。

按比例分配算法，根据进程的大小按比例分配物理块。

考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。

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;}。

操作系统：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,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;

计算机操作系统分页算法FIFO,LRU,OPT的C++实现算法

计算机操作系统分页算法FIFO,LRU,OPT的C++实现算法#include#include#includeusing namespace std;int pagenum=0; ///内存的页数int total=0; ///要访问的叶面总数int lacknumber=0; ///缺页的总数void main(){int array[20];int a[2][20];int value;char sequence[255];cout<<"请选择算法 1--FIFO，2--LRU，3--OPT\n"; cin>>value;cout<<"请输入页数:";cin>>pagenum;cout<<"请输入页面的字符串(最多可以输入255个):"; cin>>sequence;int total=strlen(sequence);switch(value){case 1:{int kk=0;for(int i=0;i<total;i++){int flag=0;for(int k=0;k<pagenum;k++){if(array[k]==sequence[i]){flag=1;break;}}if(flag==0){int tem=array[kk];array[kk]=sequence[i];kk++;lacknumber++; //缺页数if(kk==pagenum){kk=0;}}}cout<<"FIFO算法下的缺页率="<<lacknumber<<" "<<total<<"="<<float(lacknumber)/float(total)<<endl; bre ak; } default: {cout<<" break;}}}</lacknumber<<"></pagenum;k++)</total;i++)。

操作系统—页面置换算法实验报告

操作系统—页面置换算法实验报告本报告旨在介绍操作系统中的页面置换算法，包括实验的目的和背景以及页面置换算法的概念和作用。

本实验旨在描述实验环境以及所使用的页面置换算法，包括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

FIFO调度算法的实现======================================================================= //1：访问内存//如果在内存，输出//如果不在内存，判断内存是否已满//如果满了，将第一个元素挤出，其他元素迁移，再把访问的元素放入队尾//再将内存中的元素输出//如果没满，找到第一个内存空快，并把元素放入该空快，跳出//输出内存中的元素import java.util.*;public class fifo {private static final String end = null;int[] page;int[] ram;float shoot_rate=1;int shoot=0;int visits;//定义访问次数public void initpages(int a)//初始化页面{t his.page=new int[a];for(int i=0;i<a;i++){page[i]=i;}}////////////////////////////////////public void intram(int a)//初始化内存{t his.ram =new int[a];f or(int i=0; i<a; i++){ram[i]=-1;}}///////////////////////////////////public void visitpage(int a)// 访问内存中的页面{if (a>=0&&a<page.length)//判断输入的页面号范围{visits++;i nt exit_element;f or(int i=0;i<=ram.length-1;i++){exit_element=ram[i];//////if (exit_element==a)//内存中存在访问的页面{System.out.print("命中 ");shoot++;for(int j=0;j<=ram.length-1; j++)//输出内存中的页面{if (ram[j]==-1){System.out.print(" null");}elseSystem.out.print(" "+ram[j]);//输出内存中的页面 }break;//跳出循环体，visitpage结束}/////else if(i==ram.length-1&& ram[i]==-1)//内存未满{for(int r=0;r<=ram.length-1;r++){if (ram[r]==-1){ram[r]=a;//将页面调入第一个空内存块break;//跳出}}System.out.print("未命中");for(int j=0;j<=ram.length-1; j++)//输出内存中的页面{if(ram[j]==-1){System.out.print(" null");}elseSystem.out.print(" "+ram[j]);//输出内存中的页面}}//////else if(i==ram.length-1&& ram[i]!=-1)//内存已满{for(int j=0;j<ram.length-1;j++)//先进先出置换{ram[j]=ram[j+1];}ram[ram.length-1]=a; //页面调入内存System.out.print("未命中");f or(int r=0; r<=ram.length-1;r++)//输出内存页面中的{System.out.print(" "+ram[r]);}b reak; //跳出循环体，visitpage结束}/////////////else{}}}//访问页面越界else{System.out.println("\n 页面访问不存在！");}shoot_rate=((float)shoot/(float)visits)*100;System.out.println();System.out.println("访问页面次数为："+visits);System.out.println("命中次数为："+shoot+"次");System.out.println("命中率为："+shoot_rate+"%"); }public static void main(String[] args){fifo jhy = new fifo();int page;int ramnumber;int visit_pagenumber;System.out.println("请输入页面数：");Scanner input1 = new Scanner(System.in);page=input1.nextInt();jhy.initpages(page);System.out.println("请输入内存块的个数：");Scanner input2 = new Scanner(System.in);ramnumber=input2.nextInt();jhy.intram(ramnumber);while(1==1){System.out.println("\n 请输入访问的页面号");Scanner input3 =new Scanner(System.in);visit_pagenumber=input3.nextInt();jhy.visitpage(visit_pagenumber);}}}LRU调度算法的实现//1：访问内存//如果在内存，将它后面的非空块的值往前移，它放入最后一个非空块，再输出//如果不在内存，判断内存是否已满//如果满了，将第一个元素挤出，其他元素迁移，再把访问的元素放入队尾//再将内存中的元素输出//如果没满，找到第一个内存空快，并把元素放入该空快，跳出//输出内存中的元素import java.util.*;public class lru {private static final String end = null;int[] page;int[] ram;int shoot=0;float shoot_rate=1;int visits;//定义访问次数public void initpages(int a)//初始化页面{t his.page=new int[a];for(int i=0;i<a;i++){page[i]=i;}}////////////////////////////////////public void intram(int a)//初始化内存{t his.ram =new int[a];f or(int i=0; i<a; i++){ram[i]=-1;}}///////////////////////////////////public void visitpage(int a)// 访问内存中的页面{if (a>=0&&a<page.length)//判断输入的页面号范围{visits++;i nt exit_element;f or(int i=0;i<=ram.length-1;i++){exit_element=ram[i];//////if (exit_element==a)//内存中存在访问的页面{System.out.print("命中 ");shoot++;int r=i;if(ram[ram.length-1]==-1)//内存没满，进入，找到最后一个非空的元素的下标{while(ram[r]!=-1 && r<ram.length-1){r++; //r 为第一个非空内存块的下标+1}}else{w hile(r<ram.length)r++; //r 为第一个非空内存块的下标+1}int k=r;for(int j=i;j<k-1;j++)//Lru移位{ram[j]=ram[j+1];}ram[r-1]=a;for(int j=0;j<=ram.length-1; j++)//输出内存中的页面{if (ram[j]==-1){System.out.print(" null");}elseSystem.out.print(" "+ram[j]);//输出内存中的页面 }break;//跳出循环体，visitpage结束}/////else if(i==ram.length-1&& ram[i]==-1)//内存未满{for(int r=0;r<=ram.length-1;r++){if (ram[r]==-1){ram[r]=a;//将页面调入第一个空内存块break;//跳出}}System.out.print("未命中");for(int j=0;j<=ram.length-1; j++)//输出内存中的页面 {if(ram[j]==-1){System.out.print(" null");}elseSystem.out.print(" "+ram[j]);//输出内存中的页面 }}//////else if(i==ram.length-1&& ram[i]!=-1)//内存已满{System.out.print("未命中");for(int j=0;j<ram.length-1;j++)//Lru置换{ram[j]=ram[j+1];}ram[ram.length-1]=a; //页面调入内存f or(int r=0; r<=ram.length-1;r++)//输出内存页面中的{System.out.print(" "+ram[r]);}b reak; //跳出循环体，visitpage结束}/////////////else{}}}//访问页面越界else{System.out.println("\n 页面访问不存在！");}shoot_rate=((float)shoot/(float)visits)*100;System.out.println();System.out.println("访问页面次数为："+visits);System.out.println("命中次数为："+shoot+"次");System.out.println("命中率为："+shoot_rate+"%");}public static void main(String[] args){lru jhy = new lru();int page;int ramnumber;int visit_pagenumber;System.out.println("请输入页面数：");Scanner input1 = new Scanner(System.in);page=input1.nextInt();jhy.initpages(page);System.out.println("请输入内存块的个数：");Scanner input2 = new Scanner(System.in);ramnumber=input2.nextInt();jhy.intram(ramnumber);while(1==1){System.out.println("\n 请输入访问的页面号");Scanner input3 =new Scanner(System.in);visit_pagenumber=input3.nextInt();jhy.visitpage(visit_pagenumber);}}/* 1：判断页面是否越界，如果越界，跳出循环，否则进入2* 2：判断页面是否在内存，如果在，直接输出。

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

fifolrunruoptc算法计算机操作系统

fifolrunruoptc算法计算机操作系统#include"stdio.h"#include"stdlib.h"#include"time.h"#define M 4#define MAX 1000typedef struct page{int num;}Page;Page y[10];typedef struct paage{int num;int time;}Paage;Paage x[10];int GetMax(paage *x) /*求出那个物理块中的页面呆的时间最长，返回物理块号*/{int i;int max=-1;int tag=0;for(i=0;i<m;i++){if(x[i].time>max){ max=x[i].time;tag=i;}}return tag;}int _0bijiao(int i,int gongyou,int *fangwen,page *y) {int k;for(k=i;k<gongyou;k++){if(y[0].num==fangwen[k+1]){return k+1-i;}}return MAX;}int _1bijiao(int i,int gongyou,int *fangwen,page *y) {int k;for(k=i;k<gongyou;k++){if(y[1].num==fangwen[k+1]){return k+1-i;}}return MAX;}int _2bijiao(int i,int gongyou,int *fangwen,page *y) {int k;for(k=i;k<gongyou;k++){if(y[2].num==fangwen[k+1]){return k+1-i;}}return MAX;}int _3bijiao(int i,int gongyou,int *fangwen,page *y){int k;for(k=i;k<gongyou;k++){if(y[3].num==fangwen[k+1]){return k+1-i;}}return MAX;}void FIFO(){int fangwen[100],fangwenshu,i=0;int mem[M+1]={0,0,0,0,0};int q,table[M][100],Fqueyeshu=0;char flag,f[100];printf("请输入要用算法FIFO访问的页面，输入0时结束\n"); scanf("%d",&fangwenshu);while(fangwenshu!=0){fangwen[i]=fangwenshu;i++;scanf("%d",&fangwenshu);}int Fgongyou = i;for(int j=0;j<fgongyou;j++){q = 0;while((fangwen[j]!=mem[q])&&(q!=M)){q++;}if(q==M){flag='*';Fqueyeshu++;}else{flag=' ';}if(flag=='*'){for(int n=M-1;n>0;n--){mem[n]=mem[n-1];}mem[0]=fangwen[j];}for(int m=0;m<m;m++){table[m][j]=mem[m];}f[j]=flag;}printf("FIFO算法的输出结果为下表（0代表为空，*代表有缺页）：\n");for(int w=0;w<m;w++){for(int e=0;e<fgongyou;e++)printf("%3d",table[w][e]);printf("\n");}for(int r=0;r<fgongyou;r++)printf("%3c",f[r]);printf("\n");float Fqueyelv=(float)Fqueyeshu/Fgongyou;printf("FIFO算法的缺页率为：%f",Fqueyelv);printf("\n");}void LRU(){int fangwenshu;int i=0;int fangwen[100];int gongyou;int table[M][100];int queyeshu=0;char f[100];printf("请输入用LRU算法访问页面序列,当输入0时结束\n");scanf("%d",&fangwenshu);while(fangwenshu!=0){fangwen[i]=fangwenshu;i++;scanf("%d",&fangwenshu);}gongyou = i;int</fgongyou;r++)</fgongyou;e++)</m;w++)</m;m++)</fgongyou;j++)</gongyou;k++)</gongyou;k++)</gongyou;k++)</gongyou;k++)</m;i++)ii,j,u;int m;for(ii=0;ii<m;ii++){x[ii].time=0;x[ii].num=0;//初始化页面的时间和存的数}x[0].num = fangwen[0];x[0].time = 1;for(m=0;m<m;m++){table[m][0]=x[m].num;}f[0]='*';queyeshu++;for(ii=1;ii<gongyou;ii++){u=0;for(j=0;j<m;j++)if(x[j].num==fangwen[ii])//物理块中存在相同页面{x[j].time=0;u=1;f[ii]=' ';for(m=0;m<m;m++){table[m][ii]=x[m].num;}break;}if(u!=1&&x[M-1].num!=0)//物理块中无相同且物理块已满{j=GetMax(x);x[j].num=fangwen[ii];f[ii]='*';queyeshu++;for(m=0;m<m;m++){table[m][ii]=x[m].num;}x[j].time=0;}if(u!=1&&x[M-1].num==0){for(j=0;j<m;j++){if(x[j].num==0){x[j].num=fangwen[ii];f[ii]='*';queyeshu++;for(m=0;m<m;m++){table[m][ii]=x[m].num;}break;}}}for(j=0;j<m;j++){if(x[j].num!=0){x[j].time++;}}}printf("LRU算法的输出结果为下表（0代表为空，*代表有缺页）：\n");for(int n=0;n<m;n++){for(int b=0;b<gongyou;b++)printf("%3d",table[n][b]);printf("\n");}for(int w=0;w<gongyou;w++)printf("%3c",f[w]);printf("\n");float queyelv=(float)queyeshu/gongyou;printf("LRU算法的缺页率为：%f",queyelv);printf("\n");}void Optimal(){int i=0;int Oqueyeshu=0;int fangwenshu;int fangwen[100];int gongyou;int table[M][100];char f[100];printf("请输入用Optimal算法访问页面序列,当输入0时结束\n"); scanf("%d",&fangwenshu);while(fangwenshu!=0){fangwen[i]=fangwenshu;i++;scanf("%d",&fangwenshu);}gongyou = i;int ii,j,u;int m;for(ii=0;ii<m;ii++){y[ii].num=0;//初始化页面的存的数}y[0].num = fangwen[0];for(m=0;m<m;m++){table[m][0]=y[m].num;}f[0]='*';Oqueyeshu++;for(ii=1;ii<gongyou;ii++){u=0;for(j=0;j<m;j++)if(y[j].num==fangwen[ii])//物理块中存在相同页面{u=1;f[ii]=' ';for(m=0;m<m;m++){table[m][ii]=y[m].num;}break;}if(u!=1&&y[M-1].num==0)//无相等的且未满{for(j=0;j<m;j++){if(y[j].num==0){y[j].num=fangwen[ii];f[ii]='*';Oqueyeshu++;for(m=0;m<m;m++){table[m][ii]=y[m].num;}break;}}}if(u!=1&&y[M-1].num!=0)//物理块中无相同且物理块已满{int cunchufanhui[4];int _0f;int _1f;int _2f;int _3f;int max=0;int zuida=-1;_0f = _0bijiao(ii,gongyou,fangwen,y); _1f = _1bijiao(ii,gongyou,fangwen,y); _2f = _2bijiao(ii,gongyou,fangwen,y); _3f = _3bijiao(ii,gongyou,fangwen,y); cunchufanhui[0] = _0f; cunchufanhui[1] = _1f; cunchufanhui[2] = _2f; cunchufanhui[3]</m;m++)</m;j++)</m;m++)</m;j++)</gongyou;ii++)</m;m++)</m;ii++)</gongyou;w++)</gongyou;b++)</m;n++)</m;j++)</m;m++)</m;j++)</m;m++)</m;m++)</m;j++)</gongyou;ii++)</m;m++)</m;ii++)= _3f;for(m=0;m<m;m++){if(max<cunchufanhui[m]){max = cunchufanhui[m];zuida++;}}y[zuida].num=fangwen[ii];f[ii]='*';Oqueyeshu++;for(m=0;m<m;m++){table[m][ii]=y[m].num;}}}printf("Optimal算法的输出结果为下表（0代表为空，*代表有缺页）：\n");for(int n=0;n<m;n++){for(int b=0;b<gongyou;b++)printf("%3d",table[n][b]);printf("\n");}for(int w=0;w<gongyou;w++)printf("%3c",f[w]);printf("\n");float queyelv=(float)Oqueyeshu/gongyou; printf("Optimal算法的缺页率为：%f",queyelv); printf("\n");}void print(){printf("-----1:FIFO算法------\n");printf("-----2:LRU算法-------\n");printf("-----3:OPtimal算法---\n");printf("-----0:退出----------\n");}void main(){int xuanze;print();while(1){printf("请输入选择\n"); scanf("%d",&xuanze); switch(xuanze){case 1:FIFO();break; case 2:LRU();break; case 3:Optimal();break; case 0:break;}}}</gongyou;w++)</gongyou;b++)</m;n++)</m;m++)</cunchufanhui[m]) </m;m++)。

OPT,LRU,FIFO

Opt算法函数部分：metathesis=true,space=true;str="";for(int i=phisical_size-1;i>=0;i--){phi[i]=-1; //设置数组初值为-1priority[i]=-1; //设置数组初值为-1，记录装入主存的页面与下次需要使用相隔的页数}for(int z=1;z<=phisical_size;z++){str+="页块";itoa(z,CSnum,10);str+=CSnum;str+=" ";}str+="有无中断页面置换形式";m_display.InsertString(m_display.GetCount(),str);for(i=0;i<point_array;i++){metathesis=true;for(int j=0;metathesis && j<phisical_size;j++){if(addr[i]==phi[j]){metathesis=false;memo=" ";for(z=0;z<phisical_size;z++){if(phi[z]==-1) //无中断且有空页面，空页面处输出空格memo+=" ";else //无中断不为空页面{itoa(phi[z],CSnum,10);memo+=CSnum;memo+=" ";}}m_display.InsertString(m_display.GetCount(),memo);}}if(metathesis) //有中断{if(space) //有空页面，插入页面中断{int m;for(z=0;z<phisical_size;z++){if(priority[z]==-1){for(int k=i+1;k<point_array;k++)if(addr[i]==addr[k])priority[z]=k-i+1;if(k==point_array) priority[z]=point_array;phi[z]=addr[i];m=z;z=phisical_size;}elsepriority[z]-=1; //计算出该页面下次使用相隔的页面数}if(priority[phisical_size-1]!=-1) space=false; //最后一个页面不空，则无空页面memo=" ";for(z=0;z<phisical_size;z++){ itoa(phi[z],CSnum,10);if(m<z) memo+=" ";else memo+=CSnum;memo+=" ";}memo+=" √插入页面";num_fail++;m_display.InsertString(m_display.GetCount(),memo);}else //无空页面，替换页面中断{ int pp=priority[0],temp=0;for(z=1;z<phisical_size;z++)//找到未来最久不使用的页面if(priority[z]>pp){ pp=priority[z];temp=z;}for(z=0;z<phisical_size;z++){ if(z==temp){ phi[temp]=addr[i];for(int k=i+1;k<point_array;k++)if(addr[i]==addr[k])priority[temp]=k-i+1;if(k==point_array) priority[temp]=point_array;}elsepriority[z]-=1;}memo=" ";for(z=0;z<phisical_size;z++){itoa(phi[z],CSnum,10);memo+=CSnum;memo+=" ";}memo+=" √替换页面";num_fail++;m_display.InsertString(m_display.GetCount(),memo);}}}LRU算法核心部分：for(i=0;i<point_array;i++){metathesis=true;for(int j=0;metathesis && j<phisical_size;j++){if(addr[i]==phi[j]){metathesis=false;for(z=0;z<phisical_size;z++)if(priority[z]>priority[j])priority[z]-=1;priority[j]=phisical_size;memo=" ";for(z=0;z<phisical_size;z++){if(phi[z]==-1) //无中断且有空页面，空页面处输出空格memo+=" ";else //无中断不为空页面{itoa(phi[z],CSnum,10);memo+=CSnum;memo+=" ";}}m_display.InsertString(m_display.GetCount(),memo);}}if(metathesis) //有中断{if(space) //有空页面，插入页面中断{int m;for(z=0;z<phisical_size;z++){if(priority[z]==0){priority[z]=phisical_size;phi[z]=addr[i];m=z;z=phisical_size;}elsepriority[z]-=1;}if(priority[phisical_size-1]!=0) space=false; //最后一个页面不空，则无空页面memo=" ";for(z=0;z<phisical_size;z++){itoa(phi[z],CSnum,10);if(m<z) memo+=" ";else memo+=CSnum;memo+=" ";}memo+=" √插入页面";num_fail++;m_display.InsertString(m_display.GetCount(),memo);}else //无空页面，替换页面中断{for(z=0;z<phisical_size;z++){if(priority[z]==1){priority[z]=phisical_size;phi[z]=addr[i];}elsepriority[z]-=1;}memo=" ";for(z=0;z<phisical_size;z++){itoa(phi[z],CSnum,10);memo+=CSnum;memo+=" ";}memo+=" √替换页面";num_fail++;m_display.InsertString(m_display.GetCount(),memo);}}}FIFO核心算法部分：for(int i=phisical_size-1;i>=0;i--){phi[i]=-1; //设置数组初值为-1priority[i]=0; //设置数组优先级为0 }for(int z=1;z<=phisical_size;z++){str+="页块";itoa(z,CSnum,10);str+=CSnum;str+=" ";}str+="有无中断页面置换形式";m_display.InsertString(m_display.GetCount(),str);for(i=0;i<point_array;i++){metathesis=true;for(int j=0;metathesis && j<phisical_size;j++){if(addr[i]==phi[j]){metathesis=false;memo=" ";for(z=0;z<phisical_size;z++){if(phi[z]==-1) //无中断且有空页面，空页面处输出空格memo+=" ";else //无中断{itoa(phi[z],CSnum,10);memo+=CSnum;memo+=" ";}}m_display.InsertString(m_display.GetCount(),memo);}}if(metathesis) //有中断{if(space) //有空页面，插入页面中断{int m;for(z=0;z<phisical_size;z++){if(priority[z]==0){priority[z]=phisical_size;phi[z]=addr[i];m=z;z=phisical_size;}elsepriority[z]-=1;}if(priority[phisical_size-1]!=0) space=false; //最后一个页面不空，则无空页面memo=" ";for(z=0;z<phisical_size;z++){itoa(phi[z],CSnum,10);if(m<z) memo+=" ";else memo+=CSnum;memo+=" ";}memo+=" √插入页面";num_fail++;m_display.InsertString(m_display.GetCount(),memo); }else //无空页面，替换页面中断{for(z=0;z<phisical_size;z++){if(priority[z]==1){priority[z]=phisical_size;phi[z]=addr[i];}elsepriority[z]-=1;}memo=" ";for(z=0;z<phisical_size;z++){itoa(phi[z],CSnum,10);memo+=CSnum;memo+=" ";}memo+=" √替换页面";num_fail++;。