实验3-页面调度算法

合集下载

页面调度算法模拟实验中遇到的问题

页面调度算法模拟实验中遇到的问题

页面调度算法模拟实验中遇到的问题在页面调度算法模拟实验中,可能会遇到以下一些问题:
1、算法选择问题:不同的页面调度算法有不同的优势和适用场景,如FIFO、LRU、OPT等。

在实验中,选择合适的算法是一个挑战。

可能需要考虑内存大小、访问模式、页面访问频率等因素,以确定使用哪种算法进行模拟实验。

2、数据集选择问题:在模拟实验中,需要使用真实或合成的数据集来模拟页面访问的情况。

选择合适的数据集是一个关键问题,需要考虑数据集的规模、访问模式的真实性以及数据集的可用性等因素。

3、实验结果的评估问题:页面调度算法的性能可以通过不同的指标进行评估,如缺页率、命中率、平均访问时间等。

在实验中,选择合适的评估指标以及评估方法是一个重要问题。

4、实验参数的设置问题:在模拟实验中,还需要考虑一些参数的设置,如内存大小、页面大小、进程数量等。

这些参数的选择可能会对实验结果产生影响,需要合理设置以保证实验的可靠性和有效性。

5、实验结果的可视化问题:实验结果的可视化是一个重要的环节,可以通过图表、曲线等形式展示实验结果,以便于对比不同算法的性能表现。

在实验中,实现合适的可视化方式可能会遇到一些技术上的挑战。

这些问题都需要在实验前进行充分的准备和规划,以确保实验的
可靠性和有效性。

同时,也需要注意实验过程中可能遇到的其他问题,并及时进行调整和解决。

操作系统实验报告——调度算法

操作系统实验报告——调度算法

操作系统实验报告——调度算法1. 实验目的本实验旨在探究操作系统中常用的调度算法,通过编写代码模拟不同的调度算法,了解它们的特点和应用场景。

2. 实验环境本次实验使用的操作系统环境为Linux,并采用C语言进行编码。

3. 实验内容3.1 调度算法1:先来先服务(FCFS)FCFS调度算法是一种简单且常见的调度算法。

该算法按照进程到达的先后顺序进行调度。

在本实验中,我们使用C语言编写代码模拟FCFS算法的调度过程,并记录每个进程的等待时间、周转时间和响应时间。

3.2 调度算法2:最短作业优先(SJF)SJF调度算法是一种非抢占式的调度算法,根据进程的执行时间来选择下一个要执行的进程。

在本实验中,我们使用C语言编写代码模拟SJF算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。

3.3 调度算法3:轮转调度(Round Robin)Round Robin调度算法是一种经典的时间片轮转算法,每个进程在给定的时间片内依次执行一定数量的时间。

如果进程的执行时间超过时间片,进程将被暂时挂起,等待下一次轮转。

在本实验中,我们使用C语言编写代码模拟Round Robin算法的调度过程,并计算每个进程的等待时间、周转时间和响应时间。

4. 实验结果分析通过对不同调度算法的模拟实验结果进行分析,可以得出以下结论:- FCFS算法适用于任务到达的先后顺序不重要的场景,但对于执行时间较长的进程可能会导致下一个进程需要等待较久。

- SJF算法适用于任务的执行时间差异较大的场景,能够提高整体执行效率。

- Round Robin算法适用于时间片相对较小的情况,能够公平地为每个进程提供执行时间。

5. 实验总结本次实验通过模拟不同调度算法的实际执行过程,深入了解了各种调度算法的原理、特点和适用场景。

通过对实验结果的分析,我们可以更好地选择合适的调度算法来满足实际应用的需求。

在后续的学习中,我们将进一步探索更多操作系统相关的实验和算法。

调度的调度算法实验报告

调度的调度算法实验报告

调度的调度算法实验报告调度的调度算法实验报告引言:调度是计算机科学中一个重要的概念,它涉及到任务分配、资源管理和优化等方面。

调度算法则是实现调度的关键,它决定了任务的执行顺序和资源的分配方式。

在本次实验中,我们将探讨几种常见的调度算法,并通过实验对其性能进行评估和比较。

一、先来先服务算法(FCFS)先来先服务算法是最简单的调度算法之一,它按照任务到达的先后顺序进行处理。

实验中,我们模拟了一个任务队列,每个任务有不同的执行时间。

通过实验结果可以看出,FCFS算法的优点是简单易懂,但当任务的执行时间差异较大时,会导致平均等待时间较长。

二、最短作业优先算法(SJF)最短作业优先算法是一种非抢占式调度算法,它根据任务的执行时间来进行排序。

实验中,我们将任务按照执行时间从短到长进行排序,并进行调度。

实验结果显示,SJF算法的优点是能够最大程度地减少平均等待时间,但当任务的执行时间无法预测时,该算法可能会导致长任务等待时间过长的问题。

三、时间片轮转算法(RR)时间片轮转算法是一种抢占式调度算法,它将任务分为多个时间片,并按照顺序进行调度。

实验中,我们设置了每个时间片的长度,并将任务按照到达顺序进行调度。

实验结果表明,RR算法的优点是能够公平地分配资源,但当任务的执行时间超过一个时间片时,会导致上下文切换频繁,影响系统的性能。

四、最高响应比优先算法(HRRN)最高响应比优先算法是一种动态调度算法,它根据任务的等待时间和执行时间来计算响应比,并选择响应比最高的任务进行调度。

实验中,我们根据任务的到达时间、执行时间和等待时间计算响应比,并进行调度。

实验结果显示,HRRN算法能够在一定程度上平衡长任务和短任务的等待时间,但当任务的执行时间过长时,会导致其他任务的等待时间过长。

五、多级反馈队列算法(MFQ)多级反馈队列算法是一种综合性的调度算法,它将任务分为多个队列,并根据任务的执行情况进行调度。

实验中,我们设置了多个队列,并根据任务的执行时间和等待时间进行调度。

页面调度实验报告

页面调度实验报告

一、实验内容(1)页面调度算法目前有许多页面调度算法,本实验主要涉及先进先出调度算法、最近最少调度算法、最近最不常用调度算法。

本实验使用页面调度算法时作如下假设,进程在创建时由操作系统为之分配一个固定数目物理页,执行过程中物理页的数目和位置不会改变。

也即进程进行页面调度时只能在分到的几个物理页中进行。

下面对各调度算法的思想作一介绍。

<1> 先进先出调度算法先进先出调度算法根据页面进入内存的时间先后选择淘汰页面,先进入内存的页面先淘汰,后进入内存的后淘汰。

本算法实现时需要将页面按进入内存的时间先后组成一个队列,每次调度队首页面予以淘汰。

<2>最近最少调度算法先进先出调度算法没有考虑页面的使用情况,大多数情况下性能不佳。

根据程序执行的局部性特点,程序一旦访问了某些代码和数据,则在一段时间内会经常访问他们,因此最近最少用调度在选择淘汰页面时会考虑页面最近的使用,总是选择在最近一段时间以来最少使用的页面予以淘汰。

算法实现时需要为每个页面设置数据结构记录页面自上次访问以来所经历的时间。

<3>最近最不常用调度算法由于程序设计中经常使用循环结构,根据程序执行的局部性特点,可以设想在一段时间内经常被访问的代码和数据在将来也会经常被访问,显然这样的页面不应该被淘汰。

最近最不常用调度算法总是根据一段时间内页面的访问次数来选择淘汰页面,每次淘汰访问次数最少的页面。

算法实现时需要为每个页面设置计数器,记录访问次数。

计数器由硬件或操作系统自动定时清零。

(2)缺页调度次数和缺页中断率、缺页置换率计算缺页中断次数是缺页时发出缺页中断的次数。

缺页中断率=缺页中断次数/总的页面引用次数*100%缺页调度次数是调入新页时需要进行页面调度的次数缺页置换率=缺页调度次数/总的页面引用次数*100%二、总体设计1、算法的原理说明FIFO 先进先出调度算法:当页面框满时,最早进来的页面调出;LRU 最近最少使用调度算法:当页面框满时,最近最少使用的页面调出LFU 最近最不常用调度算法:当页面框满时,最近最不常用的页面调出SECOND 二次机会调度算法:当页面框满时,页面调入时R=0,当被访问时R = 1。

操作系统实验-页面调度算法

操作系统实验-页面调度算法

操作系统实验报告专业计算机及应用(本)姓名考号指导老师实验一 DOS/Windows用户接口与进程管理一.实验目的了解和掌握DOS/Windows有关用户接口和进程管理的特点二.实验内容1.MS-DOS的命令接口(1)再当前目录下建立子目录MYTEMP和MYTEMP2,将当前目录设定为MYTEMP;解: c:\>md MYTEMP MYTEMP2c:\>cd MYTEMP(2)再当前目录下创建新文件B.BAT,其内容为:清除屏幕内容,显示当前DOS版本;解: c:\MYTEMP>editclsver(3)使用type命令显示B.BAT的内容,执行他;解: C:\MYTEMP>type b.batC:\MYTEMP>b.bat(4)拷贝B.BAT到路径MYTEMP2中;解: c:\MYTEMP>copy b.bat c:\MYTEMP2(5)删除MYTEMP2中的文件B.BAT,删除目录MYTEMP2;解: c:\MYTEMP>del c:\MYTEMP2\B.BATc:\MYTEMP>rd c:\MYTEMP2(6)使用deltree命令删除MYTEMP.解: c:\MYTEMP>cd\c:\>deltree MYTEMP2.MS-DOS的进程管理(1)运行编辑程序EDIT,可以同时再运行其它命令吗?答:不可以再运行其他命令。

(2)执行如下管道和换向命令:C:\>dir>dir.lst答: dir 命令生成的C:\ 盘下的目录和文件列表重定向到dir.lst文件:如果dir.lst文件不存在,将创建该文件。

如果dir.lst 存在,将使用 dir 命令的输出替换文件中的信息。

C:\>type dir.lst|more答:显示dir.lst文件内容。

C:\dir |FIND“<DIR>”答:在C盘下查找和显示包含字符串“<DIR>”的文件名,并使用管道号 (|) 将 dir 命令的结果重新定向到find 中,dir 命令的输出是通过 find 筛选器命令进行发送的C:\dir *.*|SORT/+14答:列出C盘下的所有目录和文件,并按照一定的排序规则输出结果,排序规则为:使用/+n 命令行时,/+14表示每个比较应该在每行的第14个字符开始。

实验三页面置换算法模拟实验

实验三页面置换算法模拟实验

计算机科学系实验报告书课程名:《操作系统》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求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值,表示该虚页的最后一次被访问时间。

页面调度实验报告

页面调度实验报告

南通大学计算机科学与技术学院操作系统页面调度实验报告班级___________计091___________姓名__________ _ _______ _学号_____________ _指导教师戴树贵一、实验目的1.进一步理解页面调度算法的相关内容2.明白页面调度的主要内容3.通过编程掌握页面调度的主要算法二、实验要求页式虚拟存储器实现的一个难点是设计页面调度(置换)算法,即将新页面调入内存时,如果内存中所有的物理页都已经分配出去,就要按某种策略来废弃某个页面,将其所占据的物理页释放出来,供新页面使用。

本实验的目的是通过编程实现几种常见的页面调度(置换)算法,加深读者对页面思想的理解。

三、实验环境Microsoft Visual Basic 6.0 中文版四、实验内容1 先入先出法(FIFO)最简单的页面置换算法是先入先出(FIFO)法。

这种算法的实质是,总是选择在主存中停留时间最长(即最老)的一页置换,即先进入内存的页,先退出内存。

理由是:最早调入内存的页,其不再被使用的可能性比刚调入内存的可能性大。

建立一个FIFO队列,收容所有在内存中的页。

被置换页面总是在队列头上进行。

当一个页面被放入内存时,就把它插在队尾上。

这种算法只是在按线性顺序访问地址空间时才是理想的,否则效率不高。

因为那些常被访问的页,往往在主存中也停留得最久,结果它们因变“老”而不得不被置换出去。

FIFO的另一个缺点是,它有一种异常现象,即在增加存储块的情况下,反而使缺页中断率增加了。

当然,导致这种异常现象的页面走向实际上是很少见的。

2 最优置换算法(OPT)最优置换(Optimal Replacement)是在理论上提出的一种算法。

其实质是:当调入新的一页而必须预先置换某个老页时,所选择的老页应是将来不再被使用,或者是在最远的将来才被访问。

采用这种页面置换算法,保证有最少的缺页率。

但是最优页面置换算法的实现是困难的,因为它需要人们预先就知道一个进程整个运行过程中页面走向的全部情况。

调度算法的实验报告

调度算法的实验报告

一、实验目的1. 理解操作系统调度算法的基本原理和概念。

2. 掌握几种常见调度算法的原理和实现方法。

3. 分析不同调度算法的性能特点,为实际应用提供参考。

二、实验内容本次实验主要涉及以下几种调度算法:先来先服务(FCFS)、最短作业优先(SJF)、优先级调度(Priority Scheduling)、最高响应比优先(HRRN)和时间片轮转(Round Robin)。

1. 先来先服务(FCFS)调度算法FCFS调度算法按照进程到达就绪队列的顺序进行调度,先到达的进程先执行。

该算法简单易实现,但可能导致长作业等待时间过长,从而降低系统吞吐量。

2. 最短作业优先(SJF)调度算法SJF调度算法优先选择执行时间最短的进程进行调度。

该算法可以最大程度地减少平均等待时间和平均周转时间,但可能导致长作业等待时间过长。

3. 优先级调度(Priority Scheduling)算法优先级调度算法为每个进程设置一个优先级,优先选择优先级高的进程进行调度。

该算法可以满足高优先级作业的需求,但可能导致低优先级作业长时间等待。

4. 最高响应比优先(HRRN)调度算法HRRN调度算法为每个进程设置一个响应比,优先选择响应比高的进程进行调度。

响应比是作业的等待时间与作业所需时间的比值。

该算法综合考虑了作业的等待时间和所需时间,是一种较为公平的调度算法。

5. 时间片轮转(Round Robin)调度算法时间片轮转调度算法将CPU时间划分为固定的时间片,按照进程到达就绪队列的顺序,每次只允许一个进程运行一个时间片。

如果进程在一个时间片内无法完成,则将其放入就绪队列的末尾,等待下一次调度。

该算法可以平衡各个进程的执行时间,但可能导致进程响应时间较长。

三、实验步骤1. 编写一个进程调度程序,实现上述五种调度算法。

2. 生成一个包含多个进程的作业队列,每个进程具有到达时间、所需运行时间和优先级等信息。

3. 分别采用五种调度算法对作业队列进行调度,并记录每个进程的执行情况。

实验三 页面调度算法

实验三   页面调度算法

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

二、实验环境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);}四、实验步骤页面置换:在地址映射过程中,若在页面中发现所要访问的页面不在内存中,则产生缺页中断。

操作系统页面调度算法

操作系统页面调度算法
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页面调度算法实现

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

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

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

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

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

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

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

二、实验目的本次实验旨在通过编写一个页面调度算法程序,深入理解操作系统中页面调度算法的原理和实现方法,并掌握如何使用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),和时钟(Clock)算法。

通过对这些算法的实现和比较,我们将能够更好地理解页面调度算法的原理和效果。

算法介绍1. 先进先出(FIFO)算法:该算法是最简单的页面调度算法之一。

它按照页面进入内存的先后顺序决定删除哪个页面,即最早进入内存的页面被删除。

该算法不考虑页面的使用频率和重要性。

2. 最近最久未使用(LRU)算法:该算法是一种根据页面的使用历史来进行页面调度的算法。

它假设最近一段时间内最久未使用的页面很可能在未来也不会被使用,因此将这些页面优先删除。

3. 时钟(Clock)算法:该算法是一种综合了FIFO算法和LRU算法的页面调度算法。

它使用一个环形链表来存储页面,并使用一个指针指向当前时钟。

当发生页面调度时,指针按照顺时针方向移动,并检查每个页面的访问位。

如果访问位为0,则说明该页面最近未被使用,可以删除;如果访问位为1,则将访问位置为0,表示该页面最近被使用。

实验设计本次实验中,我们将使用python语言实现上述三种页面调度算法,并通过相同的测试数据对它们进行性能比较。

环境配置在开始实验之前,需要安装Python 3.0及以上版本,并确保环境配置正确。

测试数据我们将使用一个虚拟内存大小为4个页面的系统来测试算法的性能。

假设系统会访问一个包含10个页面的访问序列。

访问序列:1, 2, 3, 4, 5, 1, 2, 6, 7, 8实验步骤1. 实现FIFO算法,并对测试数据进行页面调度。

2. 实现LRU算法,并对测试数据进行页面调度。

3. 实现时钟算法,并对测试数据进行页面调度。

调度算法实验报告总结(3篇)

调度算法实验报告总结(3篇)

第1篇一、实验目的本次实验旨在通过模拟操作系统中的进程调度过程,加深对进程调度算法的理解。

实验中,我们重点研究了先来先服务(FCFS)、时间片轮转(RR)和动态优先级调度(DP)三种常见的调度算法。

通过编写C语言程序模拟这些算法的运行,我们能够直观地观察到不同调度策略对进程调度效果的影响。

二、实验内容1. 数据结构设计在实验中,我们定义了进程控制块(PCB)作为进程的抽象表示。

PCB包含以下信息:- 进程编号- 到达时间- 运行时间- 优先级- 状态(就绪、运行、阻塞、完成)为了方便调度,我们使用链表来存储就绪队列,以便于按照不同的调度策略进行操作。

2. 算法实现与模拟(1)先来先服务(FCFS)调度算法FCFS算法按照进程到达就绪队列的顺序进行调度。

在模拟过程中,我们首先将所有进程按照到达时间排序,然后依次将它们从就绪队列中取出并分配CPU资源。

(2)时间片轮转(RR)调度算法RR算法将CPU时间划分为固定的时间片,并按照进程到达就绪队列的顺序轮流分配CPU资源。

当一个进程的时间片用完时,它将被放入就绪队列的末尾,等待下一次调度。

(3)动态优先级调度(DP)算法DP算法根据进程的优先级进行调度。

在模拟过程中,我们为每个进程分配一个优先级,并按照优先级从高到低的顺序进行调度。

3. 输出调度结果在模拟结束后,我们输出每个进程的调度结果,包括:- 进程编号- 到达时间- 运行时间- 等待时间- 周转时间同时,我们还计算了平均周转时间、平均等待时间和平均带权周转时间等性能指标。

三、实验结果与分析1. FCFS调度算法FCFS算法简单易实现,但可能会导致进程的响应时间较长,尤其是在存在大量短作业的情况下。

此外,FCFS算法可能导致某些进程长时间得不到调度,造成饥饿现象。

2. 时间片轮转(RR)调度算法RR算法能够有效地降低进程的响应时间,并提高系统的吞吐量。

然而,RR算法在进程数量较多时,可能会导致调度开销较大。

页面调度算法实验

页面调度算法实验

先进先出页面调度算法的c语言实现main (){int cunchufangwenyemian[4];/*存储访问的页面*/int cunchujisuanguocheng[3][4];/*存储计算过程;*/int cunchushifoumingzhong[4];/*存储是否被命中*/int lie,hang;/*循环变量列,行*/int shifoumingzhong;/*在前一列的位置,没有则为0;*/int wenmenyemiangeshu=4;/*访问页面的个数*//*第一步,初始化*//*输入访问的页面,存到存储访问的页面的数组中*/for (lie=0;lie<4;lie++){printf("\n请输入第%d个页面:",lie);scanf("%d",&cunchufangwenyemian[lie]);}/*初始化计算过程数组*/for (lie=0;lie<4;lie++){for(hang=0;hang<3;hang++){cunchujisuanguocheng[hang][lie]=-1;}}/*初始化是否没有命中的数组*/for (lie=0;lie<4;lie++){cunchushifoumingzhong[lie]=0;}/*第二步,计算*//*察看是否命中*/for (wenmenyemiangeshu=0;wenmenyemiangeshu<4;wenmenyemiangeshu++) {/*对于某一列进行处理*/lie=wenmenyemiangeshu;if (lie==0) /*如果为第一列*/{cunchujisuanguocheng[0][lie]= cunchufangwenyemian[lie]; /*将页面落下来*/cunchushifoumingzhong[0]=0; /*是否命中为0,不命中*/ } else{/*如果不为第一列*/shifoumingzhong=0; /*假设没命中*/for(hang=0;hang<3;hang++){if ( cunchujisuanguocheng[hang][lie-1]== cunchufangwenyemian[lie]){shifoumingzhong=hang+1;/*如果相同,则是否命中为命中的位置*/}}cunchushifoumingzhong[lie]=shifoumingzhong;/*存储命中位置*/}if (lie!=0){if ((shifoumingzhong!=0))/*是否命中*/{/*如果命中,则不变*/for(hang=0;hang<3;hang++){cunchujisuanguocheng[hang][lie]=cunchujisuanguocheng[hang][lie-1];/*将上一列复制过来*/}} else{/*如果没有命中,则向下移一位,新的进来*/for(hang=2;hang>0;hang--){cunchujisuanguocheng[hang][lie]= cunchujisuanguocheng[hang-1][lie-1];/*将上一列逐个下移复制过来*/}cunchujisuanguocheng[0][lie]=cunchufangwenyemian[lie];/*最上面的等于新进来的*/}}}/*第三步,输出*/ /*输出访问序列*/for (lie=0;lie<4;lie++){printf("%d ",cunchufangwenyemian[lie]);}printf("\n"); /*输出计算过程*/for (hang=0;hang<3;hang++){for(lie=0;lie<4;lie++){printf("%d ",cunchujisuanguocheng[hang][lie]);}printf("\n");} /*输出是否命中*/for (lie=0;lie<4;lie++){printf("%d ",cunchushifoumingzhong[lie]);}}运行结果:。

实验3-页面调度算法

实验3-页面调度算法

实验报告院(系):专业班级:学号:姓名:实验地点:实验日期:课程名称实验项目名称实验学时实验类型计算机操作系统页面调度算法 2 验证型一、实验目的及要求通过本实验可以加深理解有关虚拟存储器的工作原理,进一步体会和了解页面替换算法的具体实现方法。

二、实验环境PC /Windows系统/Visual C++6.0三、实验内容①实现三种算法:先进先出;OPT;LRU②页面序列从指定的文本文件(TXT文件)中取出③输出:第一行:每次淘汰的页面号,第二行:显示缺页的总次数四、实验步骤1.先进先出(FIFO)置换算法的思路该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单,只需把一个进程已调入内存的页面,按照先后次序连接成一个队列,并设置一个替换指针,使它总指向最老的页面。

2.最近久未使用(LRU)置换算法的思路最近久未使用置换算法的替换规则,是根据页面调入内存后的使用情况来进行决策的。

该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间,当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。

3.最佳(OPT)置换算法的思路其所选择的被淘汰的页面,将是以后不使用的,或者是在未来时间内不再被访问的页面,采用最佳算法,通常可保证获得最低的缺页率。

4、流程图如下图所示:五、调试过程 程序结构分析:程序共有以下九个部分:int findSpace(void);//查找是否有空闲内存int findExist(int curpage);//查找内存中是否有该页面开始 取一条指令取指令中访问的页号=>L查 页 表页标记=1?形成绝对地址是“存”指令?置L 页修改标记“1”输出绝对地址输出“*页号”有后继指令?取一条指令结 束J:=P[k]J 页的修改标记输出“OUTj ”输出“INL ”P[k]:=L k:=(k+1) mod m修改页面是否是 否否(产生缺页中断)是否int findReplace(void);//查找应予置换的页面void display(void);//显示void FIFO(void);//FIFO算法void LRU(void);//LRU算法void OPT(void);//OPT算法;void BlockClear(void);//BLOCK清空,以便用另一种方法重新演示int main() //主程序六、实验结果及分析程序源代码:#include <iostream.h>#define Bsize 3#define Psize 20struct pageInfor{int content;//页面号int timer;//被访问标记};class PRA{public:PRA(void);int findSpace(void);//查找是否有空闲内存int findExist(int curpage);//查找内存中是否有该页面int findReplace(void);//查找应予置换的页面void display(void);//显示void FIFO(void);//FIFO算法void LRU(void);//LRU算法void Optimal(void);//OPTIMAL算法void BlockClear(void);//BLOCK恢复pageInfor * block;//物理块pageInfor * page;//页面号串private:};PRA::PRA(void){int QString[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};block = new pageInfor[Bsize];for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}page = new pageInfor[Psize];for(i=0; i<Psize; i++){page[i].content = QString[i];page[i].timer = 0;}}int PRA::findSpace(void){for(int i=0; i<Bsize; i++)if(block[i].content == -1)return i;//找到空闲内存,返回BLOCK中位置return -1;}int PRA::findExist(int curpage){for(int i=0; i<Bsize; i++)if(block[i].content == page[curpage].content)return i;//找到内存中有该页面,返回BLOCK中位置return -1;}int PRA::findReplace(void){int pos = 0;for(int i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i;//找到应予置换页面,返回BLOCK中位置return pos;}void PRA::display(void){for(int i=0; i<Bsize; i++)if(block[i].content != -1)cout<<block[i].content<<" "; cout<<endl;}void PRA::Optimal(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){ cout<<"不缺页"<<endl; }else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{for(int k=0; k<Bsize; k++)for(int j=i; j<Psize; j++){if(block[k].content != page[j].content){ block[k].timer = 1000; }//将来不会用,设置TIMER为一个很大数else{block[k].timer = j;break;}}position = findReplace();block[position] = page[i];display();}}}}void PRA::LRU(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;block[exist].timer = -1;//恢复存在的并刚访问过的BLOCK中页面TIMER为-1}else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;}}void PRA::FIFO(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;}else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中所有页面TIMER++ }}void PRA::BlockClear(void){for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}}void main(void){cout<<"|----------页面置换算法----------|"<<endl;cout<<"|---power by kangyan(1318064008)---|"<<endl;cout<<"|-------------------------------------|"<<endl;cout<<"页面号引用串:7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1"<<endl; cout<<"----------------------------------------------------"<<endl;cout<<"选择<1>应用Optimal算法"<<endl;cout<<"选择<2>应用FIFO算法"<<endl;cout<<"选择<3>应用LRU算法"<<endl;cout<<"选择<0>退出"<<endl;int select;PRA test;while(select){cin>>select;switch(select){case 0:break;case 1:cout<<"Optimal算法结果如下:"<<endl;test.Optimal();test.BlockClear();cout<<"----------------------"<<endl;break;case 2:cout<<"FIFO算法结果如下:"<<endl;test.FIFO();test.BlockClear();cout<<"----------------------"<<endl;break;case 3:cout<<"LRU算法结果如下:"<<endl;test.LRU();test.BlockClear();cout<<"----------------------"<<endl;break;default:cout<<"请输入正确功能号"<<endl;break;}}}实验截图如下图所示:<—键入1选择运行LRU算法的置换<—初始化信息:3个页块,20个页面号引用串<—存入前三个页,有空闲内存,无需置换<—3,4页已经在内存中无需再写入<—因为3是最久的页面所以将其置换下面原理相同<—所有命中的页面数<—命中率0.5七、总结页面置换算法的思想可以说比较简单,易懂,但是在实现的时候,也遇到了很多的问题,比如说在找空闲物理块的时候,起初我是比较物理块是否等于0,若为0,则直接把页面放入,后来发现不论什么时候都是把0替换出去,才恍然大悟,既然页面标号有0,就不能用0来表示空闲物理块,后来就换成用-1来表示物理块空闲了。

页面调度算法

页面调度算法

#include<iostream.h>#define da 5int max; //主存页数void fifo(int a[]) //FIFO替换策略{int b[da]; //主存页面int flag=0; //标志在主存中没有float c=0; //缺页率int lackcount=0; //缺页数b[0]=a[0];lackcount++;for(int i=1;i<max;i++){flag=0;for(int j=0;j<da;j++){if(a[i]==b[j])flag=1; //访问序列在主存页面中}if(flag==0) //替换{for(j=da-1;j>0;j--){b[j]=b[j-1];}b[0]=a[i];lackcount++;}}cout<<"缺页次数:";cout<<lackcount<<endl;cout<<"缺页率:";c=float(lackcount/float(max));cout<<c<<endl;}void lru(int a[]) //LRU替换策略{int b[da];int flag=0;float c=0; //缺页率int lackcount=0;b[0]=a[0];lackcount++;for(int i=1;i<max;i++){flag=0;for(int j=0;j<da;j++){if(a[i]==b[j]){ flag=1;while(j>0){b[j]=b[j-1];j--;}b[0]=a[i]; // 把主存中页面刚访问到的放到b[0]}}if(flag==0){for(j=da-1;j>0;j--)b[j]=b[j-1];b[0]=a[i];lackcount++;}}cout<<"缺页次数:";cout<<lackcount<<endl;cout<<"缺页率:";c=float(lackcount/float(max));cout<<c<<endl;}void opt(int a[]) //OPT替换策略{int b[da];for(int m=0;m<da;m++)b[m]=max; //假设初始化主存页面中的max值int flag=0;float c=0;int lackcount=0;b[0]=a[0];lackcount++;for(int i=1;i<max;i++){flag=0;for(int j=0;j<da;j++){if(a[i]==b[j])flag=1;}if(flag==0) //替换{int c[da]; //存放主存页面中序列号在访问序列号中第一次将出现的位置for(int m=0;m<da;m++)c[m]=max; //初始化c[m]for( m=0;m<da;m++)for(int n=i+1;n<max;n++){if(b[m]==a[n]){c[m]=n;break;}}int cmax=c[0],u=0;for( m=1;m<da;m++){if(c[m]>cmax)//数组c中最大的下标{ cmax=c[m];u=m;}}b[u]=a[i];lackcount++;}}cout<<"缺页次数:";cout<<lackcount<<endl;cout<<"缺页率:";c=float(lackcount/float(max));cout<<c<<endl;}void main(){cout<<"输入访问序列的个数:";cin>>max;int *a;a=new int[max];cout<<"请输入访问序列:"<<endl;for(int i=0;i<max;i++){cout<<" ";cin>>a[i];}cout<<endl;cout<<endl;cout<<"FIFO替换策略:"<<endl;fifo(a);cout<<endl;cout<<"LRU替换策略:"<<endl;lru(a);cout<<endl;cout<<"OPT替换策略:"<<endl;opt(a);cout<<endl;}。

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

实验报告院(系):专业班级:学号:姓名:实验地点:实验日期:课程名称实验项目名称实验学时实验类型计算机操作系统页面调度算法 2 验证型一、实验目的及要求通过本实验可以加深理解有关虚拟存储器的工作原理,进一步体会和了解页面替换算法的具体实现方法。

二、实验环境PC /Windows系统/Visual C++6.0三、实验内容①实现三种算法:先进先出;OPT;LRU②页面序列从指定的文本文件(TXT文件)中取出③输出:第一行:每次淘汰的页面号,第二行:显示缺页的总次数四、实验步骤1.先进先出(FIFO)置换算法的思路该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单,只需把一个进程已调入内存的页面,按照先后次序连接成一个队列,并设置一个替换指针,使它总指向最老的页面。

2.最近久未使用(LRU)置换算法的思路最近久未使用置换算法的替换规则,是根据页面调入内存后的使用情况来进行决策的。

该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间,当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。

3.最佳(OPT)置换算法的思路其所选择的被淘汰的页面,将是以后不使用的,或者是在未来时间内不再被访问的页面,采用最佳算法,通常可保证获得最低的缺页率。

4、流程图如下图所示:五、调试过程 程序结构分析:程序共有以下九个部分:int findSpace(void);//查找是否有空闲内存int findExist(int curpage);//查找内存中是否有该页面开始 取一条指令取指令中访问的页号=>L查 页 表页标记=1?形成绝对地址是“存”指令?置L 页修改标记“1”输出绝对地址输出“*页号”有后继指令?取一条指令结 束J:=P[k]J 页的修改标记输出“OUTj ”输出“INL ”P[k]:=L k:=(k+1) mod m修改页面是否是 否否(产生缺页中断)是否int findReplace(void);//查找应予置换的页面void display(void);//显示void FIFO(void);//FIFO算法void LRU(void);//LRU算法void OPT(void);//OPT算法;void BlockClear(void);//BLOCK清空,以便用另一种方法重新演示int main() //主程序六、实验结果及分析程序源代码:#include <iostream.h>#define Bsize 3#define Psize 20struct pageInfor{int content;//页面号int timer;//被访问标记};class PRA{public:PRA(void);int findSpace(void);//查找是否有空闲内存int findExist(int curpage);//查找内存中是否有该页面int findReplace(void);//查找应予置换的页面void display(void);//显示void FIFO(void);//FIFO算法void LRU(void);//LRU算法void Optimal(void);//OPTIMAL算法void BlockClear(void);//BLOCK恢复pageInfor * block;//物理块pageInfor * page;//页面号串private:};PRA::PRA(void){int QString[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};block = new pageInfor[Bsize];for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}page = new pageInfor[Psize];for(i=0; i<Psize; i++){page[i].content = QString[i];page[i].timer = 0;}}int PRA::findSpace(void){for(int i=0; i<Bsize; i++)if(block[i].content == -1)return i;//找到空闲内存,返回BLOCK中位置return -1;}int PRA::findExist(int curpage){for(int i=0; i<Bsize; i++)if(block[i].content == page[curpage].content)return i;//找到内存中有该页面,返回BLOCK中位置return -1;}int PRA::findReplace(void){int pos = 0;for(int i=0; i<Bsize; i++)if(block[i].timer >= block[pos].timer)pos = i;//找到应予置换页面,返回BLOCK中位置return pos;}void PRA::display(void){for(int i=0; i<Bsize; i++)if(block[i].content != -1)cout<<block[i].content<<" "; cout<<endl;}void PRA::Optimal(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){ cout<<"不缺页"<<endl; }else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{for(int k=0; k<Bsize; k++)for(int j=i; j<Psize; j++){if(block[k].content != page[j].content){ block[k].timer = 1000; }//将来不会用,设置TIMER为一个很大数else{block[k].timer = j;break;}}position = findReplace();block[position] = page[i];display();}}}}void PRA::LRU(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;block[exist].timer = -1;//恢复存在的并刚访问过的BLOCK中页面TIMER为-1}else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;}}void PRA::FIFO(void){int exist,space,position ;for(int i=0; i<Psize; i++){exist = findExist(i);if(exist != -1){cout<<"不缺页"<<endl;}else{space = findSpace();if(space != -1){block[space] = page[i];display();}else{position = findReplace();block[position] = page[i];display();}}for(int j=0; j<Bsize; j++)block[j].timer++;//BLOCK中所有页面TIMER++ }}void PRA::BlockClear(void){for(int i=0; i<Bsize; i++){block[i].content = -1;block[i].timer = 0;}}void main(void){cout<<"|----------页面置换算法----------|"<<endl;cout<<"|---power by kangyan(1318064008)---|"<<endl;cout<<"|-------------------------------------|"<<endl;cout<<"页面号引用串:7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1"<<endl; cout<<"----------------------------------------------------"<<endl;cout<<"选择<1>应用Optimal算法"<<endl;cout<<"选择<2>应用FIFO算法"<<endl;cout<<"选择<3>应用LRU算法"<<endl;cout<<"选择<0>退出"<<endl;int select;PRA test;while(select){cin>>select;switch(select){case 0:break;case 1:cout<<"Optimal算法结果如下:"<<endl;test.Optimal();test.BlockClear();cout<<"----------------------"<<endl;break;case 2:cout<<"FIFO算法结果如下:"<<endl;test.FIFO();test.BlockClear();cout<<"----------------------"<<endl;break;case 3:cout<<"LRU算法结果如下:"<<endl;test.LRU();test.BlockClear();cout<<"----------------------"<<endl;break;default:cout<<"请输入正确功能号"<<endl;break;}}}实验截图如下图所示:<—键入1选择运行LRU算法的置换<—初始化信息:3个页块,20个页面号引用串<—存入前三个页,有空闲内存,无需置换<—3,4页已经在内存中无需再写入<—因为3是最久的页面所以将其置换下面原理相同<—所有命中的页面数<—命中率0.5七、总结页面置换算法的思想可以说比较简单,易懂,但是在实现的时候,也遇到了很多的问题,比如说在找空闲物理块的时候,起初我是比较物理块是否等于0,若为0,则直接把页面放入,后来发现不论什么时候都是把0替换出去,才恍然大悟,既然页面标号有0,就不能用0来表示空闲物理块,后来就换成用-1来表示物理块空闲了。

相关文档
最新文档