实验报告三-虚拟内存页面置换算法

合集下载

理解操作系统中的虚拟内存和页面置换算法

理解操作系统中的虚拟内存和页面置换算法

理解操作系统中的虚拟内存和页面置换算法虚拟内存是现代操作系统中的重要概念,它扩展了计算机的内存容量,允许运行更多的程序和处理更大的数据量。

虚拟内存通过将物理内存与磁盘上的某个存储区域进行映射,使得计算机能够在不使用全部物理内存的情况下运行更多的程序。

具体来说,操作系统将物理内存划分为大小相等的页面(page),同时将磁盘上的一部分空间划分为大小相等的页面框(page frame)。

每个页面框对应一个物理内存页面,而每个页面则对应一段虚拟内存空间。

当程序需要使用某个虚拟内存地址时,操作系统会将其映射到一个物理内存页面上。

如果所需页面已经在物理内存中,则直接访问该物理页面;如果所需页面不在内存中,则操作系统会选择一个页面进行置换,将其放入磁盘上的页面框中,然后将所需页面从磁盘加载到物理内存中。

页面置换算法是一种选择页面进行置换的策略。

常见的页面置换算法包括最佳置换算法(OPT)、先进先出算法(FIFO)、最近最少使用算法(LRU)等。

最佳置换算法是一种理想情况下的算法,即在置换页面时选择未来最长时间不再使用的页面进行置换。

然而,最佳置换算法需要未来的信息,因此在实际应用中很难实现。

FIFO算法则是一种最简单的页面置换算法,它选择最早被加载到物理内存的页面进行置换。

LRU算法是一种较为常用的页面置换算法,它根据页面的最近访问时间来选择置换页面。

页面置换算法的选择会影响系统的性能。

最佳置换算法理论上具有最佳的置换效果,但是在实际情况下很难实现。

FIFO算法简单易实现,但是无法适应程序运行时的不同访问模式。

LRU算法则考虑了最近访问时间,可以适应不同的访问模式,但是其实现相对复杂。

因此,选择合适的页面置换算法需要根据具体应用场景进行权衡和选择。

虚拟内存和页面置换算法为计算机的运行提供了更大的灵活性和效率。

它们通过将磁盘空间用作扩展内存,使得计算机能够处理更多的数据和运行更多的程序。

通过页面置换算法,操作系统可以根据程序的访问模式动态地调整物理内存的使用,提高系统的性能和响应速度。

页面置换算法实验报告实验心得

页面置换算法实验报告实验心得

页面置换算法实验报告实验心得
页面置换算法是操作系统中用来管理内存的一种重要算法。

在本次实验中,我们通过模拟内存的分配和释放过程,探索了三种典型的页面置换算法:FIFO(先进先出)、LRU(最近最少使用)和OPT(最优置换)。

在实验过程中,我发现FIFO算法虽然简单易懂,但容易产生“抖动”现象,即容易出现频繁的页面置换,导致系统效率低下。

LRU算法则能够有效避免抖动现象,但需要记录每个页面最近一次的使用时间,算法实现较为复杂。

OPT算法是一种理论上的最优算法,但由于需要预测未来的页面使用情况,实际中难以实现。

通过对三种算法的实验数据分析,我发现在不同的内存使用情况下,不同的页面置换算法表现也不同。

例如在内存使用较少的情况下,FIFO算法的效率可能会更高,但在内存使用较多的情况下,LRU算法则能够更好地发挥作用。

因此,在实际应用中,需要根据实际情况选择合适的页面置换算法。

总之,本次页面置换算法的实验让我更加深入地了解了操作系统中内存管理的相关知识,也加深了我对算法选择的理解和实际应用的思考。

页面置换算法实验报告

页面置换算法实验报告

页面置换算法实验报告
一、实验内容
本次实验主要围绕页面置换算法进行,以实验课本的实例介绍,采用FIFO页面置换算法对后面提到的参数进行置换,最终得出页面置换的结果和比较所得结果。

二、实验步骤
(一) 熟悉FIFO算法
首先是要了解FIFO页面置换算法,FIFO全称(First In First Out),按页面进入内存的顺序来替换相应内存页面,先进先出,将先进入内存的页面先替换出去。

(二) 阅读实验课本
在阅读实验课本之前要先熟悉实验书上所介绍的FIFO算法,然后在实验书上找出需要做的实验,并对实验环境和表格进行观察,掌握实验的基本内容。

(三) 开始页面置换
在开始实验之前,熟悉实验环境,根据实验书上的参数,首先模拟进程分配内存,根据FIFO算法去进行计算,根据上表中的参数去比较,最后得出最终结果。

(四) 在本次实验的补充
这次实验中,可以把FIFO的概念应用到实际应用中,也可以模拟不同情况,例如改变页面的大小,观察不同页面置换算法的结果,实验出最合适的结果。

三、实验结论
本次实验是为了了解FIFO页面置换算法,实验出最终的结果,最后得出页面置换的结果及比较结果。

虚拟内存的页面置换算法

虚拟内存的页面置换算法

虚拟内存的页面置换算法一、引言虚拟内存是计算机系统中的一种技术,它将计算机内存的管理从物理内存中分离出来,扩大了可用的内存空间。

而虚拟内存的页面置换算法则是虚拟内存管理中的重要组成部分。

本文将对虚拟内存的页面置换算法进行详细介绍。

二、页面置换算法的作用在计算机系统中,虚拟内存的大小远远大于物理内存的大小。

当系统运行的程序需要的内存超过物理内存的容量时,就需要将一部分数据从内存中置换出来,以腾出空间给新的数据。

而页面置换算法就是决定哪些页面被置换出去的方法。

三、常见的页面置换算法1. 最佳(OPT)页面置换算法最佳算法是一种理想化的算法,它总是选择未来最长时间内不会被访问的页面进行置换。

然而,由于无法预测未来的访问模式,最佳算法无法在实际系统中使用。

2. 先进先出(FIFO)页面置换算法FIFO算法是一种简单的页面置换算法,它总是选择最早进入内存的页面进行置换。

这种算法容易实现,但是它没有考虑到页面的访问模式,可能会导致较高的缺页率。

3. 最近最久未使用(LRU)页面置换算法LRU算法是一种基于页面访问历史的页面置换算法,它总是选择最近最久未使用的页面进行置换。

这种算法通常能够较好地预测未来的访问模式,但是实现起来较为复杂,需要维护一个访问历史记录。

4. 时钟(Clock)页面置换算法时钟算法是一种基于页面访问位的页面置换算法,它使用一个指针来指向内存中的页面,当需要置换页面时,检查指针指向的页面的访问位。

如果访问位为0,则选择该页面进行置换;如果访问位为1,则将访问位置为0,并将指针移动到下一个页面。

这种算法相对简单,并且能够较好地预测未来的访问模式。

5. 最不经常使用(LFU)页面置换算法LFU算法是一种基于页面访问频率的页面置换算法,它总是选择访问频率最低的页面进行置换。

这种算法能够较好地预测未来的访问模式,并且对于访问频率较低的页面有较好的效果。

四、页面置换算法的评价指标评价一个页面置换算法的好坏通常使用缺页率来衡量。

实验报告三 内存页面置换算法的设计

实验报告三 内存页面置换算法的设计

实验报告三——内存页面置换算法的设计姓名:丛菲学号:20100830205 班级:信息安全二班一、实习内容•实现最近最久未使用(LRU)置换算法二、实习目的•LINUX中,为了提高内存利用率,提供了内外存进程对换机制,内存空间的分配和回收均以页为单位进行,一个进程只需将其一部分调入内存便可运行,还支持请求调页的存储管理方式。

•本实习要求学生通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

三、实习题目1. 最近最久未使用(LRU)置换算法原理就是:当需要淘汰某页面时,选择当前一段时间内最久未使用过的页先淘汰,即淘汰距当前最远的上次使用的页。

•例如: 分配给该进程的页块数为3,一个20位长的页面访问序列为:12560,36536,56042,70435,则缺页次数和缺页率按下图给出:2. 假定分配给该进程的页块数为3,页面访问序列长度为20。

本实验可以采用数组结构实现,首先随机产生页面序列,当发生请求调页时,若内存已满,则需要利用LRU算法,将当前一段时间内最久未使用过的页替换出去。

•模拟程序的算法如下图:四、实现代码为:#include<stdio.h>#define M 3#define N 20#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n") /*表格控制*/typedef struct page{int num; /*记录页面号*/int time; /*记录调入内存时间*/}Page; /* 页面逻辑结构,结构为方便算法实现设计*/Page b[M]; /*内存单元数*/int c[M][N]; /*暂保存内存当前的状态:缓冲区*/int queue[100]; /*记录调入队列*/int K; /*调入队列计数变量*//*初始化内存单元、缓冲区*/void Init(Page *b,int c[M][N]){int i,j;for(i=0;i<N;i++){b[i].num=-1;b[i].time=N-i-1;}for(i=0;i<M;i++)for(j=0;j<N;j++)c[i][j]=-1;}/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/ int GetMax(Page *b){int i;int max=-1;int tag=0;for(i=0;i<M;i++){if(b[i].time>max){max=b[i].time;tag=i;}}return tag;}/*判断页面是否已在内存中*/int Equation(int fold,Page *b){int i;for(i=0;i<M;i++){if (fold==b[i].num)return i;}return -1;}void Lru(int fold,Page *b) /*LRU核心部分*/{int i;int val;val=Equation(fold,b);if (val>=0){b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}else//页面不存在{queue[++K]=fold;/*记录调入页面*/val=GetMax(b);b[val].num=fold;b[val].time=0;for(i=0;i<M;i++)if (i!=val)b[i].time++;}}main()/*主程序*/{int a[N]={1,0,5,1,7,1,0,2,4,1,0,0,8,7,5,4,3,2,3,4};int i,j;start:K=-1;Init(b, c);for(i=0;i<N;i++){Lru(a[i],b);c[0][i]=a[i];/*记录当前的内存单元中的页面*/for(j=0;j<M;j++)c[j][i]=b[j].num;}/*结果输出*/printf("nei cun zhuang tai :\n");Myprintf;for(j=0;j<N;j++)printf("|%2d ",a[j]);printf("|\n");Myprintf;for(i=0;i<M;i++){for(j=0;j<N;j++){if(c[i][j]==-1)printf("|%2c ",32);elseprintf("|%2d ",c[i][j]);}printf("|\n");}Myprintf;printf("\ndiao ru dui lie :");for(i=0;i<K+1;i++)printf("%3d",queue[i]);printf("\nque ye ci shu :%6d\nque ye lv:%16.2f%%\n",K+1,(float)(K+1)/N*100);}五、在虚拟机上的具体操作及结果六、思考题•比较LRU和其他置换算法各自的优缺点,能够实现其他置换算法模拟设计,分析内存页面数的变化对各种置换算法命中率的影响。

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

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

计算机科学系实验报告书课程名:《操作系统》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求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、提高自己的编程能力和问题解决能力。

二、实习环境本次实习使用的编程语言为 Python,开发环境为 PyCharm。

操作系统为 Windows 10。

三、页面置换算法简介1、先进先出(FIFO)算法FIFO 算法是最简单的页面置换算法之一。

它总是淘汰最先进入内存的页面。

这种算法实现简单,但可能会导致一些频繁使用的页面被过早置换出去。

2、最近最久未使用(LRU)算法LRU 算法根据页面最近的使用情况来决定置换。

即淘汰最长时间未被使用的页面。

该算法性能较好,但实现相对复杂,需要记录页面的使用时间。

3、最优置换(OPT)算法OPT 算法是一种理论上的最优算法,它淘汰未来最长时间内不会被使用的页面。

然而,由于在实际中无法准确预测未来的页面使用情况,所以该算法更多地用于理论分析。

四、实习过程1、算法实现首先,我使用 Python 实现了上述三种页面置换算法。

在实现过程中,我使用了数据结构来存储页面的相关信息,并通过模拟页面的调入和调出过程来计算缺页次数。

以 FIFO 算法为例,我使用一个队列来存储页面进入内存的顺序。

当需要置换页面时,将队首的页面淘汰。

2、性能测试为了比较不同算法的性能,我设计了一系列的测试用例。

测试用例包括不同的页面访问序列和不同的内存大小。

通过运行测试用例,我记录了每种算法在不同情况下的缺页次数。

3、结果分析对测试结果进行分析是实习的重要环节。

我发现,在不同的页面访问模式下,不同算法的表现差异较大。

例如,当页面访问序列具有局部性时,LRU 算法的表现通常优于FIFO 算法。

操作系统中的虚拟内存与页面置换算法

操作系统中的虚拟内存与页面置换算法

操作系统中的虚拟内存与页面置换算法操作系统是计算机系统中最核心的组成部分之一,负责管理和协调计算机系统的各种资源。

虚拟内存和页面置换算法是操作系统中的重要概念和技术,用于提高系统的性能和资源利用率。

本文将详细介绍操作系统中的虚拟内存和页面置换算法的原理及其应用。

一、虚拟内存的概念和原理虚拟内存是一种操作系统技术,它可以扩展计算机的实际物理内存大小,使得应用程序能够访问比实际物理内存更大的虚拟地址空间。

虚拟内存的实现原理是将进程的虚拟地址空间映射到物理内存或磁盘上,实现了从逻辑地址到物理地址的转换。

虚拟内存的主要功能包括内存保护、内存共享和内存扩充。

通过内存保护,操作系统可以为每个进程分配独立的虚拟地址空间,防止不同进程之间的内存相互干扰;通过内存共享,操作系统可以将相同的虚拟页面映射到不同的进程,实现进程间的数据共享;通过内存扩充,操作系统可以将虚拟内存中的部分内容映射到磁盘上,从而将物理内存中的数据暂时存储在磁盘上,释放出更多的物理内存供其他进程使用。

二、页面置换算法的概念和分类页面置换算法是虚拟内存管理中的核心算法,用于根据内存访问的特点和目标来选择被置换出去的页面,以便为新的页面腾出空间。

常用的页面置换算法有FIFO(First In First Out)、LRU(Least Recently Used)、LFU(Least Frequently Used)和OPT(Optimal)等。

FIFO算法是最简单的页面置换算法,它按照页面进入内存的顺序选择被置换出去的页面。

尽管FIFO算法实现简单,但是由于没有考虑到页面的使用频率和重要性,可能会导致被频繁访问的页面被置换出去,降低系统的性能。

LRU算法是最常用的页面置换算法之一,它根据页面最近的访问时间来选择被置换出去的页面。

LRU算法认为,最长时间没有被访问的页面很可能在未来也不会被访问,因此选择该页面来置换可以最大程度上减少页面置换的次数,提高系统的性能。

页面置换算法实验报告

页面置换算法实验报告

页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中,页面置换算法是一种重要的内存管理策略。

当物理内存不足以容纳所有需要运行的进程时,操作系统需要根据一定的算法将部分页面从内存中换出,以便为新的页面腾出空间。

本实验旨在通过实际操作,对比不同的页面置换算法在不同场景下的性能表现。

二、实验背景在计算机系统中,每个进程都有自己的虚拟内存空间,而物理内存空间是有限的。

当进程需要访问某个页面时,如果该页面不在物理内存中,就会发生缺页中断,操作系统需要根据页面置换算法选择一个页面将其换出,然后将需要访问的页面换入。

常见的页面置换算法有先进先出(FIFO)、最近最久未使用(LRU)、时钟(Clock)等。

三、实验目的本实验旨在通过模拟不同的页面置换算法,比较它们在不同情况下的缺页率和效率。

通过实验结果,评估各个算法在不同场景下的优劣,为实际系统的内存管理提供参考。

四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较:FIFO、LRU和Clock。

我们使用C++编程语言模拟了一个简单的内存管理系统,并通过产生不同的访存序列来模拟不同的场景。

实验中,我们设置了不同的物理内存大小,访存序列长度和页面大小,以模拟不同的系统环境。

五、实验结果与分析在实验中,我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。

通过统计不同算法的缺页率和运行时间,得出以下结论:1. FIFO算法FIFO算法是最简单的页面置换算法,它按照页面进入内存的顺序进行置换。

实验结果表明,FIFO算法在缺页率方面表现一般,特别是在访存序列具有局部性的情况下,其性能明显下降。

这是因为FIFO算法无法区分不同页面的重要性,可能会将经常使用的页面换出,导致缺页率升高。

2. LRU算法LRU算法是一种基于页面访问时间的置换算法,它认为最近被访问的页面很可能在未来会被再次访问。

实验结果表明,LRU算法在缺页率方面表现较好,特别是在访存序列具有较强的局部性时,其性能明显优于FIFO算法。

页面置换算法实验报告

页面置换算法实验报告

页面置换算法实验报告一、实验目的本次实验的目的是通过模拟页面置换算法的过程,了解不同算法的优缺点,掌握算法的实现方法,以及对算法的性能进行评估。

二、实验原理页面置换算法是操作系统中的一个重要概念,它是为了解决内存不足的问题而产生的。

当系统中的进程需要使用内存时,如果内存已经被占满,就需要将一些页面从内存中置换出去,以便为新的页面腾出空间。

页面置换算法就是用来决定哪些页面应该被置换出去的算法。

常见的页面置换算法有以下几种:1. 最佳置换算法(OPT)最佳置换算法是一种理论上的最优算法,它总是选择最长时间内不会被访问的页面进行置换。

但是,由于无法预测未来的页面访问情况,因此最佳置换算法无法在实际中使用。

2. 先进先出置换算法(FIFO)先进先出置换算法是一种简单的置换算法,它总是选择最先进入内存的页面进行置换。

但是,这种算法容易出现“抖动”现象,即频繁地将页面置换出去,然后再将其置换回来。

3. 最近最久未使用置换算法(LRU)最近最久未使用置换算法是一种比较常用的置换算法,它总是选择最长时间未被访问的页面进行置换。

这种算法可以避免“抖动”现象,但是实现起来比较复杂。

4. 时钟置换算法(Clock)时钟置换算法是一种改进的FIFO算法,它通过维护一个环形链表来实现页面置换。

当需要置换页面时,算法会从当前位置开始扫描链表,如果找到一个未被访问的页面,则将其置换出去。

如果扫描一圈后都没有找到未被访问的页面,则将当前位置的页面置换出去。

三、实验过程本次实验使用Python语言编写了一个页面置换算法模拟程序,可以模拟上述四种算法的过程,并输出算法的性能指标。

程序的主要流程如下:1. 读取输入文件,获取页面访问序列和内存大小等参数。

2. 根据选择的算法,初始化相应的数据结构。

3. 遍历页面访问序列,模拟页面置换的过程。

4. 输出算法的性能指标,包括缺页率、页面置换次数等。

下面分别介绍四种算法的实现方法。

1. 最佳置换算法(OPT)最佳置换算法需要预测未来的页面访问情况,因此需要遍历整个页面访问序列,找到最长时间内不会被访问的页面。

页面置换算法实验报告实验心得

页面置换算法实验报告实验心得

页面置换算法实验报告实验心得
1. 实验背景
页面置换算法是操作系统中的重要概念,主要用于解决内存不足的问题。

它通过将当前不需要的页面从内存中移出,以腾出空间给即将到来的页面。

本次实验主要是通过模拟不同页面置换算法的过程,来更好地了解和掌握这些算法的实现原理及其优缺点。

2. 实验过程
本次实验中,我们使用了三种页面置换算法,分别是最优页面置换算法(OPT)、先进先出页面置换算法(FIFO)和最近最久未使用页面置换算法(LRU)。

在模拟的过程中,我们需要先给每个页面设置一个访问时间,然后根据不同算法的实现原理来决定哪个页面被置换出去。

通过实验,我们发现不同的算法在不同情况下的效果也会不同。

比如,当页面访问时间相对均匀分布时,FIFO算法的效果会比较好,而当页面访问时间存在一定规律性时,LRU算法的效果则会更好。

而OPT 算法则需要未来时间的信息,一般情况下难以实现,但是在某些特殊情况下,它也可以发挥出比较好的效果。

3. 实验心得
通过本次实验,我更深入地了解了页面置换算法的实现原理,学会了如何根据不同算法的特点来选择合适的算法来解决内存不足的问题。

在实验过程中,我也学会了如何使用Python编程语言来模拟不同算法的过程,提高了我的编程能力。

通过不断地调试和实验,我还学会了如何发现问题和解决问题的方法,这对我今后的学习和工作都大有裨益。

总之,本次实验不仅加深了我对操作系统中重要概念的理解,也提高了我的编程和分析问题的能力,让我对未来的学习和工作充满信心和热情。

页面置换算法实验报告

页面置换算法实验报告

页面置换算法实验报告背景页面置换算法是计算机操作系统中的一个重要概念,它用于解决操作系统需要共享有限的物理内存资源给多个进程使用的问题。

在操作系统中,每个进程都有自己的虚拟地址空间,但实际的物理内存资源是有限的。

当物理内存不足时,操作系统需要根据一定的策略将一部分进程暂时从内存中移出,以便为其他进程让出空间,而后再从外存中将其重新加载到内存中。

这个过程就是页面置换。

页面置换算法有很多种,比如最优页面置换算法(Optimal)、先进先出页面置换算法(FIFO)、最近最久未使用页面置换算法(LRU)等等。

不同的算法对于系统性能、响应时间等指标有着不同的影响,因此在实际应用中需要选择合适的算法来平衡各种需求。

本实验旨在通过模拟页面置换算法,并对不同算法进行性能分析,以便了解各种算法的优缺点,为实际系统的选择提供依据。

分析在实验中,我们选择了三种常用的页面置换算法,分别是FIFO、LRU和Optimal。

下面对这三种算法进行详细的分析和说明。

先进先出页面置换算法(FIFO)FIFO算法是最简单和最直观的页面置换算法。

它按照页面进入内存的顺序来选择被淘汰的页面。

当内存不足时,选择最早进入内存的页面进行置换,即将其从内存中移出。

FIFO算法不需要进行进一步的页面访问计算,只需要维护一个页面进入内存的队列即可,因此实现起来比较简单。

然而,由于FIFO算法没有考虑页面的访问频率和重要性,所以可能会导致被频繁访问的页面被淘汰出内存,从而影响系统的性能。

最近最久未使用页面置换算法(LRU)LRU算法是一种基于”最近使用原则”的页面置换算法。

它根据页面最近被访问的时间来选择被淘汰的页面。

当内存不足时,选择最长时间未被访问的页面进行置换,即将其从内存中移出。

LRU算法需要维护一个页面访问时间的记录,以便在需要置换时能够快速找到最近最久未使用的页面。

相比于FIFO算法,LRU算法更加合理地利用了页面的访问情况,但实现起来相对复杂一些。

虚拟内存页面置换算法实训报告

虚拟内存页面置换算法实训报告

虚拟内存页面置换算法实训报告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算法在缺页率和执行时间方面都表现较好,可以作为一种较为通用的页面置换算法。

页面置换算法实践报告

页面置换算法实践报告

页面置换算法实践报告页面置换算法(Page Replacement Algorithm)是操作系统中用于管理虚拟内存的重要算法之一。

其目的是在有限的物理内存空间中,将进程所需的页面加载到内存中,并根据一定的策略替换掉不再被使用的页面,以提高内存利用率和系统性能。

在本次实践报告中,我将重点介绍三种常见的页面置换算法:先进先出(FIFO)、最近最久未使用(LRU)和最不经常使用(LFU)。

先进先出(FIFO)算法是最简单的页面置换算法之一。

它根据页面进入内存的先后顺序进行页面置换。

当一个页面需要被替换时,选择最早进入内存的页面进行替换。

虽然FIFO算法的实现简单,但它无法很好地反映页面的使用频率和重要性,容易发生“缺页率抖动”的问题。

缺页率抖动指的是在某些场景下,缺页率会频繁地快速上升,然后又快速下降。

最近最久未使用(LRU)算法是一种基于页面历史访问记录的页面置换算法。

它认为最近被访问过的页面是最有可能在未来被访问的,因此选择最近最久未使用的页面进行替换。

LRU算法可以较为准确地反映页面的使用频率,避免了FIFO算法的缺点。

但由于需要记录页面的访问历史,因此实现相对复杂,需要额外的开销。

最不经常使用(LFU)算法是一种基于页面使用频率的页面置换算法。

它认为使用频率最低的页面是最不重要的,因此选择最不经常使用的页面进行替换。

LFU算法可以较好地反映页面的使用频率,对于一些热点页面和冷门页面的处理较为准确。

但由于需要记录页面的使用次数,因此实现相对复杂,需要额外的开销。

根据实际情况选择合适的页面置换算法对于系统的性能影响非常重要。

一般来说,FIFO算法比较适用于缺页率较低的情况,而LRU算法则适用于需要较高精确度的场景,而LFU算法则适用于需要特别关注页面使用频率的场景。

在实践中,我们可以使用模拟算法来进行页面置换算法的实验。

通过构造不同的页面访问序列,我们可以测试不同算法的效果并进行比较。

在实验过程中,我们可以观察不同算法的缺页率、替换次数、访问延迟等指标,以评估算法的性能。

虚拟内存的页面置换算法

虚拟内存的页面置换算法

虚拟内存的页面置换算法一、概述虚拟内存是计算机操作系统中的一种技术,它允许程序使用比实际物理内存更大的内存空间。

但是,由于实际物理内存是有限的,虚拟内存的实现需要使用到一种称为页面置换算法的策略。

页面置换算法的作用是根据一定的规则将内存中的页面从物理内存中换出,以便为新的页面腾出空间。

二、FIFO算法FIFO(First In First Out)算法是最简单的页面置换算法之一。

它的原理是将最早进入内存的页面置换出去。

这种算法的实现非常简单,只需要维护一个页面队列,按照页面进入内存的先后顺序进行置换。

然而,FIFO算法存在一个明显的问题,即它无法区分页面的重要性。

如果最早进入内存的页面是一个常用的页面,那么它被置换出去后可能会频繁地被再次访问,从而导致性能下降。

三、LRU算法LRU(Least Recently Used)算法是一种比较常用的页面置换算法。

它的原理是将最近最少使用的页面置换出去。

为了实现LRU算法,需要维护一个页面访问时间的记录。

具体来说,每当一个页面被访问时,就将它的访问时间更新为当前时间。

当需要置换页面时,选择访问时间最早的页面进行置换。

这样做的好处是,能够较好地区分页面的重要性,常用的页面能够保留在内存中,提高系统的性能。

四、LFU算法LFU(Least Frequently Used)算法是根据页面的访问频率进行置换的算法。

它的原理是将访问频率最低的页面置换出去。

为了实现LFU算法,需要维护每个页面的访问次数。

具体来说,每当一个页面被访问时,就将它的访问次数加一。

当需要置换页面时,选择访问次数最低的页面进行置换。

LFU算法的优点是能够适应不同页面访问频率的变化,但是实现起来比较复杂。

五、OPT算法OPT(Optimal)算法是一种理论上的最佳页面置换算法。

它的原理是根据未来的访问情况进行页面置换。

具体来说,OPT算法会根据未来的页面访问情况预测哪个页面在未来最长时间内不会被访问到,然后将其置换出去。

分页置换实验报告

分页置换实验报告

一、实验目的1. 理解分页置换算法的基本原理及其在虚拟内存管理中的作用。

2. 掌握几种常见的分页置换算法(如FIFO、LRU等)的模拟实现方法。

3. 分析不同分页置换算法的性能差异,并评估其在实际应用中的适用性。

二、实验原理分页置换算法是虚拟内存管理中的一种关键技术,其主要目的是在有限的物理内存中模拟更大的内存空间,以满足程序对内存的需求。

当物理内存不足时,系统会根据一定的置换算法选择某些页面进行淘汰,以腾出空间给新的页面。

常见的分页置换算法包括:1. FIFO(先进先出)算法:根据页面进入内存的顺序进行淘汰,即先进入内存的页面先被淘汰。

2. LRU(最近最少使用)算法:淘汰最近一段时间内最长时间未被访问的页面。

3. OPT(最佳置换)算法:淘汰未来最长时间内不再被访问的页面。

三、实验内容1. FIFO算法实现:模拟FIFO算法,记录缺页中断次数和缺页率。

2. LRU算法实现:模拟LRU算法,记录缺页中断次数和缺页率。

3. 性能对比分析:对比FIFO和LRU算法的性能差异,分析其适用场景。

四、实验步骤1. 数据准备:生成一系列页面访问序列,用于模拟分页置换过程。

2. FIFO算法模拟:- 初始化一个固定大小的内存缓冲区。

- 遍历页面访问序列,对于每个页面:- 检查是否已在内存缓冲区中。

- 如果不在,则将内存缓冲区中最先进入的页面淘汰,并将当前页面加入内存缓冲区。

- 记录缺页中断次数。

3. LRU算法模拟:- 初始化一个内存缓冲区,并维护一个访问顺序链表。

- 遍历页面访问序列,对于每个页面:- 检查是否已在内存缓冲区中。

- 如果不在,则将内存缓冲区中最少访问的页面淘汰,并将当前页面加入内存缓冲区。

- 更新访问顺序链表。

- 记录缺页中断次数。

4. 性能对比分析:- 对比FIFO和LRU算法的缺页中断次数和缺页率。

- 分析两种算法的性能差异及其适用场景。

五、实验结果与分析1. FIFO算法:FIFO算法简单易实现,但性能较差。

操作系统实验报告之虚拟存储器管理页面置换算法

操作系统实验报告之虚拟存储器管理页面置换算法

操作系统实验二:虚拟存储器管理时间:2013-12-06地点:计算机实验机房2实验人:朱蓉蓉学号:E01114336题目一:采用先进先出算法实现分页管理的缺页调度。

实验代码:#include "stdio.h"#define N 20#define m 4void main(){int n;printf("请输入引用串页面个数:\n");scanf("%d",&n);int ym[N],i,j,q,mem[m]={0},table[m][N];char flag,f[N];printf("请输入页面访问序列:\n");for(i=0;i<n;i++){printf("输入页面号:");scanf("%d",&ym[i]);}for(i=0;i<n;i++) //查页表,看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页,则置标志flag为'*'else flag=' ';if(flag=='*'){for(j=m-1;j>0;j--) //淘汰最先调入的页面调入当前访问的mem[j]=mem[j-1];mem[0]=ym[i];}for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表(0代表为空,*代表有缺页)\n"); for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);printf("\n");}实验二:采用LRU算法实现分页管理的缺页调度.实验代码:#include <stdio.h>#define P 20#define m 5void main(){int n;printf("--------------LRU算法缺页调度---------------\n"); printf("请输入引用串页面个数:\n");scanf("%d",&n);int ym[P],i,j,q,mem[m]={0},table[m][P];char flag,f[P];printf("请输入页面访问序列:\n");for(i=0;i<n;i++){printf("输入页面号:");scanf("%d",&ym[i]);}for(i=0;i<n;i++) //查页表,看是否缺页{q=0;while((ym[i]!=mem[q])&&(q!=m)) q++;if(q==m) flag='*'; //缺页,则置标志flag为'*'else flag=' ';for(j=q;j>0;j--)mem[j]=mem[j-1];mem[0]=ym[i];for(j=0;j<m;j++)table[j][i]=mem[j];f[i]=flag;}printf("输出结果为下表(0代表为空,*代表有缺页)\n"); for(i=0;i<m;i++){for(j=0;j<n;j++)printf("%3d",table[i][j]);printf("\n");}for(i=0;i<n;i++)printf("%3c",f[i]);printf("\n");}。

操作系统实验报告页面置换参考模板

操作系统实验报告页面置换参考模板

实验三内存页面置换算法的设计实习内容设计一个虚拟存储区和内存工作区,并使用下述算法来模拟实现页面的置换: 1. 先进先出的算法(FIFO)2. 最近最久未使用算法(LRU)3. 最佳置换算法(OPT)实习目的本实习要求学生通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的技术特点,掌握请求页式存储管理的页面置换算法。

LINUX中,为了提高内存利用率,提供了内外存进程对换机制,内存空间的分配和回收均以页为单位进行,一个进程只需将其一部分(段或页)调入内存便可运行,还支持请求调页的存储管理方式。

当进程在运行中需要访问某部分程序和数据时,发现其所在页面不在内存,就立即提出请求(向CPU发出缺中断),由系统将其所需页面调入内存。

这种页面调入方式叫请求调页。

当CPU接收到缺页中断信号,中断处理程序先保存现场,分析中断原因,转入缺页中断处理程序。

该程序通过查找页表,得到该页所在外存的物理块号。

如果此时内存未满,能容纳新页,则启动磁盘I/O将所缺之页调入内存,然后修改页表。

如果内存已满,则须按某种置换算法从内存中选出一页准备换出,是否重新写盘由页表的修改位决定,然后将缺页调入,修改页表。

利用修改后的页表,去形成所要访问数据的物理地址,再去访问内存数据。

整个页面的调入过程对用户是透明的。

实习原理——算法思想:1.先进先出(FIFO)置换算法的思路该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。

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

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

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

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

操作系统第三次实验报告_页面替换算法

操作系统第三次实验报告_页面替换算法

实验三页面替换算法3.1实验简介本实验要求实现多种页面替换算法,然后利用随机产生的引用串测试其性能。

3.2 页面替换算法我们做如下假设:• 虚拟内存页面总数为P,标号从0 到P -1• 引用串RS(reference string) 是一个整数序列,整数的取值范围为0到P -1。

RS 中的每个元素p 表示对页面p 的一次引用• 物理内存由F 帧组成,标号从0 到F -1。

我们引入一个数组M[F],数组元素M[f] 中包含数字p,它表示帧f 中包含页面p页面替换算法顺次读取RS 中的每个元素。

对于RS 中的元素值p,算法搜索数组M[F],判断是否存在某个f,使得M[f] == p。

如果未发现,则表示页面缺失。

这时,算法必须根据其特定的替换规则,选择一帧M[i],用页面p 替换其中的内容,即令M[i] = p。

下面讨论各种替换算法所需要的不同数据结构:• 最佳替换算法和随机替换算法不需要其它的数据结构。

对于最佳替换算法,通过搜索RS 即足以确定应被替换的页面;对于随机替换算法,产生一个取值范围在0 和F -1 之间的随机数,该随机数即可表示应被替换的页面。

• FIFO 需要一个指向最老页面的指针(数组索引)。

每当该页面被替换的时候,把该指针加1(模F) 即可。

• LRU 算法则需要一个尺寸为F 的数组,该数组用来实现排队功能:每次处理一个新的页面引用时,则把该页放置在队列的末尾。

这样,每当需要淘汰一个页面时,从队首取到的即最长时间未被用到的页面。

• Clock 算法(也叫second -chance 算法)和FIFO 算法一样,需要一个指针。

此外,它还需要一个数组,用来记录每一帧的使用情况。

3.3 试验程序#include<stdio.h>#include <windows.h>static int a,b,c;//三个存储单元static int flag_a,flag_b,flag_c;//存储单元标志位int optimal(int rs[200]){int *p1,*p2;int count=0;a=0;b=0;c=0;a=rs[0];b=rs[1];c=rs[2];p1=&rs[3];do{flag_a=0;flag_b=0;flag_c=0;p2=p1;if ((*p2!=a)&&(*p2!=b)&&(*p2!=c)){while(flag_a+flag_b+flag_c<2&&p2<=&rs[200]){if(*p2==a){flag_a=1;p2++;}else if(*p2==b){flag_b=1;p2++;}else if(*p2==c){flag_c=1;p2++;}else p2++;}if (flag_a+flag_b+flag_c==0){do{a=*p1;p1++;count++;}while(p1<=&rs[199]);}else if(flag_a+flag_b+flag_c==1) {if((*p1==a)||(*p1==b)||(*p1==c)) {p1++;}else{if(p1!=&rs[199]){a=*p1;p1++;}else{flag_a=0;flag_b=0;flag_c=0;}}}else{if (flag_a==0){a=*p1;p1++;count++;}else if (flag_b==0){b=*p1;p1++;count++;}else if (flag_c==0){c=*p1;p1++;count++;}}}else p1++;}while(p1<=&rs[199]&&p2<=&rs[199]); return count;}int FIFO(int rs[200]){int *p1,*p2;int count=0;a=0;b=0;c=0;a=rs[0];b=rs[1];c=rs[2];p1=&rs[3];p2=p1;while(p1<=&rs[200]&&p2<=&rs[200]){ p2=p1;if ((*p2!=a)&&(*p2!=b)&&(*p2!=c)) {a=*p2;b=c;c=*p2;count++;}else p1++;}return count;}int rand(int rs[200]){int *p1,*p2;int count=0;a=0;b=0;c=0;a=rs[0];b=rs[1];c=rs[2];p1=&rs[3];p2=p1;while(p1<=&rs[200]&&p2<=&rs[200]){ p2=p1;if ((*p2!=a)&&(*p2!=b)&&(*p2!=c)) {int k=rand();if(k%3==0){a=*p2;count++;}else if(k%3==1){b=*p2;count++;}else if(k%3==2){c=*p2;count++;}}else p1++;}return count;}int LRU(int rs[200]){int *p1,*p2;int count=0;a=0;b=0;c=0;a=rs[0];b=rs[1];c=rs[2];p1=&rs[3];p2=p1;while(p1<=&rs[200]&&p2<=&rs[200]){ p2=p1;if ((*p2!=a)&&(*p2!=b)&&(*p2!=c)) {c=b;b=a;a=*p2;count++;}else{if (*p2==a){p1++;}else if (*p2==b){b=a;a=*p2;p1++;}else{c=b;b=a;a=*p2;p1++;}}}return count;}int main(){int count1=0;int count2=0;int count3=0;int count4=0;int RS[200];for(int a=0;a<200;a++) {RS[a]=rand()%10;printf("%d,",RS[a]);}count1=optimal(RS);count2=FIFO(RS);count3=LRU(RS);count4=rand(RS);printf("最佳值换算法的次数是:%d次\n",count1);printf("先进先出算法的次数是:%d次\n",count2);printf("最近最久未使用算法的次数是:%d次\n",count3);printf("随机算法的次数是:%d次\n",count4);return 0;}3.4 实验结果3.5 性能评测测试不同的引用串以及不同的虚拟内存尺寸,回答如下问题:1. FIFO 算法是否比随机替换算法优越LRU 算法比FIFO 算法优越多少?解:FIFO算法比随机替换算法优越,最近最久未使用算法在rs长度为200的引用串中,替换了148次而先进先出算法替换了164次。

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

实验报告三-虚拟内存页面置换算法实验报告三虚拟内存页面置换算法班级学号姓名一、实验目的通过这次实验,加深对虚拟内存页面置换概念的理解,进一步掌握先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。

二、实验的开发环境1. 硬件设备:PC机一台2. 软件环境:安装Windows操作系统或者Linux 操作系统,并安装相关的程序开发环境,如 C \C++\Java 等编程语言环境。

三、实验设计思路问题描述:设计程序模拟先进先出FIFO,最佳置换OPI 和最近最久未使用LRU页面置换算法的工作过程。

假设内存中分配给每个进程的最小物理块数为m,在进程运行过程中要访问的页面个数为n,页面访问序列为P1, … ,Pn,分别利用不同的页面置换算法调度进程的页面访问序列,给出页面访问序列的置换过程,计算每种算法缺页次数和缺页率。

四、实验内容及结果程序要求如下:1)利用先进先出FIFO,最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。

2)模拟三种算法的页面置换过程,给出每个页面访问时的内存分配情况。

3)输入:最小物理块数m,页面个数n,页面访问序列P1, …,Pn,算法选择1-FIFO,2-OPI,3-LRU。

4)输出:每种算法的缺页次数和缺页率。

程序源码如下:#include "iostream.h"const int DataMax=100;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}; // 测试数据//int N = 20; // 输入页面个数int Data[DataMax]; // 保存数据int Block[BlockNum]; // 物理块int count[BlockNum]; // 计数器int N ; // 页面个数int M;//最小物理块数int ChangeTimes;void DataInput(); // 输入数据的函数void DataOutput();void FIFO(); // FIFO 函数void Optimal(); // Optimal函数void LRU(); // LRU函数///*int main(int argc, char* argv[]){DataInput();// DataInput();// FIFO();// Optimal();// LRU();// return 0;int menu;while(true){cout<<endl;cout<<"* 菜单选择*"<<endl;cout<<"*******************************************************"<<endl;cout<<"* 1-FIFO *"<<endl;cout<<"* 2-Optimal *"<<endl;cout<<"* 3-LRU *"<<endl;cout<<"* 0-EXIT *"<<endl;cout<<"*******************************************************"<<endl;cin>>menu;switch(menu){case 1: FIFO();break;case 2: Optimal();break;case 3: LRU();break;default: break;}if(menu!=1&&menu!=2&&menu!=3) break;}}//*/void DataInput(){cout<<"请输入最小物理块数:";cin>>M;while(M > BlockNum) // 大于数据个数{cout<<"物理块数超过预定值,请重新输入:";cin>>M;}cout<<"请输入页面的个数:";cin>>N;while(N > DataMax) // 大于数据个数{cout<<"页面个数超过预定值,请重新输入:";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;for(j=0;j<M;j++){cout<<" ";for(i=0;i<N;i++) // 对所有数据操作{if( DataShowEnable[j][i] )cout<<DataShow[j][i]<<" ";elsecout<<" ";}cout<<endl;}cout<<"缺页次数: "<<ChangeTimes<<endl;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,表示没有要显示的数据for(i=0;i<M;i++){count[i] = 0; // 大于等于BlockNum,表示块中没有数据,或需被替换掉// 所以经这样初始化(3 2 1),每次替换>=3的块,替换后计数值置1,// 同时其它的块计数值加1 ,成了(1 3 2 ),见下面先进先出程序段}for(i=0;i<N;i++) // 对有所数据操作{// 增加countfor(j=0;j<M;j++)count[j]++;find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] ){find = true;}}if( find ) continue; // 块中有该数据,判断下一个数据// 块中没有该数据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];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0; // 更新计数值// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"FIFO => "<< endl;DataOutput();}void Optimal(){int i,j,k;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,表示没有要显示的数据// for(i=0;i<M;i++)// {// count[i] = 0 ; //// }for(i=0;i<N;i++) // 对有所数据操作{find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] )find = true;}if( find ) continue; // 块中有该数据,判断下一个数据// 块中没有该数据,最优算法ChangeTimes++; // 缺页次数++for(j=0;j<M;j++){// 找到下一个值的位置find = false;for( k =i;k<N;k++){if( Block[j] == Data[k] ){find = true;count[j] = k;break;}}if( !find ) count[j] = N;}if( (i+1) > M ) // 因为i是从0开始记,而BlockNum指的是个数,从1开始,所以i+1 {//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"Optimal => "<< endl;DataOutput();}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++)DataShowEnable[j][i] = false; // 初始化为false,表示没有要显示的数据for(i=0;i<M;i++){count[i] = 0 ;}for(i=0;i<N;i++) // 对有所数据操作{// 增加countfor(j=0;j<M;j++)count[j]++;find = false; // 表示块中有没有该数据for(j=0;j<M;j++){if( Block[j] == Data[i] ){count[j] = 0;find = true;}}if( find ) continue; // 块中有该数据,判断下一个数据// 块中没有该数据ChangeTimes++; // 缺页次数++if( (i+1) > M ) // 因为i是从0开始记,而BlockNum指的是个数,从1开始,所以i+1 {//获得要替换的块指针temp = 0;for(j=0;j<M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0;// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i<M?(j<=i?j:i):j][i] = true; // 设置显示数据}}// 输出信息cout<< endl;cout<<"LRU => "<< endl;DataOutput();}五、实验效果六、实验总结通过这次实验我对先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。

相关文档
最新文档