操作系统-LRU页面置换算法模拟
LRU页面置换算法模拟程序

#include<stdio.h>#include<conio.h>#define M 4#define N 17#define Myprintfprintf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n") /*表格控制*/typedef struct page{int num; /*记录页面号*/int time; /*记录调入内存时间*/}Page; /* 页面逻辑结构,结构为方便算法实现设计*/Page b[M]; /*内存单元数*/int c[M][N]; /*暂保存内存当前的状态:缓冲区*/int queue[100]; /*记录调入队列*/int K; /*调入队列计数变量*//*初始化内存单元、缓冲区*/void Init(Page *b,int c[M][N]){int i,j;for(i=0;i<N;i++){b[i].num=-1;+b[i].time=N-i-1;}for(i=0;i<M;i++)for(j=0;j<N;j++)c[i][j]=-1;}/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/ int GetMax(Page *b){int i;int max=-1;int tag=0;for(i=0;i<M;i++){if(b[i].time>max){max=b[i].time;tag=i;}}return tag;}/*判断页面是否已在内存中*/int Equation(int fold,Page *b){int i;for(i=0;i<M;i++){if (fold==b[i].num)return i;}return -1;}/*LRU核心部分*/void Lru(int fold,Page *b){ int i;int val;val=Equation(fold,b);if (val>=0){b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}else{queue[++K]=fold;/*记录调入页面*/val=GetMax(b);b[val].num=fold;b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}}/*主程序*/void main(){int a[N]={1,0,1,0,2,4,1,0,0,8,7,5,4,3,2,3,4};int i,j;start: K=-1;Init(b, c);for(i=0;i<N;i++){Lru(a[i],b);c[0][i]=a[i];/*记录当前的内存单元中的页面*/ for(j=0;j<M;j++)c[j][i]=b[j].num;}/*结果输出*/printf("内存状态为:\n");Myprintf;for(j=0;j<N;j++)printf("|%2d ",a[j]);printf("|\n");Myprintf;for(i=0;i<M;i++){ for(j=0;j<N;j++){if(c[i][j]==-1)printf("|%2c ",32);elseprintf("|%2d ",c[i][j]); }printf("|\n");}Myprintf;printf("\n调入队列为:");for(i=0;i<K+1;i++)printf("%3d",queue[i]);printf("\n缺页次数为:%6d\n缺页率:%16.6f",K+1,(float)(K+1)/N); printf("\nAre you continuing!\ty?");if(getche()=='y')goto start;}。
操作系统页面置换算法(opt,lru,fifo,clock)实现

操作系统页⾯置换算法(opt,lru,fifo,clock )实现选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率,也就是说,应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种(以下来⾃操作系统课本)。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的,或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的,因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块,并考虑有以下页⾯号引⽤串: 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时,先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时,产⽣缺页中断,根据最佳置换算法,选择第18次访问才需调⼊的页⾯7予以淘汰。
然后,访问页⾯0时,因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推,如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到,发⽣缺页中断的次数为9,页⾯置换的次数为6。
图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯,亦即在内存中驻留时间最久的页⾯。
该算法实现简单,只需把调⼊内存的页⾯根据先后次序链接成队列,设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应,因为在进程中,有的页⾯经常被访问。
图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例,⾤⽤FIFO 算法进⾏页⾯置换。
进程访问页⾯2时,把最早进⼊内存的页⾯7换出。
然后访问页⾯3时,再把2, 0, 1中最先进⼊内存的页换出。
操作系统虚拟页面替换算法的仿真实现

《计算机操作系统原理》课外上机实验报告题目:操作系统虚拟页面替换算法的仿真实现学院:信息科技学院组长主要任务:1、学习教材关于虚拟页面替换算法的相关知识2、设计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%。
lru页面置换算法例题详解

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.要求:本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。
其中虚页的个数可以事先给定(例如10个),对这些虚页访问的页地址流(其长度可以事先给定,例如20次虚页访问)可以由程序随机产生,也可以事先保存在文件中。
要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。
程序应允许通过为该进程分配不同的实页数,来比较两种置换算法的稳定性。
二、实验说明1.设计中虚页和实页的表示本设计利用C语言的结构体来描述虚页和实页的结构。
在虚页结构中,pn代表虚页号,因为共10个虚页,所以pn的取值范围是0—9。
pfn代表实页号,当一虚页未装入实页时,此项值为-1;当该虚页已装入某一实页时,此项值为所装入的实页的实页号pfn。
time项在FIFO算法中不使用,在LRU中用来存放对该虚页的最近访问时间。
在实页结构中中,pn代表虚页号,表示pn所代表的虚页目前正放在此实页中。
pfn代表实页号,取值范围(0—n-1)由动态指派的实页数n所决定。
next是一个指向实页结构体的指针,用于多个实页以链表形式组织起来,关于实页链表的组织详见下面第4点。
2.关于缺页次数的统计为计算命中率,需要统计在20次的虚页访问中命中的次数。
为此,程序应设置一个计数器count,来统计虚页命中发生的次数。
每当所访问的虚页的pfn项值不为-1,表示此虚页已被装入某实页内,此虚页被命中,count加1。
最终命中率=count/20*100%。
3.LRU算法中“最近最久未用”页面的确定为了能找到“最近最久未用”的虚页面,程序中可引入一个时间计数器countime,每当要访问一个虚页面时,countime的值加1,然后将所要访问的虚页的time项值设置为增值后的当前countime值,表示该虚页的最后一次被访问时间。
页面置换算法模拟_课程设计

《操作系统原理与Linux》课程设计报告专业计算机科学与技术班级学号姓名指导教师完成时间成绩目录一、设计题目 (2)二、设计目的 (2)三、设计要求 (2)四、设计思想说明 (2)1. 最佳置换算法(OPT) (2)2. 先进先出置换算法(FIFO) (3)3. 最近最久未使用置换算法(LRU) (3)五、系统结构说明 (3)1. 内存信息类(MemInfo) (5)2. 访问器(MemVisitor) (5)3. 加载器(MemLoader) (6)4. 页面走向列表类(MemReqs) (6)5. MemReplacement (6)六、数据结构说明 (6)1. 内存信息类(MemInfo) (6)2. 访问器(MemVisitor) (7)3. 加载器(MemLoader) (8)4. 页面走向列表类(MemReqs) (9)七、程序清单 (9)1. 访问器 (9)2. 加载器 (10)3. 最佳置换算法 (11)4. 先进先出算法 (13)5. 最近最久末使用算法 (13)八、使用说明书 (14)九、实验体会、建议 (17)十、参考文献 (17)一、设计题目页面置换算法模拟二、设计目的1、编写页面置换算法,实现计算机中页面置换的模拟。
2、通过算法模拟的实现,理解几种常用的页面置换算法的执行过程。
三、设计要求1、实现OPT,LRU,FIFO三种算法并进行对比分析。
2、要求界面简单,易懂,关键代码部分要注释。
3、编程语言可以采用自己任意精通的语言。
四、设计思想说明1. 最佳置换算法(OPT)最佳置换算法所选择的被淘汰掉的页面,将是以后永久不再使用的,或许是在最长(未来)时间内不再被访问的页面。
采用最佳置算法,通常可保证获得最低的缺页率。
本模拟算法中,最佳页面置换算法实现所采用的思想是:循环读入每个页表项,若该页表在内存中,则读取下一个页表项。
若页表不存在内存中:一种情况是内存不满,则将页表放入内存中;若内存块已满,刚分别计算内存中各个页表再次被使用的时间,并将最久不被访问的调出,放入当前读入页表项。
计算机操作系统页面置换算法模拟(DOC)

《计算机操作系统》课外实践报告题目:页面置换算法模拟班级: 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)算法模拟

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++;}
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);
操作系统页面置换
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
}
else{
if(isNotHave(need,i))
C=need;c=0;Text[3][i].setBackground(Color.red);m++;
}
}
else{
if(isNotHave(need,i)&&b>c){
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
广东海洋大学学生实验报告书(学生用表)
实验名称LRI•页而之后算法模拟课程名称操作系统课程号_______________ 学院(系)_______________________ 专业__________________ 班级 ____________________ 学生姓名_______ 学号 _________ 实验地点_________________ 实验日期 ________________
LRU页面置换算法模拟
一.实验目的
(1)掌握页式管理基本原理
(2)掌握LRU页而宜换算法
二.实验内容
(1)按照最近最久未使用页而置换算法(LRU)设计页而置换模拟程序。
(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=O;
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 Iru = new LRU();
lru.init();
lru.display();
}
public void init() {
try{
br = new BufferedReader(new InputStreamReader(System.in));
Jcatch (Exception e) {
e.printStackTrace();
System.exit(O);
}
blockCount = 3;
stack = new int[blockCount];
System.out.printlnC*请输入访问内存的块序列的个数为3门;
seriaCount = readlnt();
System.out.println(H i^入的访问序列是门;
address = readlntArray();
}
public void display!) {
boolean flag;
System.out.println(" --------------------------------------- ");
System.out.printC1^近最久未使用页面置换算法(LRU)页面豊换序列:") for (int i = 0; i< address.length; i++) {
intj=O;
flag =false;
int t, temp =addre^s[i];
while(stack[j] != address(i)) {
t= stack[j];
stack[j]= temp;
temp= t;
j++;
if(temp == 0 11 j == stack.length)
break;
}
if (j< stack.length) stack[j]= temp;
if (temp != 0&& j != stack.length)
flag= true;
try{ ng.Thread.sleep(SOO);
} catch(lnterruptedException e) { e.printStackTrace();
}
for (int m= 0; m < i - blockcount +1; m++) System.out.print(H”);
for (int m =0; m < stack length; m++) System.out.print(stack[m]+ " System.out.print(,7,);
if(flag){
num=num;
}
else{
num++;
}
}
System.out.printlnC'11);
System.out.printlnC'总缺页数:M+num); }
public int readlnt() {
try{
String s =br.readLine(); return Integer.parselnt(s);
} catch (Exception e) { return 3;
}
}
public int[] readlntArray() {
try{
String s =br.readLine(); System.out.println(s); String tmp(J= s.split(" ”);
int valued =new in t[tmp length];
for (int i =0; i < value.length; i++)
value(i]= lnteger.parselnt(tmp[i]);
return value;
} catch (Exception e) {
System.out.println(e);
return null;
}
}
}
五.实现结论
通过这次的实验,我对LRU页而置换算法有了更深的了解,LRU置换算法是理想性的算法,因为使用LRU苣换算法要花费很大的系统开销,所以在实际系统中并不会直接采用LRU算法。
本次实验通过java程序对LRU页面苣换算法的模拟,并没有设苣自动执行的功能,而且内存的块序列也得手动进行输入,在程序的设汁上没有完全达到实验的要求,但基本实现了实验要求的全部功能。