操作系统页面置换-最近最少使用(LRU)算法模拟
- 格式:doc
- 大小:34.00 KB
- 文档页数:4
实验五. 请求页式存储管理的模拟[实验内容]:熟悉虚拟存储管理的各种页面置换算法,并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法(LRU),要求在每次产生置换时显示页面分配状态和缺页率。
[实验要求]:1、运行给出的实验程序,查看执行情况,进而分析算法的执行过程,在理解FIFO页面置换算法和最近最久未使用算法(LRU)置换算法后,给出最佳置换算法的模拟程序实现,并集成到参考程序中。
2、执行2个页面置换模拟程序,分析缺页率的情况。
最好页框数和访问序列长度可调节,在使用同一组访问序列数据的情况下,改变页框数并执行2个页面置换模拟程序,查看缺页率的变化。
3、在每次产生置换时要求显示分配状态和缺页率。
程序的地址访问序列通过随机数产生,要求具有足够的长度。
最好页框数和访问序列长度可调节。
实验的执行结果如下图所示(左下图为FIFO执行结果,右下图为LRU执行结果):程序源代码:#include <libio.h>#include "windows.h"#include <conio.h>#include <stdlib.h>#include <fstream.h>#include <io.h>#include <string.h>#include <stdio.h>void initialize(); //初始化相关数据结构void createps(); //随机生成访问序列void displayinfo(); //显示当前状态及缺页情况void fifo(); //先进先出算法int findpage(); //查找页面是否在内存void lru(); //最近最久未使用算法int invalidcount = 0; // 缺页次数int vpoint; //页面访问指针int pageframe[10]; // 分配的页框int pagehistory[10]; //记录页框中数据的访问历史int rpoint; //页面替换指针int inpflag; //缺页标志,0为不缺页,1为缺页struct PageInfo //页面信息结构{int serial[100]; // 模拟的最大访问页面数,实际控制在20以上int flag; // 标志位,0表示无页面访问数据int diseffect; // 缺页次数int total_pf; // 分配的页框数int total_pn; // 访问页面序列长度} pf_info;//////////////////////////////////////////////////////////////////////// //初始化相关数据结构void initialize(){int i,pf;inpflag=0; //缺页标志,0为不缺页,1为缺页pf_info.diseffect =0; // 缺页次数pf_info.flag =0; // 标志位,0表示无页面访问数据printf("\n请输入要分配的页框数:"); // 自定义分配的页框数scanf("%d",&pf);pf_info.total_pf =pf;for(i=0;i<100;i++) // 清空页面序列{pf_info.serial[i]=-1;}///////////////////////////////////////////////////////////////////// 随机生成访问序列void createps(void ){int s,i,pn;initialize(); //初始化相关数据结构printf("\n请输入要随机生成访问序列的长度:"); //自定义随机生成访问序列的长度scanf("%d",&pn);srand(rand()); //初始化随机数队列的"种子"s=((float) rand() / 32767) * 50 + pn; // 随机产生页面序列长度pf_info.total_pn = s;for(i=0;i<s;i++) //产生随机访问序列{pf_info.serial[i]=((float) rand() / 32767) * 16 ; //随机数的大小在0-15之间 }}////////////////////////////////////////////////////////////////////////// 显示当前状态及缺页情况void displayinfo(void){int i,n;if(vpoint==0){printf("\n=============页面访问序列=============\n");for(i=0; i<pf_info.total_pn; i++){printf("%4d",pf_info.serial[i]);if ((i+1) % 10 ==0) printf("\n"); //每行显示10个}printf("\n======================================\n");}printf("访问%3d : 内存<",pf_info.serial[vpoint]);for(n=0;n<pf_info.total_pf;n++) // 页框信息{if (pageframe[n] >=0)printf("%3d",pageframe[n]);elseprintf(" ");}printf(" >");if(inpflag==1) //缺页标志,0为不缺页,1为缺页{printf(" ==>缺页 ");printf("缺页率%3.1f",(float)(pf_info.diseffect)*100.00/vpoint);}printf("\n");}//////////////////////////////////////////////////////////////////////// // 查找页面是否在内存,1为在内存,0为不在即缺页int findpage(int page){int n;for(n=0;n<pf_info.total_pf;n++){pagehistory[n] ++; // 访问历史加1}for(n=0;n<pf_info.total_pf;n++){if (pageframe[n]==page ){inpflag=0 ; //inpflag缺页标志,0为不缺页,1为缺页pagehistory[n]=0; //置访问历史为0return 1;}}inpflag=1; //页面不存在,缺页return 0;}//////////////////////////////////////////////////////////////////////// // FIFO页面置换算法void fifo(void){int n,count,pstate;rpoint=0; // 页面替换指针初始化为0invalidcount = 0; // 缺页数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满是所有的页框for(n=0;n<pf_info.total_pf;n++) // 清除页框信息{pageframe[n]=-1;}inpflag=0; //缺页标志,0为不缺页,1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0) // 页不存在则置换页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;pf_info.diseffect++; // 缺页次数加1}}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束getch();return;}///////////////////////////////////////////////////////////////////// LRU页面置换算法void lru(void){int n,count,pstate,max;rpoint=0; // 页面替换指针invalidcount = 0; // 缺页次数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满所有的页框for(n=0;n<pf_info.total_pf;n++){pageframe[n]=-1; // 清除页框信息pagehistory[n]=0; // 清除页框历史}inpflag=0; //缺页标志,0为不缺页,1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint]; //把要调入的页面放入一个空的页框里rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0)// 页不存在则置换页面{max=0;for(n=1;n<pf_info.total_pf;n++){if(pagehistory[n]>pagehistory[max]){max=n;}}rpoint=max;pageframe[rpoint]=pf_info.serial[vpoint];pagehistory[rpoint]=0;pf_info.diseffect++; // 缺页次数加1}}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}/////////////////////最佳置换算法自己完成///////////////////////////////////////////////////////////////////// 主函数int main(){char ch;system("cls") ;while ( true ){printf("*******************************************\n");printf(" 若要执行FIFO页面置算法请按1\n");printf(" 若要执行LRU 页面置算法请按2\n");printf(" 若要退出请按3\n") ;printf("*******************************************\n");printf( "Enter your choice (1 or 2 or 3): ");do{ //如果输入信息不正确,继续输入ch = (char)getch() ;}while(ch != '1' && ch != '2'&& ch != '3');printf("\n\n你按的是:%c ,现在为你执行对应操作。
操作系统页⾯置换算法(opt,lru,fifo,clock )实现选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率,也就是说,应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种(以下来⾃操作系统课本)。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的,或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的,因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块,并考虑有以下页⾯号引⽤串: 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时,先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时,产⽣缺页中断,根据最佳置换算法,选择第18次访问才需调⼊的页⾯7予以淘汰。
然后,访问页⾯0时,因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推,如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到,发⽣缺页中断的次数为9,页⾯置换的次数为6。
图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯,亦即在内存中驻留时间最久的页⾯。
该算法实现简单,只需把调⼊内存的页⾯根据先后次序链接成队列,设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应,因为在进程中,有的页⾯经常被访问。
图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例,⾤⽤FIFO 算法进⾏页⾯置换。
进程访问页⾯2时,把最早进⼊内存的页⾯7换出。
然后访问页⾯3时,再把2, 0, 1中最先进⼊内存的页换出。
《计算机操作系统原理》课外上机实验报告题目:操作系统虚拟页面替换算法的仿真实现学院:信息科技学院组长主要任务:1、学习教材关于虚拟页面替换算法的相关知识2、设计FIFO、LRU、ClOCK算法3、设计程序的界面4、编写程序代码5、完成实验报告一、实验目的1、模拟计算机操作系统内存管理虚拟页面替换算法FIFO、LRU、CLOCK2、加深对虚拟页面替换算法的理解二、基础原理和核心设计内容1、为了满足程序并发执行的要求,提高程序对主存的利用率,我们采用虚拟页面替换算法。
而先进先出页面替换算法(FIFO)、最近未使用算法(LRU)和CLOCK算法2、当页框全部被分配完时,FIFO算法将最先进入的页面替换;LRU算法引用标志位,将标志位为false的页面(最久未被使用)替换;CLOCK算法将页框组成循环队列,用指针绕队列一周,若标志位为False,则将其替换,否则将指针所指页面替换。
3、本程序采用Visual Basic 6.0开发,界面友好。
三、数据结构及操作函数设计1、自定义数据类型:1.1模拟页面:Private Type P_Page整型P_Num(页面号)布尔型P_Mark(标志位)End Type1.2模拟页表:Private Type P_Table整型PT_frame整型PT_Num布尔型PT_MarkEnd Type2、主要变量和数组2.1数组P_Page型Page():存放页面P_Table型Table():存放页表各数据2.2全局变量整型P_Pointer:用以指示即将请求的页面整型Pointer:用以在CLOCK算法中作为循环队列的指针3、主要算法流程图3.13.2FIFO流程图3.2LRU流程图3.2CLOCK流程图四、测试运行及结果分析分析:如图所示,用该程序首先生成了30个页号为1-11的页面,物理页框数为5,三种算法的(FIFO、LRU、CLOCK)的页面中断率分别为46%、50%、43%。
目录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个数字页面引用串。
lru页面置换算法例题详解LRU(Least Recently Used)页面置换算法是一种常用的内存管理算法,其基本思想是:当内存空间不足时,优先淘汰最近最少使用的页面。
下面是一个LRU页面置换算法的详细例子:假设我们有3个物理块,当前内存中已经装入了页面1、页面2和页面3。
现在,我们按照顺序依次访问页面4、页面3、页面2、页面1、页面4、页面3、页面5和页面4,我们需要使用LRU算法来决定哪些页面应该被淘汰。
步骤1:装入页面4。
此时内存中有页面1、页面2、页面3和页面4,下一次访问时,将页面4标记为最近使用。
步骤2:访问页面3。
由于页面3在内存中,将其标记为最近使用。
步骤3:访问页面2。
同样,页面2也在内存中,将其标记为最近使用。
步骤4:访问页面1,内存已满,需要淘汰一个页面。
根据LRU算法,应该淘汰最久未使用的页面,即页面3。
因此,将页面1装入内存中,并标记为最近使用,同时将页面3淘汰。
步骤5:访问页面4,内存已满,需要淘汰一个页面。
根据LRU算法,应该淘汰最久未使用的页面,即页面2。
因此,将页面4装入内存中,并标记为最近使用,同时将页面2淘汰。
步骤6:访问页面3,内存已满,需要淘汰一个页面。
根据LRU算法,应该淘汰最久未使用的页面,即页面1。
因此,将页面3装入内存中,并标记为最近使用,同时将页面1淘汰。
步骤7:访问页面5,内存已满,需要淘汰一个页面。
根据LRU算法,应该淘汰最久未使用的页面,即页面1。
因此,将页面5装入内存中,并标记为最近使用,同时将页面1淘汰。
在上述过程中,我们按照LRU算法依次淘汰了页面3、页面2、页面1和页面1,最终实现了页面的置换。
页面置换算法模拟1、设计目的通过请求页式管理方式中页面置换算法的模拟设计,了解虚拟存储的特点,掌握请求页式存储管理中的页面置换算法。
2、任务及要求2.1 设计任务模拟实现先进先出算法(FIFO)、最近最少使用算法(LRU)、最优页置换算法(OPT),并计算命中率。
2.2 设计要求2.2.1 首先用随机数生成函数产生“指令”序列,然后将指令序列变换成相应的页地址流,再计算不同算法下的命中率。
2.2.2 通过随机数产生一个指令序列,共产生400条。
其中50%的指令是顺序执行的,且25%的指令分布在前半部分地址空间,25%的指令分布在后半部分地址空间。
2.2.3 将指令地址流变换成页地址流2.2.4 循环运行,使用户内存容量从4到40,。
计算每个内存容量下不同页面置换算法的命中率。
3、算法及数据结构3.1算法的总体思想(流程)struct Pro{int num,time;};int a[total_instruction];int page[N];//调用函数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;}return -1;}void Input(Pro p[total_instruction]){int m,i,m1,m2;srand((unsigned int )time(NULL));m=rand()%400;for(i=0;i<total_instruction;) //产生指令队列{if(m<0||m>399){printf("When i==%d,Error,m==%d\n",i,m);exit(0);}a[i]=m; //任选一指令访问点ma[i+1]=a[i]+1;a[i+2]=a[i]+2; //顺序执行两条指令m1=rand( )%m; //执行前地址指令m1a[i+3]=m1;a[i+4]=m1+1;a[i+5]=m1 + 2;//顺序执行两条指令m2 = rand()%(157-m1)+m1+3;a[i+6]=m2;if( (m2+2) > 159 ){a[i+7] = m2+1;i +=8;}else{a[i+7] = m2+1;a[i+8] = m2+2;i = i+9;}m = rand()%m2;}//forfor(i=0;i<total_instruction;i++) //将指令序列变换成页地址流{p[i].num=a[i]/10;p[i].time = 0;}}3.2先进先出算法(FIFO)模块3.2.1 功能根据页地址流,采用先进先出的算法进行页面置换。
“计算机操作系统”课程设计大作业页面置换算法模拟实验(含完整资料,可直接提交)一、题目: 页面置换算法模拟实验二、目的分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法对用户输入的页面号请求序列进行淘汰和置换,从而加深对页面置换算法的理解。
三、内容和要求请用C/C++语言编一个页面置换算法模拟程序。
用户通过键盘输入分配的物理内存总块数,再输入用户逻辑页面号请求序列,然后分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法三种算法对页面请求序列进行转换,最后按照课本P150页图4-26的置换图格式输出每次页面请求后各物理块内存放的虚页号,并算出总的缺页率(缺页次数/总的请求次数)。
最后三种页面置换算法的优缺点。
三种页面置换算法的思想可参考教材P149-P152页。
假设页面号请求序列为4、3、2、1、4、3、5、4、3、2、1、5,当分配给某进程的物理块数分别为3块和4块时,试用自己编写的模拟程序进行页面转换并输出置换图和缺页次数、缺页率。
四、提交内容本大作业每个人必须单独完成。
最后需提交的内容包括:源程序(关键代码需要注释说明)、可运行程序、运行结果、算法思路及流程图、心得体会。
大作业严禁抄袭。
发现抄袭一律以不及格论。
请大家严格按照大作业题目来编写程序,不要上交以前布置的大作业。
如果提交的大作业题目与本文档要求不符,成绩一律为及格。
目录摘要 (2)正文 (2)1、设计思路 (3)2、各模块的伪码算法 (6)3、函数的调用关系图 (8)4、测试 (13)设计总结 (15)参考文献 (16)致谢 (17)附录:部分源程序代码 (18)摘要UNIX中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
操作系统实验报告四【实验题目】虚拟内存页面置换算法【实验目的】通过这次实验,加深对虚拟内存页面置换概念的理解,进一步掌握先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
【实验内容】问题描述:设计程序模拟先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m,在进程运行过程中要访问的页面个数为n,页面访问序列为P1, …,Pn,分别利用不同的页面置换算法调度进程的页面访问序列,给出页面访问序列的置换过程,计算每种算法缺页次数和缺页率。
程序要求如下:1)利用先进先出FIFO,最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。
2)模拟三种算法的页面置换过程,给出每个页面访问时的内存分配情况。
3)输入:最小物理块数m,页面个数n,页面访问序列P1, … ,Pn,算法选择1-FIFO,2-OPI,3-LRU。
4)输出:每种算法的缺页次数和缺页率。
【实验要求】1) 上机前认真复习页面置换算法,熟悉FIFO,OPI,LRU三种页面分配和置换算法的过程;2) 上机时独立编程、调试程序;3) 根据具体实验要求,完成好实验报告(包括实验的目的、内容、要求、源程序、实例运行结果截图)。
【源代码】//--------------- YeMianZhiHuan.cpp -----------------#include "iostream.h"const int DataMax=100;const int BlockNum = 10;int DataShow[BlockNum][DataMax]; // 用于存储要显示的数组bool DataShowEnable[BlockNum][DataMax]; // 用于存储数组中的数据是否需要显示//int Data[DataMax]={4,3,2,1,4,3,5,4,3,2,1,5,6,2,3,7,1,2,6,1}; // 测试数据//int N = 20; // 输入页面个数int Data[DataMax]; // 保存数据int Block[BlockNum]; // 物理块int count[BlockNum]; // 计数器int N ; // 页面个数int M;//最小物理块数int ChangeTimes;void DataInput(); // 输入数据的函数void DataOutput();void FIFO(); // FIFO 函数void Optimal(); // Optimal函数void LRU(); // LRU函数///*int main(int argc, char* argv[]){DataInput();// DataInput();// FIFO();// Optimal();// LRU();// return 0;int menu;while(true){cout<<endl;cout<<"* 菜单选择*"<<endl;cout<<"*******************************************************"<<endl;cout<<"* 1-FIFO *"<<endl;cout<<"* 2-Optimal *"<<endl;cout<<"* 3-LRU *"<<endl;cout<<"* 0-EXIT *"<<endl;cout<<"*******************************************************"<<endl;cin>>menu;switch(menu){case 1: FIFO();break;case 2: Optimal();break;case 3: LRU();break;default: break;}if(menu!=1&&menu!=2&&menu!=3) break;}}//*/void DataInput(){cout<<"请输入最小物理块数:";cin>>M;while(M > BlockNum) // 大于数据个数{cout<<"物理块数超过预定值,请重新输入:"; cin>>M;}cout<<"请输入页面的个数:";cin>>N;while(N > DataMax) // 大于数据个数{cout<<"页面个数超过预定值,请重新输入:"; cin>>N;}cout<<"请输入页面访问序列:"<<endl;for(int i=0;i<N;i++)cin>>Data[i];}void DataOutput(){int i,j;for(i=0;i<N;i++) // 对所有数据操作{cout<<Data[i]<<" ";}cout<<endl;for(j=0;j<M;j++){cout<<" ";for(i=0;i<N;i++) // 对所有数据操作{if( DataShowEnable[j][i] )cout<<DataShow[j][i]<<" ";elsecout<<" ";}cout<<endl;}cout<<"缺页次数: "<<ChangeTimes<<endl;cout<<"缺页率: "<<ChangeTimes*100/N<<"%"<<endl; }void FIFO(){int i,j;bool find;int point;int temp; // 临时变量ChangeTimes = 0;for(j=0;j<M;j++)for(i=0;i<N;i++)DataShowEnable[j][i] = false; // 初始化为false,表示没有要显示的数据for(i=0;i<M;i++){count[i] = 0; // 大于等于BlockNum,表示块中没有数据,或需被替换掉// 所以经这样初始化(3 2 1),每次替换>=3的块,替换后计数值置1,// 同时其它的块计数值加1 ,成了(1 3 2 ),见下面先进先出程序段}for(i=0;i<N;i++) // 对有所数据操作{// 增加countfor(j=0;j<M;j++)count[j]++;find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] ){find = true;}}if( find ) continue; // 块中有该数据,判断下一个数据// 块中没有该数据ChangeTimes++; // 缺页次数++if( (i+1) > M ) // 因为i是从0开始记,而M指的是个数,从1开始,所以i+1 {//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0; // 更新计数值// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"FIFO => "<< endl;DataOutput();}void Optimal(){int i,j,k;bool find;int point;int temp; // 临时变量,比较离的最远的时候用ChangeTimes = 0;for(j=0;j<M;j++)for(i=0;i<N;i++)DataShowEnable[j][i] = false; // 初始化为false,表示没有要显示的数据// for(i=0;i<M;i++)// {// count[i] = 0 ; //// }for(i=0;i<N;i++) // 对有所数据操作{find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] )find = true;}if( find ) continue; // 块中有该数据,判断下一个数据// 块中没有该数据,最优算法ChangeTimes++; // 缺页次数++for(j=0;j<M;j++){// 找到下一个值的位置find = false;for( k =i;k<N;k++){if( Block[j] == Data[k] ){find = true;count[j] = k;break;}}if( !find ) count[j] = N;}if( (i+1) > M ) // 因为i是从0开始记,而BlockNum指的是个数,从1开始,所以i+1 {//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"Optimal => "<< endl;DataOutput();}void LRU(){int i,j;bool find;int point;int temp; // 临时变量ChangeTimes = 0;for(j=0;j<M;j++)for(i=0;i<N;i++)DataShowEnable[j][i] = false; // 初始化为false,表示没有要显示的数据for(i=0;i<M;i++){count[i] = 0 ;}for(i=0;i<N;i++) // 对有所数据操作{// 增加countfor(j=0;j<M;j++)count[j]++;find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] ){count[j] = 0;find = true;}}if( find ) continue; // 块中有该数据,判断下一个数据// 块中没有该数据ChangeTimes++; // 缺页次数++if( (i+1) > M ) // 因为i是从0开始记,而BlockNum指的是个数,从1开始,所以i+1 {//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0;// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"LRU => "<< endl;DataOutput();}【效果截图】以作业为测试数据:。
武汉轻工大学数学与计算机学院《操作系统》课程设计说明书题目:页式虚拟存储管理页面置换算法专业:班级:学号:姓名:指导老师:2015年5月26日目录一、设计目的二、设计内容三、基本原理和解决方案四、实验内容五、流程图六、源代码七、运行结果八、实验总结(心得体会)一、设计目的通过请求页式存储管理中页面置换算法模拟程序,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。
二、设计内容阅读教材《计算机操作系统》第四章,掌握存储器管理相关概念和原理。
模拟实现页式虚拟存储管理的三种页面置换算法(OPT、FIFO和LRU),并通过比较性能得出结论。
前提:(1)页面分配采用固定分配局部置换。
(2)作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
(3)置换算法的置换过程输出可以在显示器上也可以存放在文件中,但必须清晰可读,便于检验。
三、基本原理和解决方案存储管理是操作系统进行资源管理的一个重要功能。
现代操作系统广泛采用虚拟存储的技术对内存进行扩充。
实现虚拟存储的一个主要技术手段就是将辅存和主存统一管理,在二者之间进行对换,从而形成物理上两级而逻辑上一级的存储管理系统。
一个置换算法的好坏对这个逻辑上的单级虚存的性能起着极其重要的作用,而且会影响处理机的调度性能。
对于本任务规定的前提:页面分配采用固定分配局部置换,则置换发生的时机是作业已经将操作系统分配的固定数目的物理块全部用完且发生缺页的时候。
此时必须要将已经装入内存的部分逻辑页面换出以便将所缺的页面调入内存。
置换算法就是一个决定将内存中“哪一个”页面换出的算法。
四、实验内容1.通过随机数产生一个指令序列,共320条指令,指令的地址按下述原则生产:50%的指令是顺序执行的;25%的指令是均匀分布在前地址部分;25%的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流设页面大小为1K;用户内存容量为4页到32页;用户虚存容量为32K。
《计算机操作系统》课外实践报告题目:页面置换算法模拟班级: 13级物联网工程一班姓名:王铎学号: 130911044指导老师: 王蕾设计时间: 2014.6一、实验目标:通过设计请求页面存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页面存储管理的页面置换算法。
二、实验要求1通过随机数产生一个指令序列320条指令。
指令的地址按下述原则生成50%的指令是顺序执行的25%的指令是均匀分布在前地址部分25%的指令是均匀分布在地址部分。
2将指令序列换成为页地址流。
3计算并输出下述各种算法在不同内存容量下的命中率。
1)先进先出的算法FIFO2)最近最少使用算法LRU3)最近最不经常使用算法NUR三.实践内容简要描述1、实践环境windows XP/7,visual C++ 6.02、算法思路与算法原理2.1、先进先出算法(FIFO):该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单,只需要把一个进程已调入内存的页面,按先后次序连接成一个队列,并设置一个指针,成为替换指针,使它总是指向最老的页面。
2.2、最近最久未使用页面置换算法(LRU):算法的基本思想:当需要淘汰某一页时,选择离当前时间最近一段时间内最久没有使用过的页先淘汰。
该算法的出发点是,如果某页被访问了,则它可能马上还被访问。
或者反过来说,如果某页长时间未被访问,则它在最近一段时间不会被访问。
3概要设计3.1 总体设计框图4系统流程图图4.1详细设计框图图4.2为置换方法的流程图5代码分析结果5.1 数据结构int m, int need[],int n, result[10][20],int state[],int count1[];5.2 FIFO具体函数及设计实现FIFO流程图FIFO函数实现void FIFO(int m, int need[],int n) //m分配物理页面大小,n需要页面数组的最大值{int p=0; //当前请求的页面int del=0; //步数int count1[20];double count=0; //缺页数double que=0; //缺页率int result[10][20]; //结果表for(int i =0;i<=m;i++)for(int j=0;j<=n;j++){result[i][j]=-1;count1[j]=-1;}while(n>=p){int k=need[p];if(p>0){for(int i=0;i<=m;i++){result[i][p]=result[i][p-1];}}int f1=0;//首先看是否有空位置或者已经存在请求的页面for(int i =0;i<=m;i++){if(result[i][p]==-1){result[i][p]=k;f1=1;i=m+1;count1[p]=k;count=count+1;p=p+1;}else if(result[i][p]==k){f1=1;p=p+1;i=m+1;}}if(f1==1) continue;//这里发生替换result[del][p]=k;count1[p]=k;count=count+1;p=p+1;del=(del+1)%(m+1);}cout<<"*******************FIFO过程如下表************************"<<endl; for(int t3=0;t3<=n;t3++)//输出原来的页面cout<<need[t3]<<" ";cout<<endl;for(int t0 =0;t0<=m;t0++)//判断页表是否填满{for(int t1=0;t1<=n;t1++){if(result[t0][t1]!=-1)cout<<result[t0][t1]<<" ";else cout<<" "<<" ";}cout<<endl;}for(int j1=0;j1<=n;j1++)//对于缺页的打×,否则打√{if(count1[j1]!=-1)cout<<"×";else cout<<"√";}cout<<endl;que=count/(n+1);//统计缺页次数和缺页率cout<<"缺页次数为:"<<count<<endl;cout<<"缺页率"<<count<<"/"<<n+1<<"="<<que<<endl;cout<<"**************************************************"<<endl;}5.3LRU具体函数及设计实现LRU流程图LRU函数实现void LRU(int m, int need[],int n){m++;n++;int i, j, min, num = 1, k, flag;int state[10], count[20], hsive[10];int result[10][20];memset(state, 0, sizeof(state));//初始化内存空间,给三个数组分配内存memset(count, -1, sizeof(count));memset(hsive, -1, sizeof(hsive));memset(result, -1, sizeof(result));for(i = 0; i < n; i++)//将need数组值赋给resultresult[0][i] = need[i];cout<<"*****************LRU过程如下表*********************"<<endl;for(i = 0; i < n; i++){flag = 0;//标志位,如果页面和页表内的熄灯则赋值for(j = 1; j < num; j++){if(result[0][i] == hsive[j]){flag = 1;state[j] = -1;break;}}if(flag == 0)//替换{if(num <= m)hsive[num] = result[0][i];else{min = -1;for(j = 1; j <= m; j++){if(state[j] > min){k = j;min = state[j];}}hsive[k] = result[0][i];state[k] = -1;}count[i] = 1;num++;}for(j = 1; j <= m; j++){result[j][i] = hsive[j];state[j]++;}}for(j = 0; j <= m; j++)//输入个页面替换情况{for(i = 0; i < n; i++){if(result[j][i] == -1)cout << " ";elsecout << result[j][i] << " ";}cout << endl;}for(i = 0; i < n; i++){if(count[i] != -1)cout<<"×";elsecout<<"√";}cout << endl;//统计各页面缺页次数和缺页率cout << "缺页次数为:" << num - 1 << endl;cout << "缺页率" << num - 1 << "/"<<n << "=" << double(num - 1) / n <<endl;cout<<"**************************************************"<<endl; }主方法int main(){cout<<" *********************************************"<<endl;cout<<" * 页式存储管理*"<<endl;cout<<" ********************************************* "<<endl;int m;int n=0;int choose=2;int need[20];char flag;while(1){cout<<"指定内存分配页面数:";while (flag<'0'||flag>'9'){cin>>flag;}m=flag-'0'-1;flag=' ';cout<<"请选择页面序列产生方式:"<<endl;cout<<" (0)手动输入"<<endl;cout<<" (1)随机产生"<<endl;while (flag<'0'||flag>'1'){cin>>flag;}choose =flag-'0';flag=' ';if(choose==0){cout<<"输入页面走向!以s结尾"<<endl;while(1){while ((flag<'0'||flag>'9')&&flag!='s'){cin>>flag;}if(flag=='s') break;need[n]=flag-'0';flag=' ';n=n+1;}flag=' ';n=n-1;}else {cout<<"随机产生的页面个数:";cin>>n;n=n-1;for(int i=0;i<=n;i++){need[i]=rand()%10;}}system("cls");cout<<"选择页面置换算法:"<<endl;cout<<"0-FIFO 1-LRU"<<endl;while (flag<'0'||flag>'1'){cin>>flag;}choose =flag-'0';flag=' ';if(choose==0){FIFO(m, need,n);}else {LRU(m, need,n);}cout<<"输入Y/y可以看另外一种置换算法的执行过程"<<endl;cin>>flag;if(flag=='Y'||flag=='y'){system("cls");if(choose==0) LRU(m, need,n);else FIFO(m, need,n);}else flag=' ';cout<<"输入N/n退出否则输入任意键继续"<<endl;cin>>flag;if(flag=='N'||flag=='n') break;else{system("cls");flag=' ';}}return 0;}5.4调用关系图6测试6.1进入界面及产生页面走向运行结果如下图6.1 进入管理界面图6.2产生页面走向6.2FIFO算法及查看结果图6.3选择FIFO算法结果6.3LRU算法及查看结果图6.4选择LRU结果6.4继续进入主界面及产生页面走向图6.5按y继续回到主界面设置页面为46.5调度算法及结果图6.6选择LRU算法结果图6.7选择FIFO算法结果7 总结与体会通过这次实验,我基本了解了页面置换算法的基本设置与要求,懂得了先进先出算法(FIFO)、最近最久未使用页面置换算法(LRU)的基本编程及算法原理。
广东海洋大学学生实验报告书(学生用表)实验名称 LRU页面之后算法模拟课程名称操作系统课程号学院(系)专业班级学生姓名学号实验地点实验日期LRU页面置换算法模拟一.实验目的(1)掌握页式管理基本原理(2)掌握LRU页面置换算法二.实验内容(1)按照最近最久未使用页面置换算法(LRU)设计页面置换模拟程序。
(2)对于给定的页面访问序列,输出其访问过程中的页面置换序列,并记录缺页次数。
70120304230321201701页面访问序列页面0 77722224440001111111页面10000000033333300000页面2111333222222222777缺页Y Y Y Y Y Y Y Y Y Y Y Y置换7 1 2 3 0 4 0 3 2 (3)输出内容参考三.相关数据结构(1)页表结构数组页号块号状态(2)页面访问序列数组:保存进程执行过程中的页面访问序列。
(3)寄存器数组:每个物理块对应一个16bit的寄存器。
(4)物理块分配表(bool数组):标识每个物理块是否已经分配四.实现流程(1)主线程:实现页面访问过程中的物理块分配和页面置换(假设每间隔80ms访问一个页面)。
(2)寄存器周期性移位线程:周期性(每隔100ms)将所有寄存器右移一位。
(3)主线程参考流程图:详细代码:import java.io.BufferedReader;import java.io.InputStreamReader;public class LRU {int blockCount;int seriaCount;static int num=0;int[] address;int[] stack;BufferedReader br;public static void main(String[] args) {int address[] = { 7, 0,1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1};LRU lru = new LRU();lru.init();lru.display();}public void init() {try {br = new BufferedReader(new InputStreamReader(System.in));}catch (Exception e) {e.printStackTrace();System.exit(0);}blockCount = 3;stack = new int[blockCount];System.out.println("请输入访问内存的块序列的个数为3:");seriaCount = readInt();System.out.println("读入的访问序列是:");address = readIntArray();}public void display() {boolean flag;System.out.println("--------------------------------------");System.out.print("最近最久未使用页面置换算法(LRU)页面置换序列:");for (int i = 0; i< address.length; i++) {int j =0;flag =false;int t, temp =address[i];while(stack[j] != address[i]) {t= stack[j];stack[j]= temp;temp= t;j++;if(temp == 0 || j == stack.length)break;}if (j< stack.length)stack[j]= temp;if (temp != 0&& j != stack.length)flag= true;try {ng.Thread.sleep(500);} catch(InterruptedException e) {e.printStackTrace();}for (int m= 0; m < i - blockCount + 1; m++) System.out.print(" ");for (int m =0; m < stack.length; m++)System.out.print(stack[m]+ " ");System.out.print(",");if(flag){num=num;}else{num++;}}System.out.println("");System.out.println("总缺页数:"+num); }public int readInt() {try {String s =br.readLine();return Integer.parseInt(s);} catch (Exception e) {return 3;}}public int[] readIntArray() {try {String s =br.readLine();System.out.println(s);String tmp[]= s.split(" ");int value[] =new int[tmp.length];for (int i =0; i < value.length; i++)value[i]= Integer.parseInt(tmp[i]);return value;} catch (Exception e) {System.out.println(e);return null;}}}五.实现结论通过这次的实验,我对LRU页面置换算法有了更深的了解,LRU置换算法是理想性的算法,因为使用LRU置换算法要花费很大的系统开销,所以在实际系统中并不会直接采用LRU算法。
操作系统——模拟页⾯置换算法(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。
先进先出(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 }。
置换算法lru模拟设计一、概述置换算法(Replacement Algorithm)是一种常用的缓存管理策略,其中 LRU (Least Recently Used)算法是一种常见的策略,用于决定何时淘汰最不常用的数据。
本篇文章将详细介绍如何使用模拟设计实现 LRU 算法。
二、算法原理LRU 算法的基本原理是,当缓存满时,选择最不常用的数据淘汰。
在计算机科学中,常用的 LRU 算法实现方式有三种:FIFO(First In First Out,先进先出)、LFU(Least Frequently Used,最不常用)和基于时间的 LRU。
其中基于时间的 LRU 算法由于其简单易实现,得到了广泛的应用。
三、模拟设计本节将介绍如何使用模拟设计实现 LRU 算法。
模拟设计通常使用一个数组和两个指针来实现。
其中,数组用于存储缓存中的数据,两个指针分别指向最不常用数据和当前头部的位置。
每次有新的数据被插入缓存时,都需要判断其是否已经在缓存中存在,如果存在则移动到尾部,如果不存在则插入到头部。
同时,需要更新头部的指针。
当需要淘汰数据时,选择头部指针所指向的数据进行淘汰。
四、代码实现以下是一个简单的 Python 代码实现:```pythonclass LRUCache:def __init__(self, capacity):self.capacity = capacityself.cache = {}self.head = Noneself.tail = Nonedef get(self, key):if key not in self.cache:return -1self.cache[key].move_to_head()return self.cache[key].valuedef put(self, key, value):if key in self.cache:self.cache[key].move_to_tail()new_node = Node(key, value)if self.head is None:self.head = new_nodeself.tail = new_nodeelse:new_node.move_to_head()prev_node = self.headwhile prev_node.next:prev_node = prev_node.nextprev_node.next = new_nodeself.tail = new_nodeself.cache[key] = new_nodeif len(self.cache) > self.capacity:tail = self.tail.prevdel self.cache[tail.key]if tail == self.head:self.head = Noneself.tail = None```在这个实现中,我们使用了一个 Node 类来表示缓存中的数据节点,其中包含了键值、值和位置信息。
操作系统实验(四)实验报告--虚拟内存操作系统实验(四)虚拟内存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)最近学习操作系统时,实验要求实现常见的三种页⾯置换算法,博主按照书上要求试着编写,实现了案例,并记录在博客随记中,以便后续⾃⼰复习并也给需要的同学分享参考⼀下!⽔平有限,若有错,请悄悄告诉博主!博主好⽴即改正。
最佳置换算法(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)是淘汰最先进⼊内存的页⾯,即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
操作系统页面置换-最近最少使用(LRU)算法模拟import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.WindowAdapter;import java.awt.event.WindowEvent;class Window extends Frame implements Runnable, ActionListener{TextField Text[][]=new TextField[4][9];int record[][]=new int[4][9]; //定义与Text[][]一一映射的数组int a=-8,b=-8,c=-8,//AgeA=-1,B=-1,C=-1;//内存Boolean boolea=true;TextField inPutText=new TextField(8);Label label=new Label("请输入八个数字,谢谢合作。
"),label2=new Label("页面失效率:"),label3=new Label("I'm waiting…………");Button button=new Button("Refresh");Window(){ //构造函数窗口初始化setTitle("操作系统页面置换-最近最少使用(LRU)算法模拟");setLayout(new FlowLayout());add(label);label.setBackground(Color.cyan);add(inPutText);inPutText.addActionListener(this); //对输入信息设置监听for(int i=0;i<4;i++){for(int j=0;j<9;j++){Text[i][j]=new TextField(1);Text[i][j].setEditable(false);add(Text[i][j]);record[i][j]=-1;}}add(label2);add(label3);add(button);button.setBackground(Color.orange);button.addActionListener(this);setBackground(Color.gray);addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}});setBounds(400,180,350,200);this.setResizable(false);setVisible(true);validate();}/*** @param args*/@Overridepublic void run() { //运算线程// TODO Auto-generated method stubint m=0;for(int i=1;i<9;i++){try {Thread.sleep(1500); //时钟滴答设为1.5秒label3.setText("I'm running…………");}catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}int need=record[0][i];if(isNotHave(need,i)&&a<0){A=need;a=0;Text[1][i].setBackground(Color.red);m++;}else if(isNotHave(need,i)&&b<0){B=need;b=0;Text[2][i].setBackground(Color.red);m++;}else if(isNotHave(need,i)&&c<0){C=need;c=0;Text[3][i].setBackground(Color.red);m++;}else if(isNotHave(need,i)&&a>b){if(isNotHave(need,i)&&a>c){A=need;a=0;Text[1][i].setBackground(Color.red);m++;}else{if(isNotHave(need,i))C=need;c=0;Text[3][i].setBackground(Color.red);m++;}}else{if(isNotHave(need,i)&&b>c){B=need;b=0;Text[2][i].setBackground(Color.red);m++;}else{if(isNotHave(need,i)){C=need;c=0;Text[3][i].setBackground(Color.red);m++;}}}a++;b++;c++;record[1][i]=A;record[2][i]=B;record[3][i]=C;for(int k=1;k<4;k++){for(int f=1;f<9;f++){if(record[k][f]>=0)Text[k][f].setText(""+record[k][f]);}}Text[0][0].setText("Age");Text[1][0].setText(""+a);Text[2][0].setText(""+b);Text[3][0].setText(""+c);}label3.setText(""+(double)m/8*100+"%");label3.setBackground(Color.red);}@Overridepublic void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubif(e.getSource()==inPutText&&boolea){//对用户输入信息的提取String number=e.getActionCommand();int q=Integer.parseInt(number);System.out.println(q);int s=1;for(int i=1;i<9;i++){record[0][9-i]=(q/s)%10;System.out.println(record[0][9-i]);s=s*10;}//将提取信息显示在窗口for(int f=1;f<9;f++){Text[0][f].setText(""+record[0][f]);}//运算线程的创建Thread t=new Thread(this);t.start();boolea=false;}else if(e.getSource()==button){refresh();boolea=true;button.transferFocus();}}//判断内存中是否包含所需数据public boolean isNotHave(int ne,int i){boolean bo=true;if(A==ne){ bo=false; a=0;Text[1][i].setBackground(Color.green);}if(B==ne) {bo=false; b=0;Text[2][i].setBackground(Color.green);}if(C==ne) {bo=false; c=0;Text[3][i].setBackground(Color.green);}return bo;}//对窗口与出口映射的数组进行还原public void refresh(){for(int i=0;i<4;i++){for(int j=0;j<9;j++){Text[i][j].setText(null);Text[i][j].setBackground(Color.white);record[i][j]=-1;}}inPutText.setText(null);label3.setText("I'm waiting…………");label3.setBackground(Color.gray);a=-8;b=-8;c=-8;A=-1;B=-1;C=-1;}}public class Windows{public static void main(String[] args) {// TODO Auto-generated method stubnew Window();}}。