LRU页面调度算法实现

合集下载

OPT、FIFO、LRU算法的实现

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先来先服务,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)实现

操作系统页⾯置换算法(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中最先进⼊内存的页换出。

操作系统课程设计面置换算法LRU算法

操作系统课程设计面置换算法LRU算法

实验报告实验说明:执行程序时,当主存没有可用页面时,为了选择淘汰主存中的哪一页 面,腾出1个空闲块以便存放新调入的页面。

淘汰哪个页面的首要问题是 选择何种置换算法。

该程序采用LRU 方法选择,依置换策略选择一个可置 换的页面并计算它们的缺页率以便比较。

包括实验内容及条件) 主要参考书 计算机操作系统原理 操作系统 算法流程图:西安大学出版社 电子工业出版社 汤子涵主编 William Stallings 著主更算法流程图(包括实验步骤int ijndex=-l;for(i=0;i<M;i++){if(a[i]=-l){index=i;break:return index;void swap(int x){int i,k,temp,tempO;int index=isIn(xjeg|O]); /****判断x 是否在reg[O]数组中*******/if(index!=-l){reg[ 1 ][index]=reg[ 1 ] [index] A N; /**reg[ 1 ] [index]异或二进制数10000000**/}else{temp=isFull(reg[OJ);if(temp!=-l){ /*******内存没有满,直接调入页而************/reg[O][temp]=x;reg[ l][temp]=reg( l][tcnip]A N;}else if(temp==-l){k=min(reg[l ]);/**置换出寄存器中数值最小的对应的下标的页面***/tenipO=reg[O][k]; /*********临时保留要换出的页而号*****/ reg[O][k]=x;reg[l][k]=reg[l](kpN:printf(M the page %d is exchanged out!\n M,tempO);/******打印要置换出的页号** ******* *****/count++; /*********g 换次数加1 ♦*****♦*♦*****/ }}for(i=0;i<M;i++){reg[l][i]=reg[l][i]»l;/******** 寄存器中的所有数右移一位 *****/ }}niain(){ int x;system("cls");init();printfC^Input a sort of pages\n n); printf(v while you input -1 Jt will stop!\n H);scanf(M%d M,&x);/********输入页面号,宜到页而号为-!*♦*******/ while(x!=-l){num++; /*******输入的页而次数加1枠**#粋/swap(x);scanf(,r%d,\&x);}/** ****** *******打印缺页数和缺页率******* *** **** ****“$*/ printf(u the count of Exchanged is: %d \n H,count);printf(u the rate of exchanged is: %f\n,\count* 1.0/nuni); getch();)本次实践计划. 进度安排及完成情况05月09号商讨如何实现本次实验以及同学之间的分工. 05月10号査阅相关资料.05月16号~05月17号基本完成程序修改完善程序.代码测试.完成实验报告.主要测试方法及测试数据,包括测试结果及实验结果:Input a sort of pageswhile you input ~1 , it will stop! 712the page 7 is exchanged out!3the page 1 is exchanged out!4the page 2 is exchanged out!2the page 3 is exchanged out!43the page 0 is exchanged out!the page 2 is exchanged out!。

实验三 页面调度算法

实验三   页面调度算法

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

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

lru算法及例题讲解

lru算法及例题讲解

lru算法及例题讲解
摘要:
1.LRU算法简介
2.LRU算法原理
3.LRU算法应用
4.例题讲解
5.总结与拓展
正文:
一、LRU算法简介
最近最少使用(Least Recently Used,简称LRU)算法是一种缓存置换策略,用于决定在内存有限的情况下,如何淘汰已失效的缓存数据。

LRU算法基于一个假设:最近访问过的数据很可能会在不久的将来再次被访问。

因此,当内存有限且需要腾出空间时,优先淘汰最近访问过的数据。

二、LRU算法原理
LRU算法通过维护一个访问顺序来实现。

当一个数据被访问时,将其放入一个队列(或栈)中,并按照访问顺序进行排序。

当需要淘汰缓存时,从队尾(或栈顶)移除最近访问过的数据。

三、LRU算法应用
LRU算法广泛应用于计算机科学领域,如操作系统、浏览器缓存、数据库等领域。

通过使用LRU算法,可以有效提高缓存利用率,提高系统性能。

四、例题讲解
题目:一个含有n个元素的缓存,采用LRU算法进行缓存置换,求第k个访问的元素在缓存中的位置。

解题思路:
1.初始化一个长度为n的数组,表示每个元素在缓存中的位置。

2.模拟访问过程,每次访问一个元素,按照LRU算法进行置换,并记录访问顺序。

3.当访问第k个元素时,找到其在访问顺序中的位置,即为在缓存中的位置。

五、总结与拓展
LRU算法作为一种高效的缓存置换策略,在实际应用中具有重要意义。

了解LRU算法的原理和应用,可以帮助我们更好地解决实际问题。

LRU页面置换算法的改进与实现

LRU页面置换算法的改进与实现
p o o e n i r v d L a t e e t s dL U)p g e lc me t l rh I i b sd o mo Ma a e Unt r p s sa mp o e e s R c nl U e ( R y a e rpa e n ag i m. t s ae n Me w n g i MMU) a r s p g c es ot ( , co s a e a c s
第 3 卷 第 1 期 8 7
V0 . 8 13






21 0 2年 9月
S p e b r 201 e tm e 2
NO 1 .7
Co pu e gi e i g m t rEn ne rn
软件技 术 与数据 库 ・
文章编号:l 0 48 02 7_2—0 文献 0 —32( l)—0 4 4 o 2 1 o 标识码: A
[ sr c]T i lytei l naino mbd e iul mo a di rv ep r r n eo e ddvr a me  ̄,hspp r Abtat os i e tt f mp f h mp me o e ed dvr a me  ̄ n o et ef ma c fe d e iu l mo ti ae t mp h o mb t
[ ywo d ]It nt f hn s1T ; aerpae n loi m; e sR cnl e (RU ;mpo e lc l rh o ef w itr pin Ke r s ne e T ig( )p g elcme t g rh L at ee t UsdL ) i rv dCo kag i m; vr o er t ; r o o a t y ot l n u o

操作系统页面调度算法

操作系统页面调度算法
int Bfor_ArryFull(struct ye b[N],struct ye a[M],int c[N])
{
int i;
printf("请输入作业序号(9个页面并用空格隔开):\n");
for(i=0;i<N;i++) scanf("%d",&b[i].Ye_Hao);
printf("发生缺页的面号分别为:\n");
int j,ii=0;
for(j=1;j<N;j++)
{int f=0;
for( k=0;k<=ii;k++)
{
if(b[j]==a[k]) {f=1;break;}中断
{
printf("%d ",b[j]);//打印缺页的页号
count++;
a[0].Ye_Hao=b[0].Ye_Hao;
a[0].falg=0;
b[0].falg=0;
printf("%d ",b[0].Ye_Hao);
int ii=0;
int k,j;
count++;
for(j=1;j<N;j++)
{int flag=0;
for( k=0;k<=ii;k++)
{
if(b[j].Ye_Hao==a[k].Ye_Hao) {flag=1;break;}//包含在中间找到,在末尾找到
五、实验操作过程及实验结果记录
1、FIFO页面置换算法:
此算法的思想是按照作业到来的顺序进行处理,以下是源代码,代码已经调试,可上机运行。

lru算法的实现过程,python

lru算法的实现过程,python

LRU算法是一种常用的缓存淘汰策略,LRU全称为Least Recently Used,即最近最少使用。

它的工作原理是根据数据的历史访问记录来淘汰最近最少使用的数据,以提高缓存命中率和性能。

在Python中,可以通过各种数据结构和算法来实现LRU算法,例如使用字典和双向链表来实现LRU缓存。

一、LRU算法的基本原理LRU算法是基于"最近最少使用"的原则来淘汰缓存中的数据,它维护一个按照访问时间排序的数据队列,当缓存空间不足时,会淘汰最近最少使用的数据。

LRU算法的基本原理可以用以下步骤来说明:1. 维护一个有序数据结构,用来存储缓存中的数据和访问时间。

2. 当数据被访问时,将其移动到数据结构的最前面,表示最近被使用过。

3. 当缓存空间不足时,淘汰数据结构最后面的数据,即最近最少使用的数据。

二、使用Python实现LRU算法在Python中,可以使用字典和双向链表来实现LRU算法。

其中,字典用来存储缓存数据,双向链表用来按照访问时间排序数据。

1. 使用字典存储缓存数据在Python中,可以使用字典来存储缓存数据,字典的键值对可以用来表示缓存的键和值。

例如:```cache = {}```2. 使用双向链表按照访问时间排序数据双向链表可以按照访问时间对数据进行排序,使得最近被访问过的数据在链表的最前面。

在Python中,可以使用collections模块中的OrderedDict来实现双向链表。

例如:```from collections import OrderedDict```3. 实现LRU算法的基本操作在Python中,可以通过对字典和双向链表进行操作来实现LRU算法的基本操作,包括缓存数据的存储、更新和淘汰。

以下是LRU算法的基本操作示例:(1)缓存数据的存储当缓存数据被访问时,可以将其存储到字典中,并更新双向链表的顺序。

例如:```def put(key, value):if len(cache) >= capacity:cache.popitem(last=False)cache[key] = value```(2)缓存数据的更新当缓存数据被再次访问时,可以更新其在双向链表中的顺序。

LRU页面调度算法实现

LRU页面调度算法实现

LRU页面调度算法实现学院计算机科学与技术专业计算机科学与技术学号学生姓名指导教师姓名2014年3月16 日目录1.实验要求 (2)2.实验目的 (2)3.实验内容 (2)4.相关知识 (2)5.实验原理 (3)6.流程图 (4)7.源代码 (5)8.运行结果 (9)9.实验心得 (10)10.参考文献 (11)LRU页调度算法实现一实验要求:1.不同的功能使用不同的函数实现(模块化),对每个函数的功能和调用接口要注释清楚。

对程序其它部分也进行必要的注释。

2.对系统进行功能模块分析、画出总流程图和各模块流程图。

3.用户界面要求使用方便、简洁明了、美观大方、格式统一。

所有功能可以反复使用,最好使用菜单。

4.通过命令行相应选项能直接进入某个相应菜单选项的功能模块。

5.所有程序需调试通过。

二实验目的:将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。

进一步巩固和复习操作系统的基础知识。

培养学生结构化程序、模块化程序设计的方法和能力。

提高学生调试程序的技巧和软件设计的能力。

提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。

三实验内容:程序应模拟实现LRU 算法思想,对n个页面实现模拟调度。

四相关知识:1.虚拟存储器的引入:局部性原理:程序在执行时在一较短时间内仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。

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

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

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

五.实验原理:目前有许多页面调度算法,本实验主要涉及最近最久未使用调度算法。

lru页面调度算法c语言实现

lru页面调度算法c语言实现

lru页面调度算法c语言实现LRU页面调度算法是一种常用的页面置换算法,它根据页面的历史使用情况来决定淘汰哪一页。

LRU全称是Least Recently Used,即最近最少使用。

该算法的核心思想是,当需要淘汰一页时,选择最近最久未被使用的页面进行淘汰,以便为新的页面让出空间。

在实际的计算机系统中,内存空间是有限的,而程序需要的内存空间往往远远超过可用的内存空间。

为了解决这个问题,操作系统采用了虚拟内存的技术,将程序所需的内存空间分为若干个页面,每个页面的大小固定,通常为4KB或者8KB。

当程序运行时,操作系统将程序所需的页面加载到内存中,如果内存空间不足,则需要进行页面置换。

LRU页面调度算法是一种比较简单有效的页面置换算法。

它的基本原理是,当需要淘汰一页时,选择最久未使用的页面进行淘汰。

为了实现这个目标,操作系统通常使用一个数据结构来记录页面的使用情况,比如一个链表或者一个队列。

每当程序访问一个页面时,操作系统就将该页面移到链表或者队列的头部,这样就保证了链表或者队列的尾部是最久未使用的页面。

当需要淘汰一页时,操作系统就选择链表或者队列的尾部页面进行淘汰。

这是因为,尾部页面是最久未使用的页面,它的使用频率最低,淘汰它对程序的影响最小。

淘汰完页面后,操作系统将新的页面加载到内存中,并将新的页面插入到链表或者队列的头部。

LRU页面调度算法的优点是,它能够比较准确地预测页面的使用情况。

当程序的访问模式具有局部性时,即程序往往会连续访问相邻的页面,LRU算法能够将这些页面保留在内存中,从而提高程序的执行效率。

另外,LRU算法的实现比较简单,只需要维护一个链表或者队列即可。

然而,LRU页面调度算法也存在一些问题。

首先,LRU算法需要维护一个链表或者队列,这会占用一定的内存空间。

其次,LRU算法需要频繁地更新链表或者队列,这会增加操作系统的开销。

最后,当程序的访问模式不具有局部性时,LRU算法的效果会大打折扣,因为它无法准确地预测页面的使用情况。

操作系统页面调度算法程序实验报告

操作系统页面调度算法程序实验报告

操作系统页面调度算法程序实验报告一、实验背景操作系统是计算机系统中最重要的组成部分之一,它负责管理计算机的资源、协调各个程序的运行和提供用户与计算机之间的接口。

而页面调度算法则是操作系统中非常重要的一个部分,它主要用于管理内存中的页面,以提高计算机系统的性能和效率。

二、实验目的本次实验旨在通过编写一个页面调度算法程序,深入理解操作系统中页面调度算法的原理和实现方法,并掌握如何使用C语言进行程序设计和开发。

三、实验原理1. 页面调度算法概述在操作系统中,为了提高内存利用率和进程执行效率,通常会将进程所需的数据或指令分割成多个大小相等的块(即“页面”),并将这些页面存储到内存中。

当进程需要访问某个页面时,如果该页面已经在内存中,则直接访问即可;如果该页面不在内存中,则需要进行“缺页处理”,将其从磁盘读入内存,并将其中一个已经在内存中但未被访问过一段时间的页面替换出去。

而为了确定应该替换哪个页面,就需要使用一种称为“页面调度算法”的技术来进行决策。

常见的页面调度算法有FIFO、LRU、LFU等。

2. FIFO算法FIFO(First In First Out)算法是最简单的页面调度算法之一,它的原理是将最先进入内存的页面替换出去。

具体来说,当一个新页面需要进入内存时,如果内存已经满了,则将最先进入内存的页面替换出去,并将新页面插入到队列末尾。

3. LRU算法LRU(Least Recently Used)算法是一种比较常用的页面调度算法,它的原理是根据页面最近被访问的时间来进行决策。

具体来说,当一个新页面需要进入内存时,如果内存已经满了,则将最近访问时间最早且未被修改过的页面替换出去,并将新页面插入到队列末尾。

4. LFU算法LFU(Least Frequently Used)算法是一种根据页面使用频率来进行决策的调度算法。

具体来说,当一个新页面需要进入内存时,如果内存已经满了,则将使用频率最低的那个页面替换出去,并将新页面插入到队列末尾。

模拟页面置换算法FIFO、LRU的实现

模拟页面置换算法FIFO、LRU的实现

实验报告五实验名称:模拟页面置换算法FIFO、LRU的实现日期:2015-12-9 班级:13级计科学号:姓名:一、实验目的了解页面置换的概念,理解页面置换的算法加深对页面置换算法的理解。

二、实验内容Java编程语言实现FIFO和LUR页面算法。

三、项目要求与分析FIFO算法当需要置换页面时,主要通过置换最早进入内存的页面从而达到先进先出的目的。

LRU算法当需要置换页面时,主要通过置换进入内存中最久没有被访问的页面而达到最近最久未使用的目的。

程序中可以通过标志位进行记录。

四、具体实现1.FIFO算法实现代码以及运行结果:public class FIFO {/*** 内存块的个数*/public static int N ;/*** 内存块数组*/Object[] array = new Object[N];/*** 要访问的页面数组*/public static int[]visit;private int size;/*** 内存是非空为否* @return*/public boolean isEmpty() {if(0 == size)return true;elsereturn false;}/*** 内存是非空满* @return*/public boolean isFulled() {if(size >= N)return true;elsereturn false;}/*** 元素(页框)的个数* @return*/public int size() {return size;}/*** 查找元素o在数组中的位置* @param o* @return*/public int indexOfElement(Object o) { for(int i=0; i<N; i++) {if(o == array[i]) {return i;}}return -1;}/*** 页面转换* @param obj*/public Object trans(Object obj){Object e = null;int t = 0;if(indexOfElement(obj) != -1) {t = indexOfElement(obj);for(int i=t; i<size-1; i++) {array[i] = array[i+1];}array[size-1] = obj;} else {if(!isFulled()){array[size] = obj;size ++;} else {for(int i=0; i<size-1; i++) {array[i] = array[i+1];}array[size-1] = obj;}}if( -1 == t) {return null;} else {return array[t];}}/*** 输出内存区中的各数据*/public void showMemoryBlock() {for(int i=0; i<size; i++) {System.out.print(array[i] + " "); }}/*** 清空队列(页框)*/public void clear(){}/*** @param args*/public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.print("请输入内存块的数量:");N=sc.nextInt();System.out.print("请输入总页面数目:");int n=sc.nextInt();visit=new int[n];System.out.println("请输入各个页的页面号码:");for(int i=0;i<n;i++)visit[i]=sc.nextInt();FIFO fifo = new FIFO();for(int i=0; i<visit.length; i++) {fifo.trans(visit[i]);fifo.showMemoryBlock();System.out.println();}运行结果:2.LUR算法实现代码以及运行结果:public class LRU {static int volum;// 栈的容量static List<Integer>list=new LinkedList<Integer>();//链表用来模拟栈存放页面static int[]visit;//要访问的页面数组static int count=0;//记录缺页次数public static void main(String []args){Scanner sc = new Scanner(System.in);System.out.print("请输入栈的容量:");volum=sc.nextInt();System.out.print("请输入总页面数目:");int n=sc.nextInt();visit=new int[n];System.out.println("请输入各个页的页面号码:");for(int i=0;i<n;i++)visit[i]=sc.nextInt();sLRU();//调用最近最久未使用算法System.out.println("置换页面的数目为:"+count);}public static void sLRU(){int index=0;while(index<visit.length){boolean flag=false;if(list.size()<=volum){for(int i=0;i<list.size();i++){if((int)(list.get(i))==visit[index]){list.remove(i);//先删除list.add(visit[index]);//再添加到尾部flag=true;break;}}if(!flag){if(list.size()<volum){//如果栈未满,而且此页面没有在栈中,就将它入栈list.add(visit[index]);}else{//如果栈已经满了,且该页面号码没有在栈中,就把栈底元素删除,将新页插入int temp=list.get(0);list.remove(0);//最开始一个换出list.add(visit[index]);//加到末尾count++;System.out.println("开始换页了,将栈底的"+temp+"换出"); System.out.println("这也是没有办法的事情,毕竟栈是有限的");}}System.out.print("经过第"+(index+1)+"个页面的栈内容为");for(int k=0;k<list.size();k++)System.out.print(list.get(k)+" ");System.out.println();index++;}运行结果:五、所遇问题与解决方法问题:针对于FIFO算法定义选择在内存中驻留时间最久的页面予以淘汰,对于内存中的驻留时间理解复杂了不知道如何下手。

LRU算法实现方法及参数调优策略

LRU算法实现方法及参数调优策略

LRU算法实现方法及参数调优策略LRU (Least Recently Used)算法是一种常用的页面置换算法,被广泛应用于操作系统的内存管理中。

LRU算法根据页面的使用历史,将最久未被访问的页面替换出内存。

本文将介绍LRU算法的实现方法,并探讨如何通过参数调优来提升其性能。

一、LRU算法实现方法LRU算法的核心思想是根据页面的访问历史进行页面置换,具体的实现方法如下:1. 使用双向链表:建立一个带有头尾指针的双向链表,链表的节点表示页面。

最近访问的页面位于链表的头部,最久未被访问的页面位于链表的尾部。

2. 使用哈希表:对每个页面建立哈希表,以便快速查找页面在链表中的位置。

3. 页面访问时的操作:当一个页面被访问时,分为以下情况:- 若页面在链表中不存在,则将其插入链表头部。

- 若页面在链表中已存在,则将其从原位置删除,并插入到链表头部。

4. 替换页面:当内存已满,需要替换页面时,将链表尾部的页面删除即可。

二、参数调优策略为了进一步提升LRU算法的性能,我们可以通过调优一些参数来达到优化的目的。

下面是一些常用的参数调优策略:1. 缓存大小的设置:缓存大小是指可以存储在内存中的页面数量。

通常来说,缓存越大,缺页率越低,程序性能越好。

但是,过大的缓存大小也会占用更多的内存资源,需要权衡考虑。

2. 缓存淘汰策略:除了LRU算法,还有其他的缓存淘汰策略,如FIFO算法和LFU算法。

FIFO算法简单地按照页面到达的顺序进行页面替换,而LFU算法根据页面的使用频率进行页面替换。

根据不同的应用场景选择合适的缓存淘汰策略。

3. 硬件支持:在一些高性能系统中,可以使用硬件支持来加速LRU 算法的实现。

例如,在现代的处理器中,可以使用相关指令或硬件数据结构来提高对LRU链表的操作效率。

4. 缓存预加载:根据应用的特性,可以在系统启动或初始化阶段将一些常用的页面预先加载到缓存中,以减少缺页率和提高系统性能。

5. 自适应调整:根据实际应用的场景和需求,可以根据运行时的统计信息和监控数据进行动态调整,以适应不同的负载情况和访问模式。

lru页面置换算法实验c语言总结

lru页面置换算法实验c语言总结

LRU页面置换算法实验C语言总结1.引言在计算机科学中,页面置换算法是解决主存容量有限的情况下,如何有效地管理页面(或称为内存块)的一种重要方法。

L RU(L ea st Re ce nt ly Us e d)页面置换算法是其中一种经典的策略,通过淘汰最久未使用的页面来提高内存的利用率。

本文将总结使用C语言实现L RU页面置换算法的相关实验。

2.算法原理L R U页面置换算法的核心思想是:最近被访问的页面可能在未来继续被访问,而最久未被使用的页面可能在未来也不再被访问。

基于这一思想,L R U算法维护一个页面访问的时间顺序链表,每次发生页面置换时,选择链表头部(即最久未使用)的页面进行淘汰。

3.实验设计本次实验旨在使用C语言实现LR U页面置换算法,并通过模拟页面访问的过程来验证算法的正确性。

具体设计如下:3.1数据结构为了实现LR U算法,我们需要定义几个关键的数据结构:3.1.1页面节点结构t y pe de fs tr uc tP age{i n tp ag eI D;//页面I Ds t ru ct Pa ge*n ex t;//下一个节点指针s t ru ct Pa ge*p re v;//上一个节点指针}P ag e;3.1.2内存块结构t y pe de fs tr uc tM emo r y{i n tc ap ac it y;//内存块容量i n ts iz e;//当前存储的页面数量P a ge*h ea d;//内存块链表头指针P a ge*t ai l;//内存块链表尾指针}M em or y;3.2实验步骤本次实验主要包括以下几个步骤:3.2.1初始化内存块根据实际需求,设置内存块的容量,并初始化链表头指针和尾指针。

3.2.2页面置换每次发生页面访问时,检查访问的页面是否已经在内存块中。

如果在,将该页面移动到链表尾部;如果不在,执行页面置换。

3.2.3页面淘汰当内存块已满时,选择链表头部的页面进行淘汰,将新访问的页面加入链表尾部。

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

操作系统_页面置换算法FIFO,OPT,LRU实现
for(intk = 0; k<3; k++)
cout <<frame[k].num <<&#39; &#39;;
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算法)

页面置换算法(FIFO算法,LRU算法)

实验四页面置换算法一、实验流程图二、实验程序#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define null 0#define len sizeof(struct page)struct page{ int num;int tag;struct page *next;};struct page *create(int n) /*建立分配的内存空间,并初始化,返回头结点*/{int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len); //开辟一个新的单元,并将malloc返回的指针转换为结构体类型的指针p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;struct page *cp,*dp,*head,*new1;int count=0;head=create(n);p=array;while(*p!=-1){ cp=dp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if (cp->num==*p) printf(" ! " );else{ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){cp->num=*p;printf(" * ");}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*new1,*endp;head=create(n);while(*p!=-1){cp=dp=rp=endp=head;for(;endp->next!=null;) endp=endp->next;for(;cp->num!=*p&&cp->next!=null;){rp=cp;cp=cp->next;}if(cp->num==*p){printf(" ! ");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;{printf(" * ");cp->num=*p;cp->tag=0;}else{new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*new1;p=array;head=create(n);while(*p!=-1){ cp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if(cp->num!=*p){ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){printf(" * ");cp->num=*p;cp->tag=0;}else{ i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){ for(;*q!=cp->num&&cp->next!=null;) cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){for(;cp->tag!=0;) cp=cp->next;printf(" %d ",cp->num);cp->num=*p;}else{ cp=head;for(;cp->tag!=0;) cp=cp->next;if(cp==head){ for(;cp->next!=null;) cp=cp->next;new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}else{ printf(" %d ",cp->num);cp->num=*p;}}cp=head;for(;cp->next!=null;) {cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf(" ! ");p++;}printf("\nQueye Zongshu : %d \n",count);}main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Cann't open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF)/*将数字字符串转化成整型-开始*/ {if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1) break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n') break;else{space=1;j++;i=0;}}}}}/*结束*/if(pt==EOF) {str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1) {printf(" %d ",page[i]);i++;}fclose(fp);printf("\n");printf(" ! : mean no moved \n * : mean have free space \n\n"); printf("FIFO ");FIFO(page,3);printf("\nLRU ");LRU(page,3);printf("\nOPT ");OPT(page,3);}。

用JAVA实现操作系统先进先出和LRU调度算法

用JAVA实现操作系统先进先出和LRU调度算法

FIFO调度算法的实现======================================================================= //1:访问内存//如果在内存,输出//如果不在内存,判断内存是否已满//如果满了,将第一个元素挤出,其他元素迁移,再把访问的元素放入队尾//再将内存中的元素输出//如果没满,找到第一个内存空快,并把元素放入该空快,跳出//输出内存中的元素import java.util.*;public class fifo {private static final String end = null;int[] page;int[] ram;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)//判断输入的页面号范围{i nt exit_element;f or(int i=0;i<=ram.length-1;i++){exit_element=ram[i];//////if (exit_element==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;//跳出}}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; //页面调入内存f or(int r=0; r<=ram.length-1;r++)//输出内存页面中的{System.out.print(" "+ram[r]);}b reak; //跳出循环体,visitpage结束}/////////////else{}}}//访问页面越界elseS ystem.out.println("\n 页面访问不存在!");}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);}}}运行结果:请输入页面数:8请输入内存块的个数:4请输入访问的页面号11 null null null请输入访问的页面号31 3 null null请输入访问的页面号1 3 4 null请输入访问的页面号51 3 4 5请输入访问的页面号63 4 5 6请输入访问的页面号33 4 5 6请输入访问的页面号43 4 5 6请输入访问的页面号74 5 6 7请输入访问的页面号8页面访问不存在!请输入访问的页面号35 6 7 3请输入访问的页面号2LRU调度算法的实现//1:访问内存//如果在内存,将它后面的非空块的值往前移,它放入最后一个非空块,再输出//如果不在内存,判断内存是否已满//如果满了,将第一个元素挤出,其他元素迁移,再把访问的元素放入队尾//再将内存中的元素输出//如果没满,找到第一个内存空快,并把元素放入该空快,跳出//输出内存中的元素import java.util.*;public class lru {private static final String end = null;int[] page;int[] ram;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)//判断输入的页面号范围{i nt exit_element;f or(int i=0;i<=ram.length-1;i++){exit_element=ram[i];//////if (exit_element==a)//内存中存在访问的页面{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;//跳出}}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++)//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{}}}//访问页面越界elseS ystem.out.println("\n 页面访问不存在!");}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);}}}运行结果:请输入页面数:8请输入内存块的个数:4请输入访问的页面号11 null null null请输入访问的页面号21 2 null null请输入访问的页面号31 2 3 null请输入访问的页面号21 32 null请输入访问的页面号13 2 1 null请输入访问的页面号53 2 1 5请输入访问的页面号62 1 5 6请输入访问的页面号52 1 6 5请输入访问的页面号8页面访问不存在!。

lru算法实验报告

lru算法实验报告

实验二模拟LRU页面置换算法一、实验目的1)用C或C++模拟LRU页面置换算法2)掌握LRU页面置换算法的调度过程二、实验内容设计一个虚拟存储系统,编写程序模拟LUR页面置换算法,通过程序输出淘汰的页面并计算出命中率:示列:随机输入页面访问串:7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1随机输入内存驻留集大小:3 (驻留集初始状态为空)三、实验要求要求访问页面号、驻留集都是随机输入,驻留集初始状态下为空。

实验代码:#include<iostream>using namespace std;int judge(int q[],int rear,int front,int num){for(int i = rear; i < front; i++){if(q[i] == num){return i;}}return -1;}void f(int q[],int rear,int t){for(int i = t; i > rear; i--){q[i] = q[i-1];}}void show(int q[],int rear,int front){for(int i = rear; i <= front; i++)cout << q[i] << " ";cout << endl;}void deal(int a[],int n,int m){int rear = 0;int front = -1;int q[m];int temp = 0;int count = 0;for(int i = 0; i < n; i++){int t = judge(q,rear,front,a[i]);q[++front]=a[i];if(temp < m){if(t != -1){f(q,rear,t);cout << a[i] << "命中" << endl; rear++;count++;}else{temp++;}}else{if(t != -1){f(q,rear,t);cout << a[i] << "命中" << endl; rear++;count++;}else{cout << q[rear] << "淘汰" << endl;rear++;}}}cout << "命中率为:" << count << "/" << n;}int main(){int n;int m;cout << "请输入要访问的页面序列个数:";cin >> n ;cout << "请输入驻留值的大小:";cin >> m;int a[n];cout << "请输入要访问的" << n << "个页面序列" << endl; for(int i = 0; i < n;i++){cin >> a[i];}deal(a,n,m);}运行结果:。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

LRU页调度算法实现学院计算机科学与技术专业计算机科学与技术学号学生姓名指导教师姓名2014年3月15日一、设计目的、内容与要求(一)目的:操作系统课程设计是计算机专业重要的教学环节,为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。

(1)进一步巩固和复习操作系统的基础知识。

(2)培养学生结构化程序、模块化程序设计的方法和能力。

(3)提高学生调试程序的技巧和软件设计的能力。

(4)提高学生分析问题、解决问题以及综合利用C语言进行程序设计的能力。

(二)内容:程序应模拟实现LRU算法思想,对n个页面实现模拟调度。

(三)要求:1.不同的功能使用不同的函数实现(模块化),对每个函数的功能和调用接口要注释清楚。

对程序其它部分也进行必要的注释。

2.对系统进行功能模块分析、画出总流程图和各模块流程图。

3.用户界面要求方便、简洁明了、美丽大方、格式统一。

所有功能可以反复使用,最好使用菜单。

4.通过命令相应选项能直接进入某个相应菜单选项的功能模块。

所有程序需调试通过。

二、算法的基本思想LRU是Least Recently Used 近期最少使用算法。

内存管理的一种页面置换算法,对于在内存中但又不用的数据块(内存块)叫做LRU,Oracle会根据哪些数据属于LRU而将其移出内存而腾出空间来加载另外的数据。

什么是LRU算法?LRU是Least Recently Used的缩写,即最少使用页面置换算法,是为虚拟页式存储管理服务的。

关于操作系统的内存管理,如何节省利用容量不大的内存为最多的进程提供资源,一直是研究的重要方向。

而内存的虚拟存储管理,是现在最通用,最成功的方式——在内存有限的情况下,扩展一部分外存作为虚拟内存,真正的内存只存储当前运行时所用得到信息。

这无疑极大地扩充了内存的功能,极大地提高了计算机的并发度。

虚拟页式存储管理,则是将进程所需空间划分为多个页面,内存中只存放当前所需页面,其余页面放入外存的管理方式。

程序中用到了if,switch选择语句,和for循环语句进行编程。

If语句基本格式为:If (表达式)语句1else语句2Switch语句基本格式为:Switch (表达式){case 常量表达式1;语句序列1case 常量表达式2;语句序列2 }三、主要功能模块流程图(1)主菜单流程图:Init;I=0I <blockYPrintf(“%d”,Fuzhu[i];)I ++NPrintf(“\n”)(2)main函数流程图:开始进入主菜单是否输入为“1”自定义块数和进程数Y是否输入为“4”是否输入为“2”是否输入为“3”N显示进程数和块数Y进入LRU 算法Y退出YN结束NN(3)LRU 程序流程图:开始页数是否已满?该页是否在物理块中更新时间找到最久的页面,更新时间,置换退出LRU算法结束Y YN N(4)自定义函数流程图:Init;I=0I <pageNumPages[i]=rand()%100;I ++YGetchar90;N 四、系统测试(1)显示主菜单:(2)选择1:(3)选择3:(4)选择1:(4)输入要修改块的:五、结论通过这两周的课设,我不仅复习了C语言的相关知识,还对操作系统有了进一步的理解和掌握。

实验中,通过LRU(最近最久未使用)算法实现了页面调度模拟实验。

LRU与其他几种调度算法在原理上既有区别又有联系。

要想充分掌握LRU算法,也要会使用其他几种算法。

虽然在程序设计中,出现了一些错误,但是经过同学的帮助和辅导老师的细心指导,我已经将错误纠正了。

使程序达到预想的结果,能够实现简单的页面调度。

通过此次实验,我发现自己在编程方面还有许多不足的地方,以后要多加动手编写,提高自己的编程能力。

最后感谢同学的帮助和辅导老师的悉心指导,使我顺利完成此次实验。

六、源程序#include <stdio.h>#include <stdlib.h>#include <time.h>#define Maxsize 50void Xiugaikuaishu();void Inition();void Zidingyi();void ShowCustomer();void ShowResult();void ShowNot();void LRU();int menu_select(); //菜单函数int pageNum = 0;int pages[Maxsize];//存储页号int Fuzhu[Maxsize];//辅助数组int Time[Maxsize];//记录页在内存中的时间int physicalblock;//记录物理块数int Fz;//辅助变量int main(){for(;;){switch(menu_select()){case 1: Zidingyi();break;case 2: ShowCustomer();break;case 3: LRU();break;case 4:exit(0);}}return 0;}int menu_select(){int n;printf("***************欢迎进入主界面*****************\n");printf("* 请求页式存储管理中LRU算法的实现*\n");printf("* *\n");printf("* 1.自定义进程数和块数*\n");printf("* 2.显示用户自定义*\n");printf("* 3.LRU算法*\n");printf("* 4.EXIT *\n");printf("* *\n");printf("**********************************************\n");do{printf("\n输入你的选择(1~4):");scanf("%d",&n);}while(n<1||n>4);return(n);}void Zidingyi(){int i;system("cls");printf("**********************************************\n");printf(" 页式储存管理-LRU算法\n");printf("**********************************************\n");printf("--------------自定义进程数和块数--------------\n");printf("请输入进程数:");scanf("%d",&pageNum);getchar();printf("请输入块数:");scanf("%d",&physicalblock );getchar();printf("请依次输入页号引用串(中间用空格隔开):");for(i = 0 ; i < pageNum ; i++)scanf("%d",&pages[i]);}void LRU(){int i,j;int ReplacePages = 0;//记录置换次数printf("***********************************************\n");printf("------------------LRU算法结果显示--------------\n");printf("\n");ShowNot();for(i = Fz ; i < pageNum; i++){int key = 0;for(j = 0 ; j < physicalblock ; j++)//判断该页是否在物理块中{if(Fuzhu[j] == pages[i]){key = 1; //该页在内存中Time[j] = i;//更新时间break;}}if(key == 0)//若该页不在内存中{ReplacePages++; //缺页次数加1int min = Time[0];int flag = 0;for(j = 1 ; j < physicalblock ; j++){if(min > Time[j]){min = Time[j];//找到最久的页面flag = j;}}Time[flag] = i;//记录时间Fuzhu[flag] = pages[i];ShowResult();}}printf("页面总数为:%d\n",pageNum);printf("置换次数为:%d\n",ReplacePages);double re1 = ((double)ReplacePages)/((double)pageNum);printf("置换率为:%.2lf\n",re1);printf("命中率为:%.2lf\n",1-re1);printf("缺页次数为:%d \n",ReplacePages+physicalblock);double re2 = ((double)(ReplacePages+physicalblock))/((double)pageNum); printf("缺页率为:%.2lf\n",re2);printf("***********************************************\n");printf("-----------按1修改块数,按2返回主菜单----------\n");printf(" \n");printf(" Yes--1,No--2 \n");int la;scanf("%d",&la);if(la==1){Xiugaikuaishu();}else{printf("********************************************\n");printf("--------------------------------------------\n");system("cls");}}void ShowResult()//显示每次换页后的结果{int i;for(i = 0 ; i < physicalblock ; i++){printf(" %d",Fuzhu[i]);}printf("\n");}void Xiugaikuaishu(){system("cls");printf("*************************************************\n");printf("--------------请输入需要修改块的数目-------------\n");{int a;scanf("%d",&a);physicalblock = a;}ShowCustomer();//显示自定义页面信息LRU();}void ShowCustomer()//显示用户自定义的进程数和块数{system("cls");int i;printf("**************************************************\n");printf("----------------------显示------------------------\n");printf("进程数为: %d\n",pageNum);printf("页号分别为: ");for(i = 0 ; i < pageNum ; i++){printf("%d ",pages[i]);}printf("\n");printf("可用物理块数为: %d\n",physicalblock);printf("****************************************************\n");printf("----------------按任意键可返回主菜单----------------\n");getchar();}void ShowNot()//显示一定不用换页的部分{Fz = physicalblock;int i,j,k=0,key = 0;for(i = 0 ; i < Fz ; i++){int flag = 0;for(j = 0 ; j <= i-1 ; j++){if(Fuzhu[j] == pages[i]){Time[j] = i;flag = 1;Fz = Fz+1;key++;}}if(flag == 0){Time[k] = i;Fuzhu[k] = pages[i];k++;for(j = 0 ; j <= i-key ; j++){printf(" %d",Fuzhu[j]);}printf("\n");}}}感谢下载!欢迎您的下载,资料仅供参考。

相关文档
最新文档