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

合集下载

操作系统 课程实验-实验四页式虚拟存储管理中地址转换和缺页中断

操作系统 课程实验-实验四页式虚拟存储管理中地址转换和缺页中断

实验四页式虚拟存储管理中地址转换和缺页中断一、实验目的深入了解页式存储管理如何实现地址转换;进一步认识页式虚拟存储管理中如何处理缺页中断。

二、实验预备知识页式存储管理中地址转换的方法;页式虚拟存储的缺页中断处理方法。

三、实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。

实验具体包括:首先对给定的地址进行地址转换工作,若发生缺页则先进行缺页中断处理,然后再进行地址转换;最后编写主函数对所做工作进行测试。

假定主存64KB,每个主存块1024字节,作业最大支持到64KB,系统中每个作业分得主存块4块。

四、提示与讲解页式存储管理中地址转换过程很简单,假定主存块的大小为2n字节,主存大小为2m'字节和逻辑地址m位,则进行地址转换时,首先从逻辑地址中的高m-n位中取得页号,然后根据页号查页表,得到块号,并将块号放入物理地址的高m'-n位,最后从逻辑地址中取得低n位放入物理地址的低n位就得到了物理地址,过程如图6所示。

逻辑地址图6 页式存储管理系统地址转换示意图地址转换是由硬件完成的,实验中使用软件程序模拟地址转换过程,模拟地址转换的流程如图7所示(实验中假定主存64KB,每个主存块1024字节,即n=10,m'=16,物理地址中块号6位、块内地址10位;作业最大64KB,即m=16,逻辑地址中页号6位、页内地址10位)。

在页式虚拟存储管理方式中,作业信息作为副本放在磁盘上,作业执行时仅把作业信息的部分页面装入主存储器,作业执行时若访问的页面在主存中,则按上述方式进行地址转换,若访问的页面不在主存中,则产生一个“缺页中断”,由操作系统把当前所需的页面装入主存储器后,再次执行时才可以按上述方法进行地址转换。

页式虚拟存储管理方式中页表除页号和该页对应的主存块号外,至少还要包括存在标志(该页是否在主存),磁盘位置(该页的副本在磁盘上的位置)和修改标志(该页是否修改过)。

详解页式管理置换算法FIFO_LRU_OPT

详解页式管理置换算法FIFO_LRU_OPT

页式管理OPT、LRU、FIFO置换算法详解指令:1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6若内存最多容纳4个页面,则……一、OPT(理想型淘汰)算法该算法无法实现。

置换规则:(1)淘汰内存中以后不再访问的页面;(2)如果没有(1),则淘汰将要访问指令之后的将来最迟被访问的指令的页面。

分析:(1)当访问5时,内存1,2,3,4,发生第5次中断,淘汰不再访问的4,换入5,内存1,2,3,5;(2)当访问6时,内存1,2,3,5,发生第6次中断,淘汰不再访问的5,换入6,内存1,2,3,6;(3)当访问7时,内存1,2,3,6,发生第7次中断,由于之后的指令(1、2、3、6)都是现在内存页面都存在的指令,无法淘汰,但可以根据指令访问顺序,先淘汰将来最迟被访问的1,换入7,置换后的内存7,2,3,6;(4)当访问1时,内存7,2,3,6,发生第8次中断,淘汰不再访问的7,换入1,内存1,2,3,6;即OPT算法一共会出现8次缺页中断。

二、LRU(最近最久未使用)算法该算法利用堆栈实现,每次访问都调整堆栈中页面顺序。

把被访问页面从栈移出再压入栈顶。

置换规则:(1)栈顶始终为最新访问过的页面;(2)栈底始终为最近最久未被访问的页面;(3)访问存在的页面要调到栈顶。

分析:(1)访问第5个指令2时,由于内存页面中已经存在2,所以不置换,但调整2在栈中顺序,即将2调到栈顶,其它页面依次后置。

调整前内存4,3,2,1,调整后内存2,4,3,1;(2)访问第7个指令5时,发生第5次中断,原内存1,2,4,3,淘汰栈底3,栈顶调入5,调整后内存5,1,2,4;(3)访问第8个指令6时,发生第6次中断,原内存5,1,2,4,,淘汰栈底4,栈顶调入6,调整后内存6,5,1,2;……即LRU算法一共会出现10次缺页中断。

三、FIFO(先进先出)算法该算法利用队列实现。

FIFO与LRU的区别是FIFO遇到内存中存在的页面不需要调换页面顺序。

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条指令。

模拟请求页式存储管理中硬件的地址转换和缺页中断处理

模拟请求页式存储管理中硬件的地址转换和缺页中断处理

一.实验内容模拟请求页式存储管理中硬件的地址转换和缺页中断处理 二.实验原理装入新页置换旧页时,若旧页在执行中没有被修改过,则不必将该页重写磁盘。

因此,页表中增加是否修改过的标志,执行“存”指令和“写”指令时将对应的修改标志置成“1”三.要求及方法:① 设计一个地址转换程序来模拟硬件的地址转换和缺页中断。

当访问的页在主存时则形成绝对地址,但不去模拟指令的执行,可以输出转换后的绝对地址来表示一条指令已执行完成。

当访问的页不在主存中时,则输出“*页号”来表示硬件产生了一次缺页中断。

模拟地址转换流程见图1。

② 编制一个FIFO 页面调度程序;FIFO 页面调度算法总是先调出作业中最先进入主存中的哪一页。

因此可以用一个数组来表示(或构成)页号队列。

数组中每个元素是该作业已在主存中的页面号,假定分配给作业的页架数为m ,且该作业开始的m 页已装入主存,则数组可由m 个元素构成。

P[0],P[1],P[2],…,P[m-1]它们的初值为P[0]:=0,P[1]:=1,P[2]:=2,…,P[m-1]:=m-1用一指针K 指示当要调入新页时应调出的页在数组中的位置,K 的初值为“0”,当产生缺页中断后,操作系统总是选择P[K]所指出的页面调出,然后执行:P[K]:=要装入的新页页号 K :=(k+1)mod m在实验中不必实际地启动磁盘执行调出一页和装入一页的工作,而用输出“OUT 调出的页号”和“IN 要装入的新页页号”来模拟一次调出和装入过程,模拟程序的流程图见附图1。

按流程控制过程如下:提示:输入指令的页号和页内偏移和是否存指令⎩⎨⎧ 0 1非存指令存指令,若d 为-1则结束,否则进入流程控制过程,得P1和d,查表在主存时,绝对地址=P1×1024+d③假定主存中页架大小为1024个字节,现有一个共7页的作业,其副本已在磁盘上。

系统为该作业分配了4个页架,且该作业的第0页至第3页已装入内存,其余3页未装入主四.主要代码及其说明#include <stdio.h>#include <string.h>#include <stdlib.h>#define M 1024#define R 4typedef struct _PTable{int Number; //页号int Flag; //标志int Fnum; //页架号int Mflag; //修改标志int Position; //该页存放在磁盘上的位置}PTable;//初始化PTable ptable[]={{0, 1, 5, 0, 11},{1, 1, 8, 0, 12},{2, 1, 9, 0, 13},{3, 1, 1, 0, 21},{4, 0, -1, 0, 22},{5, 0, -1, 0, 23},{6, 0, -1, 0, 121},};void menu();int change(char op,int number,int add);void display();int p[]={0,1,2,3},k=0;void main(void){int number,add,n;char op;while(n){display();fflush( stdin );printf("输入:操作页号页内地址(存指令用\"c\"代表)\n");scanf("%c %d %d",&op,&number,&add);change(op,number,add);printf("\"是否继续! (按1 继续按任意键结束)\"\n");scanf("%d",&n);system( "cls ");if(n==1)continue;elsebreak;}}void menu(){printf("操作码\t页号\t页内地址页架标志修改标志出入状态绝对地址(L)\n");}int change(char op,int number,int add){bool flag1=false;bool flag2=false;int i,address,cout,temp;;for(i=0;i<7;i++){if(op=='c'){ptable[number].Mflag=1;}if(ptable[i].Number==number && ptable[i].Flag==1){address=ptable[i].Fnum*M+add;flag1=true;}if(ptable[i].Number==number && ptable[i].Flag==0){cout=i;temp = p[k]; //将要出的页if(ptable[temp].Mflag==1){flag2=true;}//修改页表ptable[number].Flag=1; //修改新页标志ptable[number].Fnum=ptable[temp].Fnum; //修改新页页架address=ptable[number].Fnum*M+add;ptable[temp].Flag=0; //修改旧页ptable[temp].Fnum=-1; //修改页架ptable[temp].Mflag=0; //修改修改标志p[k]=number; //新页k=(k+1)%R;}}menu();if(flag1)printf("%c\t %d\t %d\t %d\t %d\t %d\t 无出入\t%d\n",op,number,add,ptable[number].Fnum,ptable[number].Flag,ptable[number].Mflag,address);else if(flag2)printf("%c\t *%d\t %d\t %d\t %d\t%d OUT:%d,IN:%d %d\n",op,number,add,number,ptable[number].Fnum,ptable[number].Flag,ptable[number].Mflag,temp,number,address);elseprintf("%c\t *%d\t %d\t %d\t %d\t %d\t IN%d\t %d\n",op,number,add,ptable[number].Fnum,ptable[number].Flag,ptable[number].Mflag,number,address);return 0;}void display(){int i;printf("********当前页表中的状态*********\n");printf("页号标志页架修标志\n");for(i=0;i<7;i++){printf("%d\t%d\t%d\t%d\n",ptable[i].Number,ptable[i].Flag,ptable[i].Fnum,ptable[i]. Mflag);}printf("当前主存中的页号为: ");for(i=0;i<4;i++){printf("%d ",p[i]);}printf("\n*********************************\n");}五,实验截图。

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

页式虚拟存储管理FIFO、LRU和OPT页面置换算法

页式虚拟存储管理FIFO、LRU和OPT页面置换算法

目录1 需求分析 (2)1.1 目的和要求 (2)1.2 研究内容 (2)2 概要设计 (2)2.1 FIFO算法 (3)2.2 LRU算法 (3)2.3 OPT算法 (3)2.4 输入新的页面引用串 (3)3 详细设计 (4)3.1 FIFO(先进先出)页面置换算法: (4)3.2 LRU(最近最久未使用)置换算法: (4)3.3 OPT(最优页)置换算法 (4)4 测试 (5)5 运行结果 (5)6 课程设计总结 (9)7 参考文献 (10)8 附录:源程序清单 (10)1 需求分析1.1 目的和要求在熟练掌握计算机虚拟存储技术的原理的基础上,利用一种程序设计语言模拟实现几种置换算法,一方面加深对原理的理解,另一方面提高学生通过编程根据已有原理解决实际问题的能力,为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。

1.2 研究内容模拟实现页式虚拟存储管理的三种页面置换算法(FIFO(先进先出)、LRU (最近最久未使用)和OPT(最长时间不使用)),并通过比较性能得出结论。

前提:(1)页面分配采用固定分配局部置换。

(2)作业的页面走向和分得的物理块数预先指定。

可以从键盘输入也可以从文件读入。

(3)置换算法的置换过程输出可以在显示器上也可以存放在文件中,但必须清晰可读,便于检验。

2 概要设计本程序主要划分为4个功能模块,分别是应用FIFO算法、应用LRU算法、应用OPT算法和页面引用串的插入。

1.1各模块之间的结构图2.1 FIFO 算法该模块的主要功能是对相应页面引用串进行处理,输出经过FIFO 算法处理之后的结果。

2.2 LRU 算法该模块的主要功功能是对相应的页面引用串进行处理,输出经过LRU 算法处理之后的结果。

2.3 OPT 算法该模块的主要功功能是对相应的页面引用串进行处理,输出经过OPT 算法处理之后的结果。

2.4 输入新的页面引用串该模块的主要功能是用户自己输入新的页面引用串,系统默认的字符串是0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0,用户可以自定义全新的20个数字页面引用串。

模拟请求页式存储管理中硬件的地址转换和缺页中断

模拟请求页式存储管理中硬件的地址转换和缺页中断

课程名称操作系统原理实验名称模拟请求页式存储管理中硬件的地址转换和缺页中断姓名学号专业班级实验日期成绩指导老师(①实验目的②实验原理③主要仪器设备④实验内容与步骤⑤实验数据记录与处理⑥实验结果分析⑦问题建议)一、实验目的模拟请求页式存储管理中硬件的地址转换和缺页中断,并用先进先出调度算法(FIFO)处理缺页中断。

二、实验内容内容:模拟请求页式存储管理中硬件的地址转换和缺页中断处理思想:装入新页置换旧页时,若旧页在执行中没有被修改过,则不必将该页重写磁盘。

因此,页表中增加是否修改过的标志,执行“存”指令和“写”指令时将对应的修改标志置成模拟算法流程三、程序及截图程序:#include<iostream>#include<iomanip>#include<list>using namespace std;char useSign[12][5]={{'+'},{'-'},{'*'},{"存"},{"取"},{'-'},{"移位"},{'+'},{"存"},{"取"},{'+'},{"存"}};int PageAddress[12]={70,50,15,21,56,40,53,23,37,78,01,84};int PageNum[12]={0,1,2,3,0,6,4,5,1,2,4,6};int S_Station;int pPageNum[7];//页号pPageint pSign[7];int pStool[7];//页架号int pModify[7];//修改标志int pStation[7];//磁盘位置static int z=0;void Store(){for(int i=0;i<7;i++){if(i<4){pSign[i]=1;}elsepSign[i]=0;pPageNum[i]=i;pModify[i]=0;}int p1=1,p2=2,p3=3;for(i=0;i<7;i++){if(i<3){pStation[i]=p1;p1++;}elseif(i<6){pStation[i]=p2;p2++;}elsepStation[i]=p3;}pStool[0]=5;pStool[1]=8;pStool[2]=9;pStool[3]=1;}void CShow(){cout<<"操作";cout<<"页号";cout<<"页内地址";cout<<"标志";cout<<"绝对地址";cout<<"修改页号";cout<<"页架号";cout<<"绝对地址";cout<<endl;}void Find(){int m_Pagenum;int m_Station;int Y_Station;//绝对地址int m_Stool;cout<<"输入页号及页内地址查询操作:";cin>>m_Pagenum>>m_Station;CShow();int i,j=0;//string m_Modify;for(i=0;i<12;i++){if(PageAddress[i]==m_Station){break;}}Y_Station=pStool[m_Pagenum]*1024+m_Station;if(pSign[m_Pagenum]==1){if(strcpy(useSign[i],"存")!=0){pModify[m_Pagenum]=1;}}cout<<useSign[i]<<" ";cout<<m_Pagenum<<" ";cout<<m_Station<<" ";cout<<pSign[m_Pagenum]<<" ";if(Y_Station!=m_Station){cout<<Y_Station<<" ";cout<<" ";cout<<pStool[m_Pagenum]<<" ";cout<<Y_Station<<endl;}else{cout<<"*"<<m_Pagenum<<" ";for(j=z;j<7;j++){if(pSign[j]==1){z++;break;}}cout<<m_Pagenum<<"->"<<j<<" ";pStool[m_Pagenum]=pStool[j];pSign[j]=0;pStool[j]=0;cout<<pStool[m_Pagenum]<<" ";cout<<pStool[m_Pagenum]*1024+m_Station<<endl;}}int main(void){Store();char judge='Y';while(judge=='Y'){Find();cout<<"是否继续输入?Y = 是N=否"<<endl;cin>>judge;}return 0;}截图:五.心得体会在实验过程中,遇到了一些问题但是在调试的过程中,会出现很多错误,有的自己可以解决,也有一些在同学的帮助下,基本都解决了所有问题。

概述fifo,opt,lru算法

概述fifo,opt,lru算法

概述fifo,opt,lru算法一、算法简介FIFO(FirstInFirstOut,先进先出)、OPT(OptimalPageReplacement)和LRU(LeastRecentlyUsed)算法是三种常见的页面替换算法,用于计算机中的虚拟内存管理。

这些算法在处理内存中数据块的替换时,需要考虑内存的容量、程序的需求以及数据的历史访问情况等因素。

二、算法原理1.FIFO算法:此算法将页面按照进入的顺序依次存放在内存中。

当有新的页面需要被加载时,如果内存中没有该页面,就需要从磁盘上加载。

当所有的页面都按照进入的顺序被加载完毕后,再按照同样的顺序将页面从内存中逐出,以腾出空间存放新的页面。

这种算法简单易行,但过于依赖页面的进入顺序,如果页面进入的顺序不合理,可能会导致频繁的页面替换。

2.OPT算法:此算法在每次需要加载新页面时,会根据一些准则(如最大错误率、最小错误率、最坏情况等)选择一个最优的页面进行替换。

相比于FIFO算法,OPT算法能更好地适应不同的页面访问情况,从而减少页面的替换频率。

然而,由于需要考虑到各种复杂的因素,OPT算法的实现难度相对较高。

3.LRU算法:此算法将最近最少使用的页面替换出内存,以腾出空间存放新的页面。

当有新的页面需要被加载时,如果内存中没有该页面,就需要从磁盘上加载。

而在加载完成后,会将该页面标记为最近最少使用的状态。

这种算法能够有效地提高内存的使用效率,减少页面的替换次数。

三、应用场景这三种算法在许多实际应用场景中都有应用,如操作系统中的虚拟内存管理、缓存系统等。

不同的应用场景可能需要不同的算法来满足特定的需求,如对于需要频繁访问的页面,可能更适合使用LRU算法;而对于访问模式较为固定的场景,可能更适合使用OPT算法。

四、总结FIFO、OPT和LRU算法是虚拟内存管理中常用的页面替换算法,它们各自具有不同的原理和应用场景。

在实际应用中,需要根据具体的需求和场景选择合适的算法,以实现最优的内存管理效果。

页式虚拟存储管理缺页中断的模拟系统的设计

页式虚拟存储管理缺页中断的模拟系统的设计

燕山大学课程设计说明书课程设计名称:操作系统OS题目:页式存储管理中页面置换(淘汰)的模拟程序班级:计算机应用二班开发小组名称:CAMPUS课题负责人:课题组成员:姓名学号班级自评成绩课题开发日期:2011-1-10至2011-1-14一.概述1目的通过分析、设计和实现页式虚拟存储管理缺页中断的模拟系统,熟悉和掌握请求分页式存储管理的实现过程,重点掌握当请求页面不在内存而内存块已经全部被占用时的替换算法,熟悉常见替换算法的原理和实现过程,并利用替换算法的评价指标——缺页次数和缺页率,来对各种替换算法进行评价比较。

2.主要完成的任务自行输入实际页数、内存可用页面数、存取内存时间、存取快表时间及缺页中断时间,然后由用户随机输入各页面号,模拟系统自动运行出FIFO、LRU、OPT、LFU四种算法的缺页次数、缺页率、命中率、总存取时间、存取平均时间等结果。

3 使用的开发工具(1)使用系统:Windows7(2)使用语言:C++(3)开发工具:Visual C++ 6.04 解决的主要问题设计的结果程序能实现FIFO、OPT、LRU、LFU算法模拟页式存储管理缺页中断,主要能够处理以下的问题:(1) 用户能够输入给作业分配的内存块数;(2) 用户能够输入给定的页面,并计算发生缺页的次数以及缺页率;(3) 程序可由用户输入页面序列;(4)系统自动计算总存取时间及平均存取时间。

二使用的基本概念和原理1.概念FIFO即先进先出页面置换算法,该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。

LRU 即最近最久未使用页面置换算法,该算法选择最近最久未使用的页面予以淘汰。

OPT 即最佳值换算法,其选择淘汰的页面是在最长时间内不再被访问的页面。

LFU 即最近使用最少页面置换算法,其淘汰的页面是最近一段时间内使用最少的页面。

缺页中断存取页面时页面不在内存中需从外存调入的现象。

缺页次数即在存取页面过程中发生缺页中断的次数。

实验--编程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法

实验--编程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法
int index=0;
for(int i=0;i<fS;i++){
if(((Couple)(i)).time<temp){
temp=((Couple)(i)).time;
index=i;
}
}
for(int i=0;i<fS;i++){
if(i!=index){
((Couple)(i)).time--;
for(int i=0;i<;i++){
"Frame size: "+frameSize[i]+"\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
errorCount=0;
}
"----------------Using LRU----------------");
(new Couple(0));
}
}
public void LRUReplace(int fS){
boolean findThesame=false;
int pre=-1;alue==digitalArray[j]){

017FIFO、LRU、OPT这三种置换算法的缺页次数

017FIFO、LRU、OPT这三种置换算法的缺页次数

考虑下述页面走向:
1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6
当内存块数量分别为3时,试问FIFO、LRU、OPT这三种置换算法的缺页次数各是多少?
答:缺页定义为所有内存块最初都是空的,所以第一次用到的页面都产生一次缺页。

当内存块数量为3时:
发生缺页中断的次数为16。

在FIFO算法中,先进入内存的页面被先换出。

当页6要调入时,内存的状态为4、1、5,考查页6之前调入的页面,分别为5、1、2、4,可见4为最先进入内存的,本次应换出,然后把页6调入内存。

发生缺页中断的次数为15。

在LRU算法中,最近最少使用的页面被先换出。

当页6要调入时,内存的状态为5、2、1,考查页6之前调入的页面,分别为5、1、2,可见2为最近一段时间内使用最少的,本次应换出,然后把页6调入内存。

发生缺页中断的次数为11。

在OPT算法中,在最远的将来才被访问的页面被先换出。

当页6要调入时,内存的状态为1、2、5,考查页6后面要调入的页面,分别为2、1、2、…,可见5为最近一段时间内使用最少的,本次应换出,然
后把页6调入内存。

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

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

课程设计题目请求页式管理缺页中断模拟设计--FIFO、OPT学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:指导教师:吴利军_ 工作单位:计算机科学与技术学院题目: 请求页式管理缺页中断模拟设计--FIFO、OPT初始条件:1.预备内容:阅读操作系统的内存管理章节内容,了解有关虚拟存储器、页式存储管理等概念,并体会和了解缺页和页面置换的具体实施方法。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.实现指定淘汰算法。

能够处理以下的情形:⑴能够输入给作业分配的内存块数;⑵能够输入给定的页面,并计算发生缺页的次数以及缺页率;⑶缺页时,如果发生页面置换,输出淘汰的页号。

2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。

周2、周3:完成程序调试及测试。

周4、周5:验收、撰写课程设计报告。

(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日请求页式管理缺页中断模拟设计——FIFO、OPT1课程设计目的与功能1.1设计目的结合《操作系统》所学内存页式管理章节,掌握虚拟内存设计的重要性,熟悉和掌握请求分页式存储管理的实现原理,通过分析、设计和实现页式虚拟存储管理缺页中断的模拟系统,重点掌握当请求页面不在内存而内存块已经全部被占用时的替换算法(主要通过FIFO和OPT实现),并考察替换算法的评价指标——缺页次数和缺页率,得到淘汰的页面次序。

对用LRU和FIFO算法计算“缺页中断”的理解

对用LRU和FIFO算法计算“缺页中断”的理解

对⽤LRU和FIFO算法计算“缺页中断”的理解输⼊缺页次数页⾯流:0 1 2 3 2 1 3 2 5 2 3 6 2 1 4 2 FIFO分析:012發別調⼊內存,則內存:012(3次缺⾴)調⼊3逃汰最先進⼊的0,則內存:123(4次缺⾴)調⼊2來命中,則內存:123(內存中有2不缺⾴)調⼊1來命中,則內存:123(內存中有1不缺⾴)調⼊3來命中,則內存:123(內存中有3不缺⾴)調⼊5逃汰最先進⼊的1,則內存:235(5次缺⾴)2,3別別命中,則內存:235調⼊6逃汰最先進⼊的,則內存:356(6次缺⾴)調⼊2逃汰最先進⼊的,則內存:562(7次缺⾴)調⼊1逃汰最先進⼊的,則內存:621(8次缺⾴)最后2命中,所以缺页8次=============================在LRU算法中,最近最少使⽤的页⾯被先换出输⼊:7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0写出LRU算法实现页⾯更换,并给出缺页次数.(设在内存中占四个页架)分析:1题⽬给了访问串7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 02题⽬给了内存中占四个页架3题⽬给了⽤LRU算法来实现。

要求:画出算法实现。

LRU给出⾏ 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0头-----> 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 01 2 0 3 0 4 2 3 0 3 2 1 2 0 1 70 1 2 2 3 0 4 2 2 0 3 3 1 2 0 1底-----> 7 7 1 1 2 3 0 4 4 4 0 0 3 3 2 2淘汰出内存的页⾯: 7 1 4 3整个的表格是怎么来的呢?请注意:题⽬给了7, 写7;题⽬给了0,写0, 7下⼀格;题⽬给了1, 写1,0下⼀格;题⽬给了2, 写2,1下⼀格;注意:已经四个了从上到下是:2107达到了2的要求:内存中占四个页架。

缺页中断及页面置换算法

缺页中断及页面置换算法

缺页中断及页⾯置换算法1. 缺页中断 在请求分页系统中,可以通过查询页表中的状态位来确定所要访问的页⾯是否存在于内存中。

每当所要访问的页⾯不在内存时,会产⽣⼀次缺页中断,此时操作系统会根据页表中的外存地址在外存中找到所缺的⼀页,将其调⼊内存。

缺页本⾝是⼀种中断,与⼀般的中断⼀样,需要经过4个处理步骤: 1. 保护CPU现场 2. 分析中断原因 3. 转⼊缺页中断处理程序进⾏处理 4. 恢复CPU现场,继续执⾏ 但是缺页中断时由于所要访问的页⾯不存在与内存时,有硬件所产⽣的⼀种特殊的中断,因此,与⼀般的中断存在区别: 1. 在指令执⾏期间产⽣和处理缺页中断信号 2. ⼀条指令在执⾏期间,可能产⽣多次缺页中断 3. 缺页中断返回时,执⾏产⽣中断的那⼀条指令,⽽⼀般的中断返回时,执⾏下⼀条指令2. 页⾯置换算法 进程运⾏过程中,如果发⽣缺页中断,⽽此时内存中有没有空闲的物理块是,为了能够把所缺的页⾯装⼊内存,系统必须从内存中选择⼀页调出到磁盘的对换区。

但此时应该把那个页⾯换出,则需要根据⼀定的页⾯置换算法(Page Replacement Algorithm)来确定。

2.1 最佳置换(Optimal, OPT)2.1.1 基本思想 置换以后不再被访问,或者在将来最迟才回被访问的页⾯,缺页中断率最低。

但是该算法需要依据以后各业的使⽤情况,⽽当⼀个进程还未运⾏完成是,很难估计哪⼀个页⾯是以后不再使⽤或在最长时间以后才会⽤到的页⾯。

所以该算法是不能实现的。

但该算法仍然有意义,作为很亮其他算法优劣的⼀个标准。

2.1.2 算例 采⽤固定分配局部置换的策略,嘉定系统为某进程在内存中分配了3个物理块,页⾯访问顺序为2、3、2、1、5、2、4、5、3、2、5、2。

假定系统未采⽤预调页策略,即未事先调⼊任何页⾯。

进程运⾏时,⼀次将2、3、1三个页⾯调⼊内存,发⽣3次缺页中断。

当第⼀次访问页⾯5时,产⽣第4次缺页中断,根据OPT算法,淘汰页⾯1,因为它在以后不会在使⽤了;第5次缺页中断时,淘汰页⾯2,因为它在5、3、2三个页⾯中,是在将来最迟才会被页⾯访问的页⾯。

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

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

课程设计题目请求页式管理缺页中断模拟设计--LRU、OPT 学院计算机科学与技术学院专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:指导教师:吴利军工作单位:计算机科学与技术学院题目: 请求页式管理缺页中断模拟设计--LRU、OPT初始条件:1.预备内容:阅读操作系统的内存管理章节内容,了解有关虚拟存储器、页式存储管理等概念,并体会和了解缺页和页面置换的具体实施方法。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.实现指定淘汰算法。

能够处理以下的情形:⑴能够输入给作业分配的内存块数;⑵能够输入给定的页面,并计算发生缺页的次数以及缺页率;⑶缺页时,如果发生页面置换,输出淘汰的页号。

2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。

周2、周3:完成程序调试及测试。

周4、周5:验收、撰写课程设计报告。

(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日请求页式管理缺页中断模拟设计----LRU、OPT1 设计目的与功能1.1 设计目的巩固并加深对虚拟存储器、请求页式存储管理等概念的理解,掌握请求页式管理中的置换算法的基本思想。

并针对LRU(最近最久未使用页面置换算法),以及OPT(理想型淘汰算法)两种算法,利用高级语言,设计出相应的模拟程序。

结合设计的程序,在理论联系实际的基础上,分析各个页面置换算法的优缺点。

(C语言)用FIFO和LRU算法处理缺页中断

(C语言)用FIFO和LRU算法处理缺页中断
if (strcmp(s,"exit")==0)
{
stop=1;
}
}
else
{
scanf("%s",s);
if (pagelist[p].flag)//该页在主存中
{
int result;
result=pagelist[p].block*SizeOfBlock+q;
}
po=GetMax();
pagelist[P[po]].flag=0;//从主存中调出该页
//if(pagelist[P[po]].dirty==1)
printf("out %ld\n",P[po]);
printf("in %ld\n",p);//输出调出的页号
cout<<"绝对地址为:"<<pagelist[p].block<<"*"<<SizeOfBlock<<"+"<<q<<"="<<result<<endl;
if (s[0]=='Y' || s[0]=='y')
{
pagelist[p].dirty=1;
//是存指令,修改标志为“1”
cout<<"绝对地址为:"<<pagelist[p].block<<"*"<<SizeOfBlock<<"+"<<q<<"="<<result<<endl;

模拟页式存储管理 操作系统课程设计

模拟页式存储管理  操作系统课程设计

计算机科学与技术学院操作系统课程设计报告课题:模拟页式存储管理姓名:学号:同组姓名:专业班级:网工10101指导教师:刘国清设计时间: 2013-6-25 评阅意见:评定成绩:指导老师签名:年月日目录一、目的和要求 (2)1、设计目的 (2)2、设计要求 (2)二、设计思路及过程 (2)1、概要设计 (2)2、过程设计 (3)三、数据定义 (5)四、核心代码 (5)五、运行截图 (8)六、小结 (10)七、参考文献 (11)附录 (12)一、目的和要求1、设计目的通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

2、设计要求根据模拟的页式管理设计,掌握在页式存储管理中最基本的三种页面调度算法FIFO、LRU以及OPT。

但在三种算法中均要求在调度程序中产生的页面序列是随机产生的,而不是人为的输入,在执行时只需改变页面的大小及内存容量就可以得到不同的页面序列,另外还需要说明随机的性能和其性能可能对算法的影响,并对随机性要有一定的参数控制能力。

此外,计算并输出FIFO、LRU以及OPT算法在不同内存容量下的命中率。

根据方法的执行过程,编写一个解决上述问题的程序,显示访问每个值页面中的值。

具体参数:访问串的长度,访问串,页面个数。

分别用3种不同的方法实现页面的置换,并输出相关信息。

二、设计思路及过程1、概要设计1.1 问题概述根据三种不同的置换算法,依据其不同的算法方式,分别计算该算法在不同情况下的命中率,并显示各页面的变化情况。

1.2 内容分析对于该课程设计中模拟的页式存储管理的页面置换过程,只要掌握其中最基本的三种算法,包括FIFO、LRU及OPT。

但最重要的一点就是要求产生随机序列,所以在编写程序时要采用控制产生随机值的种子数函数,如此能产生随机的访问序列。

另外,不能在执行完一次操作后就只能进行另外一种算法的操作,必须还要有更加详细的操作,比如:是否要重新得到新序列?还是要不改变访问序列而只改变访问串的内存容量?抑或是不操作就退出该算法以进行下一种调度算法?因此,在执行完每次操作后都必须要有提示语,看是否进入更细节的操作,还是退出本次算法的操作以进入下一种算法的调度。

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

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

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

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

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

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

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

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

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

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

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

操作系统_页面置换算法FIFO,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;

请求分页系统OPT-LRU-FIFO-CLOCK示例

请求分页系统OPT-LRU-FIFO-CLOCK示例

在一个请求分页系统中,假如系统分配一个作业的物理块数为3,且此作业的页面走向为2 ,3 , 2 ,1 ,5 ,2 ,4 ,5 , 3 2 5 2则OPT,LRU,FIFO,CLOCK算法的页面置换次数为?1.首先是OPT算法的求解过程:2 3 2 1 5 2 4 5 3 2 5 2页面走向2 2 2 2 2 2 4 4 4 2 2 2物理块13 3 3 3 3 3 3 3 3 3 3物理块21 5 5 5 5 5 5 5 5物理块3是是否是是否是否否是否否是否缺页是否否否否否是否是否否是否否置换由表中可知缺页次数为6,置换次数为3.OPT通常可保证获得的最低的缺页率,可以利用此算法去评价其他的页面置换算法。

OPT置换算法是一种理想算法,因为人们还无法预知哪一个页面在未来最长时间不再被访问。

2.下面是LRU 页面置换算法求解过程:2 3 2 1 5 2 4 5 3 2 5 2页面走向2 2 2 2 2 2 2 23 3 3 3物理块13 3 3 5 5 5 5 5 5 5 5物理块21 1 1 4 4 42 2 2物理块3是是否是是否是否是是否否是否缺页是否否否否否是否是否是是否否置换由表中可知缺页次数为7,置换次数为4.LRU置换算法是选择最近最久未使用的页面予以淘汰。

LRU需要寄存器或栈的硬件支持。

3.下面是FIFO 页面置换算法求解过程: 页面走向 2 3 2 1 5 2 4 5 3 2 5 2 物理块1 2 2 2 2 5 5 5 5 3 3 3 3 物理块2 3 3 3 3 2 2 2 2 2 5 5 物理块31 1 1 4 4 4 4 42 是否缺页 是 是 否 是 是 是 是 否 是 否 是 是 是否置换否 否否否是是是否是否是是由上表可知:缺页次数为9次,页面置换次数为6次。

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

4.下面是CLOCK 页面置换算法求解过程:(括号内的0,1表示访问标记。

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

课程设计题目请求页式管理缺页中断模拟设计--LRU、OPT 学院计算机科学与技术学院专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名:指导教师:吴利军工作单位:计算机科学与技术学院题目: 请求页式管理缺页中断模拟设计--LRU、OPT初始条件:1.预备内容:阅读操作系统的内存管理章节内容,了解有关虚拟存储器、页式存储管理等概念,并体会和了解缺页和页面置换的具体实施方法。

2.实践准备:掌握一种计算机高级语言的使用。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.实现指定淘汰算法。

能够处理以下的情形:⑴能够输入给作业分配的内存块数;⑵能够输入给定的页面,并计算发生缺页的次数以及缺页率;⑶缺页时,如果发生页面置换,输出淘汰的页号。

2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。

周2、周3:完成程序调试及测试。

周4、周5:验收、撰写课程设计报告。

(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日请求页式管理缺页中断模拟设计----LRU、OPT1 设计目的与功能1.1 设计目的巩固并加深对虚拟存储器、请求页式存储管理等概念的理解,掌握请求页式管理中的置换算法的基本思想。

并针对LRU(最近最久未使用页面置换算法),以及OPT(理想型淘汰算法)两种算法,利用高级语言,设计出相应的模拟程序。

结合设计的程序,在理论联系实际的基础上,分析各个页面置换算法的优缺点。

以及在对课程的整体把握上,提升对操作系统这门课程的全面认识。

1.2 设计功能本次课程设计需要实现LRU和OPT两种置换算法。

能够实现以下功能:1)能够输入给作业分配的内存块数;2)能够输入给定的页面,并计算发生缺页的次数以及缺页率;3)缺页时,如果发生页面置换,输出淘汰的页号。

2 设计需求分析2.1 需求分析2.1.1 请求页式管理的实现请求页式管理是在静态页式管理的基础上发展起来的,它允许只装入部分页面的程序和数据,便启动运行。

此后,再通过调页功能和页面置换功能,陆续把即将要运行的页面调入内存,同时把暂时不运行的页面换出到外存上,置换时以页面为单位。

为了能实现请求调页和置换功能,系统必须提供必要的硬件支持和相应的软件。

其中硬件支持包括:1)请求分页的页表机制,它是在纯分页的页表机制上增加若干项而形成的,作为请求分页的数据结构;2)缺页中断机构,当要访问的页面尚未调入内存时,便产生一缺页中断,以请求OS将所缺的页调入内存;3)地址变换机构,它同样是在纯分页地址变换机构的基础上形成的。

2.1.2 置换算法分析请求页式管理中的置换算法在内存中没有空闲页时被调用,它的目的是选出一个被淘汰的页面。

如果内存中有足够的空闲页面存放调入的页,则不必使用置换算法。

本次设计使用最近最久未使用页面置换算法(least recently used,LRU)和理想型淘汰算法(optional replacement algorithm,OPT)。

LRU置换算法:最近最久未使用页面置换算法(least recently used,LRU),该算法的基本思想是:当需要淘汰某一页时,选择离当前时间最近的一段时间内最久没有使用过的页先淘汰。

该算法的主要出发点是,如果某页被访问了,则它可能马上还要被访问,或者如果某页很长时间未被访问,则它在最近一段时间也不会被访问。

OPT置换算法:理想型淘汰算法(optional replacement algorithm,OPT),该算法淘汰在访问串中将来再也不出现的或者是在离当前最远的位置上出现的页,这样淘汰掉该页将不会造成因需要访问该页又立即把它调入的现象。

这种算法难以实现,因为它要求必须预先知道每一个进程的访问串。

2.2 数据结构及功能框图- - - - - - - - - - 基本数据变量说明- - - - - - - - - - - - -int input; //输入的页面数int num; //内存块允许装入页面数int *in; //准备调入的页面序列int *memory; //用来记录进入内存的页面信息struct page{int Pnumber; //页面的页号int Mnumber; //在内存中对应的块号int stayin; //是否在内存中};page Ptotal[N]; //对N个页面进行操作- - - - - - - - - - - 基本操作的函数原型说明- - - - - - - - - - - - -void LRU(); //实现LRU算法的函数void OPT(); //实现OPT算法的函数请求页式管理实现过程3 源程序的主要部分3.1 源程序简介本次设计中LRU以及OPT算法中页面置换的思想,分别对照页框的内容,向前查找最久未被使用的页面号和向后查找最后被使用的页面号,将其替换之。

在设计的思想上可以转化为以当前即将调入的页面为中心,LRU为向前查找离中心最远的页号,而OPT为向后查找离中心最远的页号。

3.2 源程序核心代码3.2.1 main函数代码main函数实现对各输入数据及待数据结构的初始化,以及通过选择来调用LRU或OPT算法。

伪代码如下:int main(){ ……//页号、块号、页面顺序的输入,以及初始化等工作。

while(true){ ……//部分全局变量的初始化工作,每次循环需重新开始char chose;cout<<"请您选择:1、LRU算法"<<endl;cout<<" 2、OPT算法"<<endl;cout<<" 3、退出"<<endl;cout<<"*********************************************"<<endl;cin>>chose;if(chose!='1'&&chose!='2')break;switch(chose){case '1':LRU();break;case '2':OPT();break;}cout<<"*********************************************"<<endl;}}3.2.2 LRU及OPT函数代码LRU和OPT的主要思想有许多共同之处,所以通过宏定义,来实现程序的共同功能。

程序中都是通过LO宏来实现的,区别在于传递的参数不同,即LRU函数调用getLRU()子函数。

而OPT函数调用getOPT()函数。

void LRU(){cout<<"LRU替换算法过程如下:"<<endl;LO(LRU); //通过LO宏,传递LRU给get##wname(int page),即getLRU(int page) }void OPT(){ cout<<"OPT替换算法过程如下:"<<endl;LO(OPT); ////通过LO宏,传递OPT给get##wname(int page),即getOPT(int page) }3.2.3 LO(wname)宏的代码LO宏是用来对LRU和OPT的置换进行公处理的,即在内存块未满,或者不需要发生置换时两者的代码是相同的,而唯一不同在于缺页中断处理函数,getLRU(int page)或者getOPT(int page)。

所以,通过宏定义,把不同的代码作为参数传递,来实现不同函数的功能。

伪代码如下:#define LO(wname)\int i,missTime=0,replace=0,full=0,page=0;\//i 为循环控制变量,missTime为缺页次数//replace代表置换的页框号full为控制变量,page为页面数do {\……//实现块未满时的页面分配,LRU和OPT相同}while(full!=num);\for( i=page;i<input;i++){\if(Ptotal[in[i]].stayin ==1){\cout<<in[i]<<"号页已在页框中,"<<endl;\}\else{missTime++;\replace=get##wname(i);\ //根据传递的参数不同,调度不同的函数,返回页框号……//进行页面替换}\cout<<endl<<"经统计:缺页次数:"<<missTime<<"次"<<"缺页率"<<double(missTime)/input*100<<"%"<<endl;\ //对缺页率进行输出3.2.4 getLRU和getOPT函数代码getLRU和getOPT函数是一种搜索算法,返回将要被替换的页框号,页框中的内容即为被替换的页号。

两个函数有一定的相似处,即getLRU函数为向前搜索,而getOPT为向后搜索,所以程序中用到get(symlx,symbly,symblz)宏,伪代码如下:int getLRU(int page){get(-,>=0,<); //get宏,传递的参数为-,>=0,<等return getNum; //返回页框号}int getOPT(int page){ get(+,<input,>); //get宏,传递的参数为+,<input,>等return getNum; //返回页框号}3.2.5 get(smblx,smbly,smblz)宏的代码getLRU和getOPT的搜索算法在思想上相似,即前者向前搜索页第一次出现的申请序号,而后者是向后搜索接下来第一次出现的申请序号,所以用get宏来对相同代码进行公操作,伪代码如下:#define get(smblx,smbly,smblz)\for(i=0;i<num;i++){\for(int j=0;j<10;j++){\if(Ptotal[j].Mnumber==i){\for(int t=page##smblx 1;t##smbly;t##smblx##smblx){\ //宏填充部分,填充内容如上……//向前或后找出该页第一次申请的序号for(i=0;i<num;i++){\if(get[i]##smblz get[getNum])\ //返回将要被置换的页号,存入到getNUM中getNum=i;\ }\4 测试4.1测试用例设计请求分页管理系统中,有一用户作业,它一次要访问的页的序列是:2 3 2 1 5 2 4 5 3 2 5 2 共12页,若分配给作业可以使用的主存空间供3个物理块,则LRU和OPT的置换算法的页面分配如下。

相关文档
最新文档