实验六 虚拟内存页面置换算法
页面置换算法实验报告实验心得
页面置换算法实验报告实验心得
页面置换算法是操作系统中用来管理内存的一种重要算法。
在本次实验中,我们通过模拟内存的分配和释放过程,探索了三种典型的页面置换算法:FIFO(先进先出)、LRU(最近最少使用)和OPT(最优置换)。
在实验过程中,我发现FIFO算法虽然简单易懂,但容易产生“抖动”现象,即容易出现频繁的页面置换,导致系统效率低下。
LRU算法则能够有效避免抖动现象,但需要记录每个页面最近一次的使用时间,算法实现较为复杂。
OPT算法是一种理论上的最优算法,但由于需要预测未来的页面使用情况,实际中难以实现。
通过对三种算法的实验数据分析,我发现在不同的内存使用情况下,不同的页面置换算法表现也不同。
例如在内存使用较少的情况下,FIFO算法的效率可能会更高,但在内存使用较多的情况下,LRU算法则能够更好地发挥作用。
因此,在实际应用中,需要根据实际情况选择合适的页面置换算法。
总之,本次页面置换算法的实验让我更加深入地了解了操作系统中内存管理的相关知识,也加深了我对算法选择的理解和实际应用的思考。
虚拟内存的页面置换算法
虚拟内存的页面置换算法一、引言虚拟内存是计算机系统中的一种技术,它将计算机内存的管理从物理内存中分离出来,扩大了可用的内存空间。
而虚拟内存的页面置换算法则是虚拟内存管理中的重要组成部分。
本文将对虚拟内存的页面置换算法进行详细介绍。
二、页面置换算法的作用在计算机系统中,虚拟内存的大小远远大于物理内存的大小。
当系统运行的程序需要的内存超过物理内存的容量时,就需要将一部分数据从内存中置换出来,以腾出空间给新的数据。
而页面置换算法就是决定哪些页面被置换出去的方法。
三、常见的页面置换算法1. 最佳(OPT)页面置换算法最佳算法是一种理想化的算法,它总是选择未来最长时间内不会被访问的页面进行置换。
然而,由于无法预测未来的访问模式,最佳算法无法在实际系统中使用。
2. 先进先出(FIFO)页面置换算法FIFO算法是一种简单的页面置换算法,它总是选择最早进入内存的页面进行置换。
这种算法容易实现,但是它没有考虑到页面的访问模式,可能会导致较高的缺页率。
3. 最近最久未使用(LRU)页面置换算法LRU算法是一种基于页面访问历史的页面置换算法,它总是选择最近最久未使用的页面进行置换。
这种算法通常能够较好地预测未来的访问模式,但是实现起来较为复杂,需要维护一个访问历史记录。
4. 时钟(Clock)页面置换算法时钟算法是一种基于页面访问位的页面置换算法,它使用一个指针来指向内存中的页面,当需要置换页面时,检查指针指向的页面的访问位。
如果访问位为0,则选择该页面进行置换;如果访问位为1,则将访问位置为0,并将指针移动到下一个页面。
这种算法相对简单,并且能够较好地预测未来的访问模式。
5. 最不经常使用(LFU)页面置换算法LFU算法是一种基于页面访问频率的页面置换算法,它总是选择访问频率最低的页面进行置换。
这种算法能够较好地预测未来的访问模式,并且对于访问频率较低的页面有较好的效果。
四、页面置换算法的评价指标评价一个页面置换算法的好坏通常使用缺页率来衡量。
虚拟内存页面置换算法
{
if(aInArr(PageOrder[i],Simulate,WuliNum)==-1) //缺页
{
LackNum++;
cout<<"\n页面"<<PageOrder[i]<<"发出缺页请求: ";
for(int j=0;j<WuliNum;j++)
cout<<Simulate[j]<<" ";
6. 测试结果 如上图。
PageCount[i]=WuliNum-i; } int LackNum=0; double LackPageRate;
//缺页率
for(int i=WuliNum;i<PageNum;i++) {
int num=aInArr(PageOrder[i],Simulate,WuliNum); if(num==-1) //缺页 {
//最近最久没使用的(下标)
cout<<"\t页面置换后: "; for(int j=0;j<WuliNum;j++)
cout<<Simulate[j]<<" "; }
for(int j=0;j<WuliNum;j++) if(j==num) PageCount[j]=0; else PageCount[j]++;
} LackPageRate=LackNum*1.0/PageNum; cout<<"\nFIFO的缺页率为: "<<LackPageRate<<endl; }
实验六 页面置换算法模拟实验
实验六页面置换算法模拟实验一、实验目的1. 掌握虚拟存储器的实现方法。
2. 掌握各种页面置换算法。
3. 比较各种页面置换算法的优缺点。
二、实验内容模拟实现各种页面置换算法。
具体步骤为:1. 使用产生随机数函数得到一个随机的数列,作为将要载入的页面序列。
2. 可以选择使用先进先出(FIFO)算法、最近最久未使用(LRU)置换算法和最佳(OPT)置换算法,给出所需淘汰的页面号序列。
3. 列出缺页中断次数。
三、实验源程序/* 程序说明:本程序假设内存为程序分配的内存块数为4。
*//* 进入程序后可以根据菜单项进入不同的模块 *//* 1.使用首次适应算法分配空间 *//* 2.最近最久未使用的页面 *//* 3.使用最佳适应算法分配空间 *//* 4.显示有多少个缺页中断 *//* 5.推出系统 */#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 39 /* 随机数序列的长度*/#define B 4 /* 内存的页面数 *//函数名:IsInBuf//功能:返回某个数x有没有在缓冲Buf[]中,若在,返回其位置;若不在,则返回-1/ int IsInBuf(int buf[],int x){ int i,j=-1;for(i=0;i<B;i++){ if(buf[i]==x) {j=i;break;}else if(buf[i]==-1){buf[i]=x;j=i;break;}}return j;}/函数名:oldest()//功能:返回最近最久未使用的页面的位置/int oldest(int f[]){ int i,j=0,max=-1;for(i=0;i<B;i++){ if(f[i]>max) {max=f[i];j=i;}f[i]++;}return j;}/函数名:oldest2()//功能:返回未来最长时间不使用的页面的位置/int oldest2(int list[],int buf[],int f[],int start) { int i,j;for(i=0;i<B;i++){ for(j=start;j<N;j++){ if(buf[i]==list[j]) break;}f[i]=j;}return oldest(f);}/函数名:main()/main(){ int list[N];int buf[B],f[B],i,j,k,max,min;int old=0;int change=0;/生成一系列随机数并初始化环境/srand((int)time(NULL));for(i=0;i<B;i++) buf[i]=f[i]=-1;printf(“\nThe Random List:\n”);for(i=0;i<N;i++){ list[i]=(int) rand()%10;printf(“%2d”,list[i]);}/显示FIFO淘汰页面的序列/printf(“\nFIFO:\n”);change=0;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){ printf(“%2d”,buf[old]);buf[old]=list[i];old=(old+1)%(int)B;change++;}elseprintf(“”);}/显示有多少个缺页中断/printf(“\nchanges:%d\n”,change);/显示LRU淘汰页面的序列/printf(“LRU :\n”);change=0;for(i=0;i<B;i++) buf[i]=f[i]=-1;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);old=oldest(f);if(j==-1){ printf(“%2d”,buf[old]);buf[old]=list[i];f[old]=0;change++;}else{ f[j]=0;printf(“”);}}/显示有多少个缺页中断/printf(“\nchanges:%d\n”,change);/显示OPT淘汰页面的序列/printf(“OPT :\n”);change=0;for(i=0;i<B;i++) buf[i]=f[i]=-1;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){ old=oldest2(list,buf,f,i);printf(“%2d”,buf[old]);buf[old]=list[i];f[old]=0;change++;}else{ printf(“”);}}/显示有多少个缺页中断/printf(“\nchanges:%d\n”,change);}说明:多次运行结果并不相同,分析一下原因。
页面置换算法实验(内含完整代码)
实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟存储技术的特点,掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程,并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区,设计下述算法并计算访问命中率。
1、最佳淘汰算法(OPT)2、先进先出的算法(FIFO)3、最近最久未使用算法(LRU)4、简单时钟(钟表)算法(CLOCK)命中率=1-页面失效次数/页地址流(序列)长度三、实验原理简述UNIX中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求(向CPU发出缺中断),由系统将其所需页面调入内存。
这种页面调入方式叫请求调页。
为实现请求调页,核心配置了四种数据结构:页表、页帧(框)号、访问位、修改位、有效位、保护位等。
当CPU接收到缺页中断信号,中断处理程序先保存现场,分析中断原因,转入缺页中断处理程序。
该程序通过查找页表,得到该页所在外存的物理块号。
如果此时内存未满,能容纳新页,则启动磁盘I/O将所缺之页调入内存,然后修改页表。
如果内存已满,则须按某种置换算法从内存中选出一页准备换出,是否重新写盘由页表的修改位决定,然后将缺页调入,修改页表。
利用修改后的页表,去形成所要访问数据的物理地址,再去访问内存数据。
整个页面的调入过程对用户是透明的。
四、算法描述本实验的程序设计基本上按照实验内容进行。
即使用srand( )和rand( )函数定义和产生指令序列,然后将指令序列变换成相应的页地址流,并针对不同的算法计算出相应的命中率。
(1)通过随机数产生一个指令序列,共320条指令。
指令的地址按下述原则生成:A:50%的指令是顺序执行的B:25%的指令是均匀分布在前地址部分C:25%的指令是均匀分布在后地址部分具体的实施方法是:A:在[0,319]的指令地址之间随机选取一起点mB:顺序执行一条指令,即执行地址为m+1的指令C:在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m’D:顺序执行一条指令,其地址为m’+1E:在后地址[m’+2,319]中随机选取一条指令并执行F:重复步骤A-E,直到320次指令(2)将指令序列变换为页地址流设:页面大小为1K;用户内存(页帧)容量为4页~32页;用户虚存容量为32K。
页面置换实验报告
计算机科学系实验报告书课程名:《操作系统》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求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值,表示该虚页的最后一次被访问时间。
操作系统虚拟内存与页面置换算法
操作系统虚拟内存与页面置换算法操作系统的虚拟内存是一种将运行程序所需的内存空间扩展到硬盘上的技术。
通过虚拟内存,操作系统可以更好地管理内存资源,使得多个程序能够同时运行,并且在内存不足时能够有效地置换页面。
一、虚拟内存的概念和作用虚拟内存是操作系统为每个进程提供的一种看似连续、但实则可以存储在物理内存和硬盘上的地址空间。
它的主要作用有以下几点:1. 扩充内存容量:虚拟内存可以将硬盘上的一部分空间作为内存扩充,有效地提高内存的容量。
2. 隔离进程地址空间:每个进程有独立的虚拟内存空间,通过虚拟内存的隔离,进程与进程之间不会相互干扰。
3. 简化物理内存管理:操作系统只需将常用的部分加载到物理内存中,而不必一次性将整个进程加载到内存中,减少物理内存的压力。
二、页面置换算法虚拟内存的管理会面临一个问题——当物理内存不足时,如何选择将哪些页面换出到硬盘中以便腾出空间给其他页面使用。
下面介绍几种常见的页面置换算法:1. 先进先出(FIFO)算法FIFO算法是最简单的页面置换算法。
它根据页面进入物理内存的先后顺序进行置换,即最早进入内存的页面最先被置换。
但是,FIFO算法的缺点是它无法根据页面的访问频率进行调度,可能导致缺页率较高。
2. 最近最久未使用(LRU)算法LRU算法是一种比较常用的页面置换算法。
它通过记录页面最近一次被访问的时间戳,优先置换最长时间未被访问的页面。
LRU算法可以有效地利用页面的访问模式,但是实现起来比较复杂。
3. 时钟(Clock)算法时钟算法是一种简单而高效的页面置换算法。
它通过维护一个指针,在页面发生缺页时从指针所指页面开始扫描。
如果页面被访问过,则将其访问位置为1;如果没有被访问过,则将其换出并将指针指向下一个页面。
时钟算法的优点是实现简单,并且能够适应访问模式的变化。
综上所述,虚拟内存是操作系统管理内存资源的一种技术。
通过虚拟内存,操作系统可以更好地管理内存,提高内存的利用率,使得多个程序能够同时运行。
操作系统实验报告6-页面置换算法模拟综述
struct{
intlength;//当獭?前°物?理え?块é长¤度è
intmiss_flag;//缺ā?页?标括?志?,?若?为a1,?则ò缺ā?页?
intmiss_count;//缺ā?页?次?数簓
BlockNode*front;
BlockNode*rear;
}Block;
if(!Block.front){
printf("内ú存?分?配?失骸?败悒?\n");
exit(0);
}
Block.length=0;
Block.miss_count=0;
Block.rear->next=NULL;
}
voidenqueue(intpage_index)//入?队ó
{
BlockNode*node=(BlockNode*)malloc(sizeof(BlockNode));
if((i+1)%5== 0){
printf("\n");
}//if
}
printf("\n");
}
voidFIFO_Replace(intpage_index)//FIFO置?换?
{
BlockNode*node;
if(!Block.length){
enqueue(page_index);
Block.miss_flag=0;
if(num>=down&& num<=up)
break;
printf("输?入?范?围§有瓺误ó,请?重?新?输?入?:");
}//while
returnnum;
页面置换算法实验报告
页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中,页面置换算法是一种重要的内存管理策略。
当物理内存不足以容纳所有需要运行的进程时,操作系统需要根据一定的算法将部分页面从内存中换出,以便为新的页面腾出空间。
本实验旨在通过实际操作,对比不同的页面置换算法在不同场景下的性能表现。
二、实验背景在计算机系统中,每个进程都有自己的虚拟内存空间,而物理内存空间是有限的。
当进程需要访问某个页面时,如果该页面不在物理内存中,就会发生缺页中断,操作系统需要根据页面置换算法选择一个页面将其换出,然后将需要访问的页面换入。
常见的页面置换算法有先进先出(FIFO)、最近最久未使用(LRU)、时钟(Clock)等。
三、实验目的本实验旨在通过模拟不同的页面置换算法,比较它们在不同情况下的缺页率和效率。
通过实验结果,评估各个算法在不同场景下的优劣,为实际系统的内存管理提供参考。
四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较:FIFO、LRU和Clock。
我们使用C++编程语言模拟了一个简单的内存管理系统,并通过产生不同的访存序列来模拟不同的场景。
实验中,我们设置了不同的物理内存大小,访存序列长度和页面大小,以模拟不同的系统环境。
五、实验结果与分析在实验中,我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。
通过统计不同算法的缺页率和运行时间,得出以下结论:1. FIFO算法FIFO算法是最简单的页面置换算法,它按照页面进入内存的顺序进行置换。
实验结果表明,FIFO算法在缺页率方面表现一般,特别是在访存序列具有局部性的情况下,其性能明显下降。
这是因为FIFO算法无法区分不同页面的重要性,可能会将经常使用的页面换出,导致缺页率升高。
2. LRU算法LRU算法是一种基于页面访问时间的置换算法,它认为最近被访问的页面很可能在未来会被再次访问。
实验结果表明,LRU算法在缺页率方面表现较好,特别是在访存序列具有较强的局部性时,其性能明显优于FIFO算法。
操作系统实验-页面置换算法
四种页面置换算法一、实验原理:在存运行过程中,若其所要访问的页面不在存而需要把他们调入存,但存已经没有空闲空间时,为了保证该进程能正常运行,系统必须从存中调出一页程序或数据送磁盘的对换区中。
但应将那个页面调出,需根据一定的算法来确定。
通常,把选择换出页面的算法成为页面置换算法。
置换算法的好坏,将直接影响到系统的性能。
一个好的页面置换算法,应具有较低的页面更换频率。
从理论上讲,应将那些以后不再会访问的页面置换出,或者把那些在较长时间不会在访问的页面调出。
目前存在着许多种置换算法(如FIFO,OPT,LRU),他们都试图更接近理论上的目标。
二、实验目的1.通过模拟实现几种基本页面置换的算法,了解虚拟存储技术的特点。
2.掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想,并至少用三种算法来模拟实现。
3.通过对几种置换算法页面的比较,来对比他们的优缺点,并通过比较更换频率来对比它们的效率。
三、实验分析在进程运行过程中,若其所访问的页面不存在存而需要把它们调入存,但存已无空闲时,为了保证该进程能够正常运行,系统必须从存中调出一页程序或数据送磁盘的对换区中。
但应调出哪个页面,需根据一定的算法来确定,算法的好坏,直接影响到系统的性能。
四、运行结果五、代码#include"stdafx.h"#define M 3 //物理页数#define N 20 //需要调入的页数typedef struct page {int num;int time;int temp;}Page; //物理页项,包括调入的页号和时间Page pp[M]; //M个物理页int queue1[20], queue2[20], queue3[20]; //记录置换的页int K = 0, S = 0, T = 0; //置换页数组的标识int pos = 0;//记录存在最长时间项int changenum = 0;int A[N];//初始化存页表项及存储存情况的空间void INIT(){int i;for (i = 0; i<M; i++){pp[i].num = -1;pp[i].time = 0;pp[i].temp = 0;} }//取得存中存在时间最久的位置int GetMax(){int max = -1;int i;for (i = 0; i<M; i++){if (pp[i].time > max){max = pp[i].time;pos = i;}}return pos;}//检查最长时间不使用页面int longestTime(int mxatimep,int temp) {int i;int max = -1;for (i = 0; i<M; i++){pp[i].temp = 0;}for (i = temp; i<N; i++){if (pp[0].temp == 1 && pp[1].temp == 1 && pp[2].temp == 1){ break;}if (pp[0].num != A[i]){pp[0].time++;if (pp[0].temp >= 1){pp[0].time--;}}else{pp[0].temp++;}if (pp[1].num != A[i]){pp[1].time++;if (pp[1].temp >= 1){pp[1].time--;}}else{pp[1].temp++;}if (pp[2].num != A[i]){pp[2].time++;if (pp[2].temp >= 1){pp[2].time--;}else{pp[2].temp++;}}for (i = 0; i<M; i++){if (pp[i].time>max){max = pp[i].time;pos = i;}}return pos;}//检查某页是否在存int Equation(int fold){int i;for (i = 0; i<M; i++){if (pp[i].num == fold)return i;}return -1;}//检查物理存是否已满,-1表满,其他不满int Check(){int i;for (i = 0; i<M; i++){if (pp[i].num == -1)return i;}return -1;}void FIFO(int fold,int temp){int i;int a, b, c;a = Equation(fold);//页已存在if (a != -1){}//页不存在else{b = Check();//存还有空闲if (b != -1){pp[b].num = fold;//存已满,需要置换else {c = GetMax();pp[c].num = fold;pp[c].time = 0;changenum++;}queue1[K++] = fold;}for (i = 0; i<M; i++){if (pp[i].num != -1){pp[i].time++;}}}void OPT(int fold,int temp){int a, b, c;a = Equation(fold);if (a == -1){//页不在存b = Check();//存还有空闲if (b != -1){pp[b].num = fold;}//存已满,需要置换else{c = longestTime(fold,temp);pp[c].num = fold;pp[c].time = 0;changenum++;}queue3[T++] = fold;}}void LRU(int fold,int temp){int i;int a, b;int p;a = Equation(fold);if (a != -1)//页已在存{//把此项移动到链表最后一项if (a == 2)//此项已经在最后,不需要做任何改动{}else{p = Equation(-1);if (p == -1)//链表是满的{for (; a<2; a++)pp[a].num = pp[a + 1].num;pp[2].num = fold;}else if (p <= 3)//链表不满{for (; a<p - 1; a++)pp[a].num = pp[a + 1].num;pp[a].num = fold;}}}else{b = Check();if (b != -1)//不满pp[b].num = fold;else{for (i = 0; i<2; i++)pp[i].num = pp[i + 1].num;pp[2].num = fold;changenum++;}queue2[S++] = fold;}}int_tmain(int argc, _TCHAR* argv[]){int B[N];int i;INIT();changenum = 0;printf("请依次输入%d个页面号:\n", N);for (i = 0; i<N; i++){scanf_s("%d", &A[i]);}//OPTprintf("\n");printf("1.最佳置换算法(Opt)\n");INIT();changenum = 0;for (i = 0; i<N; i++){B[i] = A[i];}for (i = 0; i<N; i++){OPT(B[i], i);}printf("\n");printf("OPT算法,调入页面顺序为:");for (i = 0; i<T; i++)printf("%3d", queue3[i]);printf("\n页面置换次数为:%6d\n缺页率:%16.2f\n\n", changenum, (float)changenum / N); //FIFOprintf("2.先进先出页面置换算法(FIFO)\n");INIT();changenum = 0;for (i = 0; i<N; i++){B[i] = A[i];}for (i = 0; i<N; i++){FIFO(B[i], i);}printf("FIFO算法,调入页面顺序为:");for (i = 0; i<K; i++)printf("%3d", queue1[i]);printf("\n页面置换次数为:%6d\n缺页率:%16.2f\n\n", changenum, (float)changenum / N);//LRUprintf("3.最近最久未使用算法(LRU)\n");INIT();changenum = 0;for (i = 0; i<N; i++){B[i] = A[i];}for (i = 0; i<N; i++){LRU(B[i], i);}printf("LRU算法,调入页面顺序为:");for (i = 0; i<S; i++)printf("%3d", queue2[i]);printf("\n页面置换次数为:%6d\n缺页率:%16.2f\n\n", changenum, (float)changenum / N);printf("\n");printf("四种算法已全部执行完毕!\n");return 0;}。
虚拟内存页面置换算法实训报告
虚拟内存页面置换算法实训报告1. 介绍虚拟内存页面置换算法的概念和作用- 虚拟内存是计算机操作系统中的一种技术,它允许程序访问比物理内存更大的地址空间。
- 页面置换算法是虚拟内存管理的一种重要策略,它用于在物理内存不足时将一部分页面移出物理内存,以便为新的页面腾出空间。
2. 算法分类- 最优页面置换算法(OPT):根据未来的访问情况,选择最长时间内不再被访问的页面进行置换。
- 先进先出页面置换算法(FIFO):选择最早进入物理内存的页面进行置换。
- 最近最少使用页面置换算法(LRU):选择最长时间内未被访问的页面进行置换。
- 时钟页面置换算法(CLOCK):使用一个指针指向当前页面,选择指针指向的页面进行置换。
3. 算法比较- OPT算法是最理想的页面置换算法,但实际上很难实现,因为需要预测未来的页面访问情况。
- FIFO算法简单易实现,但可能会出现“抖动”现象,即频繁地将同一页面置换出去再置换回来。
- LRU算法性能较好,但实现较为复杂,需要维护一个访问时间戳。
- CLOCK算法是对LRU算法的一种改进,实现较为简单,但在某些情况下可能会出现性能问题。
4. 实验设计- 使用C++语言实现了FIFO、LRU和CLOCK三种页面置换算法。
- 使用随机生成的页面序列进行测试,记录每种算法的缺页率和执行时间。
- 分析实验结果,比较各种算法的优缺点。
5. 实验结果- 在测试中,FIFO算法的缺页率最高,CLOCK算法的缺页率最低,LRU 算法的缺页率居中。
- 在执行时间方面,CLOCK算法最快,FIFO算法最慢,LRU算法居中。
- 综合考虑,可以根据具体的应用场景选择适合的页面置换算法。
6. 结论- 虚拟内存页面置换算法是操作系统中的重要技术,对系统性能有着重要影响。
- 不同的页面置换算法有着各自的优缺点,需要根据具体情况进行选择。
- 实验结果表明,CLOCK算法在缺页率和执行时间方面都表现较好,可以作为一种较为通用的页面置换算法。
操作系统实验页面置换算法实验
淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求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%。
页面置换算法实验报告
页面置换算法实验报告一、实验目得:设计与实现最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Clock置换算法;通过支持页面访问序列随机发生实现有关算法得测试及性能比较、二、实验内容:●虚拟内存页面总数为N,页号从0到N—1●物理内存由M个物理块组成●页面访问序列串就是一个整数序列,整数得取值范围为0到N - 1、页面访问序列串中得每个元素p表示对页面p得一次访问●页表用整数数组或结构数组来表示❑符合局部访问特性得随机生成算法1.确定虚拟内存得尺寸N,工作集得起始位置p,工作集中包含得页数e,工作集移动率m(每处理m个页面访问则将起始位置p +1),以及一个范围在0与1之间得值t;2.生成m个取值范围在p与p+ e间得随机数,并记录到页面访问序列串中;3.生成一个随机数r,0 ≤r ≤1;4.如果r〈t,则为p生成一个新值,否则p = (p+1) mod N;5.如果想继续加大页面访问序列串得长度,请返回第2步,否则结束。
三、实验环境:操作系统:Windows7软件: VC++6.0四、实验设计:本实验包含六种算法,基本内容相差不太,在实现方面并没有用统一得数据结构实现,而就是根据不同算法得特点用不同得数据结构来实现:1、最佳置换与随机置换所需操作不多,用整数数组模拟内存实现;2、先进先出置换与最近最久未使用置换具有队列得特性,故用队列模拟内存来实现;3、CLOCK置换与改进得CLOCK置换具有循环队列得特性,故用循环队列模拟内存实现;4、所有算法都就是采用整数数组来模拟页面访问序列。
五、数据结构设计://页面访问序列数组:intref[ref_size];//内存数组:int phy[phy_size];//队列数据结构定义:typedef struct QNodeﻩ//定义队列数据结构{ﻩint data;struct QNode *next;}QNode,*QueuePtr;typedefstruct{QueuePtr front;ﻩ//头指针ﻩQueuePtr rear;ﻩ//尾指针}LinkQueue;//定义链表数据结构typedefstruct LNode//定义循环链表数据结构{int data;int flag;ﻩ//访问位int modify;ﻩﻩ//修改位ﻩstruct LNode*next;}LNode,*LinkList;六、主要函数说明:1、void set_rand_num()ﻩ//产生具有局部特性得随机数列;2、int Exchange_LNode(LinkList&L,inte,int i)//将链表L中序号为i得结点替换为内容为e得结点;3、bool Search_LinkList(LinkList&L,int e,int&i)//找到链表L中内容为e得结点,并用i返回其位置,i=1表示第一个非头结点,依次类推;4、void Search_LL_Flag(LinkList&L,int &i)//用i返回第一个flag为0得结点得位置,i=1表示第一个非头结点,以此类推;5、void Set_LL_Flag(LinkList&L,int i) //设置链表L中得序号为i得结点得flag标志为1;6、intSearch_LL_ModifyClock(LinkList &L,int&modify_num)//找到改进得CLOCK算法所需要淘汰得页,用modify_num返回其位置;此函数根据书上给得思路,第一遍扫描A=0且M=0得页面予以淘汰,若失败,则进行第二轮扫描A=0且M=1得页面,第二轮扫描时将所有访问过得页面得访问位A置0;若失败则重复上述两部;7、void Set_LL_modify(LinkList&L,int i) //设置链表L中得序号为i得结点得modify标志为1;8、boolSearchQueue(LinkQueue &Q,inte,int &i)ﻩ//寻找队列Q中结点data域等于e得结点,并用i返回其在Q中得位置;9、int getnum(int a,intb)ﻩﻩ//用b返回元素a在被引用数列中得下一个位置10、void ORA() //实现最佳置换算法,包括判断页面就是否在内存中、页面进内存、输出内存状态等内容;11、void RAND() ﻩ//随机置换算法12、void FIFO() ﻩﻩﻩ//先进先出算法13、voidLRU() ﻩﻩ//最近最久未使用算法实现最近最久未使用算法得思想就是:判断待进入内存得页面,如果与内存中得第一个页面相同,则将它移到最后一个,即标志为最近使用得页;如果与内存中得第二个页面相同,则将它删除,并在队列尾部添加相同元素,即标志为最近使用得页;ﻩ14、void CLOCK()ﻩﻩ//实现CLOCK算法15、void Modified_Clock() //实现改进得CLOCK算法16、intmain() //主函数,调用实现各算法得6个主要函数,并输出各算法得缺页率。
操作系统实验报告材料6-页面置换算法模拟
实验报告( 2013 / 2014学年第1学期)课程名称操作系统原理实验名称实验6:页面置换算法模拟实验时间2013 年12 月 10 日指导单位软件工程系指导教师杨健学生姓名班级学号学院(系) 软件工程系专业计算机软件与服务外包//物?理え?块é定¨义?typedef struct BlockNode{int page_index;//page数簓组哩?的?下?标括?struct BlockNode * next;}BlockNode;struct{int length;//当獭?前°物?理え?块é长¤度èint miss_flag;//缺ā?页?标括?志?,?若?为a1,?则ò缺ā?页?int miss_count;//缺ā?页?次?数簓BlockNode*front;BlockNode*rear;}Block;//本?程ì序ò中D全?局?变?量?名?均ù由?两?个?单蹋?词洙?组哩?成é,?且ò开a头?字?母?大洙?写′int BlockSize = 5;//物?理え?块é大洙?小?int PageCount = 200;//页?面?总哩?数簓int PageSize = 1024;//页?面?大洙?小?int AddrRange = 8*1024;//访?问ê地?址·范?围§int get_num(int down,int up)//得?到?一?个?down~up之?间?的?整?数簓{int num;char str[111];while(1){fgets(str,111*sizeof(int),stdin);num=atoi(str);//把?字?符?串?中D的?数簓字?转羇换?为a整?数簓if(num>=down&& num<=up)break;printf("输?入?范?围§有瓺误ó,请?重?新?输?入?:");}//whilereturn num;}void init_block()//构1造ì一?个?空?的?物?理え?块é队ó列{Block.rear=Block.front=(BlockNode*)malloc(sizeof(BlockNode)); if(!Block.front){printf("内ú存?分?配?失骸?败悒?\n");exit(0);}Block.length=0;Block.miss_count=0;Block.rear->next=NULL;}void enqueue(int page_index)//入?队óvoid clear_block()//清?空?物?理え?块é{while(Block.rear=Block.front->next){ Block.front->next=Block.rear->next;free(Block.rear);Block.length--;}Block.rear=Block.front;Block.length=0;Block.miss_count=0;}void destroy_block()//销ú毁ù物?理え?块é{while(Block.rear=Block.front){Block.front=Block.front->next;free(Block.rear);}free(page);}void init_page()//初?始?化ˉ页?面?系μ列int i,j;srand(time(NULL));//用?当獭?前°系μ统?时骸?间?来ぁ?初?始?化ˉ随?机ú种?子哩? page=(struct node_page*) malloc(PageCount*sizeof(struct node_page));for(i=0;i<PageCount;i++){page[i].address=rand()%AddrRange;page[i].page_num=page[i].address/PageSize;}for(i=0;i<PageCount;i++){for(j=i+1;j<PageCount;j++){if(page[i].page_num== page[j].page_num){page[i].next_order=j;break;}//if}//forif(j== PageCount)//说μ明÷page[i]以?后ó都?不?会á再ù访?问êpage[i].next_order= PageCount;}//for}void print_page()//打洙?印?页?面?系μ列{int i;printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); printf("页?面?系μ列为a:阰\n");for(i=0;i<PageCount;i++){printf("[%-2d,%-4d]",page[i].page_num,page[i].address%PageSize); if((i+1)%5== 0){printf("\n");}//if}printf("\n");}void FIFO_Replace(int page_index)//FIFO置?换?{BlockNode*node;if(!Block.length){enqueue(page_index);Block.miss_flag=0;return;}node=Block.front;while(node=node->next){if(page[node->page_index].page_num==page[page_index].page_num){destroy_block(); return 0;}截图。
页面置换算法实践报告
页面置换算法实践报告页面置换算法(Page Replacement Algorithm)是操作系统中用于管理虚拟内存的重要算法之一。
其目的是在有限的物理内存空间中,将进程所需的页面加载到内存中,并根据一定的策略替换掉不再被使用的页面,以提高内存利用率和系统性能。
在本次实践报告中,我将重点介绍三种常见的页面置换算法:先进先出(FIFO)、最近最久未使用(LRU)和最不经常使用(LFU)。
先进先出(FIFO)算法是最简单的页面置换算法之一。
它根据页面进入内存的先后顺序进行页面置换。
当一个页面需要被替换时,选择最早进入内存的页面进行替换。
虽然FIFO算法的实现简单,但它无法很好地反映页面的使用频率和重要性,容易发生“缺页率抖动”的问题。
缺页率抖动指的是在某些场景下,缺页率会频繁地快速上升,然后又快速下降。
最近最久未使用(LRU)算法是一种基于页面历史访问记录的页面置换算法。
它认为最近被访问过的页面是最有可能在未来被访问的,因此选择最近最久未使用的页面进行替换。
LRU算法可以较为准确地反映页面的使用频率,避免了FIFO算法的缺点。
但由于需要记录页面的访问历史,因此实现相对复杂,需要额外的开销。
最不经常使用(LFU)算法是一种基于页面使用频率的页面置换算法。
它认为使用频率最低的页面是最不重要的,因此选择最不经常使用的页面进行替换。
LFU算法可以较好地反映页面的使用频率,对于一些热点页面和冷门页面的处理较为准确。
但由于需要记录页面的使用次数,因此实现相对复杂,需要额外的开销。
根据实际情况选择合适的页面置换算法对于系统的性能影响非常重要。
一般来说,FIFO算法比较适用于缺页率较低的情况,而LRU算法则适用于需要较高精确度的场景,而LFU算法则适用于需要特别关注页面使用频率的场景。
在实践中,我们可以使用模拟算法来进行页面置换算法的实验。
通过构造不同的页面访问序列,我们可以测试不同算法的效果并进行比较。
在实验过程中,我们可以观察不同算法的缺页率、替换次数、访问延迟等指标,以评估算法的性能。
操作系统中的虚拟内存管理与页面置换算法分析
操作系统中的虚拟内存管理与页面置换算法分析虚拟内存是一种操作系统的内存管理技术,它能够使得每个程序能够访问比其实际内存大小更大的地址空间,从而提高系统的利用率和性能。
虚拟内存管理的核心任务之一是页面置换算法,它决定了在物理内存不足时,操作系统如何选择将哪些页调入内存、哪些页调出内存。
虚拟内存管理的基本概念是通过将主存划分为大小固定的页,而将程序划分为大小相同的块,即页面。
当程序运行需要访问某个页时,如果该页已经在主存中,则直接访问该页即可。
如果该页不在主存中,则需要通过页面置换算法将其调入主存,同时选择一个页将其置换出去。
页面置换算法的性能直接影响了系统的整体性能和响应速度,因此选择一个合适的页面置换算法至关重要。
常用的页面置换算法有先进先出(FIFO)、最近最久未使用(LRU)、最不经常使用(LFU)等。
FIFO算法是最简单的页面置换算法之一。
它根据页面在主存中进入的先后顺序来进行页面的置换。
即当需要置换页面时,选择在主存中驻留时间最长的页面进行置换。
然而,FIFO算法存在着“先进入的页面先出去”的缺点,这使得系统可能会频繁地置换掉正在频繁使用的页面,从而导致较高的页错误率,降低系统性能。
相比之下,LRU算法是一种更为常用和高效的页面置换算法。
它根据页面的访问历史来进行页面的置换,即当需要置换页面时,选择在最近一段时间内最久未被使用的页面进行置换。
LRU算法能够充分利用局部性原理,即程序往往在短时间内频繁访问一部分页面,因此将最近最久未使用的页面置换出去,可以降低页错误率,提高系统性能。
LFU算法则根据页面的使用频率来进行页面的置换。
LFU算法记录每个页面被访问的次数,当需要置换页面时,选择使用频率最低的页面进行置换。
LFU算法适用于对于频繁使用的页面进行保护,避免被频繁置换出去,但对于使用频率低的页面,可能会长时间占用主存资源。
除了上述常见的页面置换算法外,还有许多其他的页面置换算法,如Clock算法、二次机会算法等。
虚拟内存的页面置换算法
虚拟内存的页面置换算法一、概述虚拟内存是计算机操作系统中的一种技术,它允许程序使用比实际物理内存更大的内存空间。
但是,由于实际物理内存是有限的,虚拟内存的实现需要使用到一种称为页面置换算法的策略。
页面置换算法的作用是根据一定的规则将内存中的页面从物理内存中换出,以便为新的页面腾出空间。
二、FIFO算法FIFO(First In First Out)算法是最简单的页面置换算法之一。
它的原理是将最早进入内存的页面置换出去。
这种算法的实现非常简单,只需要维护一个页面队列,按照页面进入内存的先后顺序进行置换。
然而,FIFO算法存在一个明显的问题,即它无法区分页面的重要性。
如果最早进入内存的页面是一个常用的页面,那么它被置换出去后可能会频繁地被再次访问,从而导致性能下降。
三、LRU算法LRU(Least Recently Used)算法是一种比较常用的页面置换算法。
它的原理是将最近最少使用的页面置换出去。
为了实现LRU算法,需要维护一个页面访问时间的记录。
具体来说,每当一个页面被访问时,就将它的访问时间更新为当前时间。
当需要置换页面时,选择访问时间最早的页面进行置换。
这样做的好处是,能够较好地区分页面的重要性,常用的页面能够保留在内存中,提高系统的性能。
四、LFU算法LFU(Least Frequently Used)算法是根据页面的访问频率进行置换的算法。
它的原理是将访问频率最低的页面置换出去。
为了实现LFU算法,需要维护每个页面的访问次数。
具体来说,每当一个页面被访问时,就将它的访问次数加一。
当需要置换页面时,选择访问次数最低的页面进行置换。
LFU算法的优点是能够适应不同页面访问频率的变化,但是实现起来比较复杂。
五、OPT算法OPT(Optimal)算法是一种理论上的最佳页面置换算法。
它的原理是根据未来的访问情况进行页面置换。
具体来说,OPT算法会根据未来的页面访问情况预测哪个页面在未来最长时间内不会被访问到,然后将其置换出去。
实验六 虚拟内存页面置换算法
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];
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}; //测试数据
【实验要求】
1)上机前认真复习页面置换算法,熟悉FIFO,OPI,LRU三种页面分配和置换算法的过程;
2)上机时独立编程、调试程序;
3)根据具体实验要求,完成好实验报告(包括实验的目的、内容、要求、源程序、实例运行结果截图)。
【源代码】
#include "iostream.h"
const int DataMax=100;
}
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++)
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
int Data[DataMax]; //保存数据
int Block[BlockNum]; //物理块
int count[BlockNum]; //计数器
int N ; //页面个数
int M;//最小物理块数
intChangeTimes;
void DataInput(); //输入数据的函数
5
一、实验目的
通过这次实验,加深对虚拟存页面置换概念的理解,进一步掌握先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
二.实验环境
C++环境
三、实验容与步骤
问题描述:
设计程序模拟先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。假设存中分配给每个进程的最小物理块数为m,在进程运行过程中要访问的页面个数为n,页面访问序列为P1,…,Pn,分别利用不同的页面置换算法调度进程的页面访问序列,给出页面访问序列的置换过程,计算每种算法缺页次数和缺页率。
// FIFO();
// Optimal();
// LRU();
// return 0;
int menu;
while(true)
{
cout<<endl;
cout<<"*菜单选择*"<<endl;
cout<<"*******************************************************"<<endl;
for(j=0;j<M;j++)
{
cout<<" ";
for(i=0;i<N;i++) //对所有数据操作
{
if( DataShowEnable[j][i] )
cout<<DataShow[j][i]<<" ";
else
cout<<" ";
}
cout<<endl;
}
cout<<"缺页次数: "<<ChangeTimes<<endl;
{
cout<<"请输入最小物理块数:";
cin>>M;
while(M > BlockNum) //大于数据个数
{
cout<<"物理块数超过预定值,请重新输入:";
cin>>M;
}
cout<<"请输入页面的个数:";
cin>>N;
while(N > DataMax) //大于数据个数
{
cout<<"页面个数超过预定值,请重新输入:";
【实验要求】
1)上机前认真复习页面置换算法,熟悉FIFO,OPI,LRU三种页面分配和置换算法的过程;
2)上机时独立编程、调试程序;
3)根据具体实验要求,完成好实验报告(包括实验的目的、容、要求、源程序、实例运行结果截图)。
【源代码】
#include "iostream.h"
const int DataMax=100;
cin>>menu;
switch(mereak;
case 2: Optimal();break;
case 3: LRU();break;
default: break;
}
if(menu!=1&&menu!=2&&menu!=3) break;
}
}
//*/
void DataInput()
政法学院
本科生实验报告
(六)
:马晓娟
学院:公安技术学院
专业:信息安全
班级:2013级信息安全
实验课程名称:
实验日期:2015年12月2日
指导教师及职称:王云峰
实验成绩:
开课时间:2015-2016学年第一学期
政法学院实验管理中心印制
实验题目
虚拟存页面置换算法
小组合作
否
马晓娟
班级
2013级信息安全
学号
for(i=0;i<M;i++)
{
count[i] = 0; //大于等于BlockNum,表示块中没有数据,或需被替换掉
//所以经这样初始化(3 2 1),每次替换>=3的块,替换后计数值置1,
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}; //测试数据
void DataOutput();
void FIFO(); // FIFO函数
void Optimal(); // Optimal函数
void LRU(); // LRU函数
///*
int main(int argc, char* argv[])
{
DataInput();// DataInput();
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,表示没有要显示的数据
程序要求如下:
1)利用先进先出FIFO,最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。
2)模拟三种算法的页面置换过程,给出每个页面访问时的存分配情况。
3)输入:最小物理块数m,页面个数n,页面访问序列P1,…,Pn,算法选择1-FIFO,2-OPI,3-LRU。
4)输出:每种算法的缺页次数和缺页率。
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;
cout<<"* 1-FIFO *"<<endl;
cout<<"*2-Optimal*"<<endl;
cout<<"*3-LRU*"<<endl;
cout<<"*0-EXIT*"<<endl; cout<<"*******************************************************"<<endl;