操作系统实验4(虚拟内存页面置换算法)
操作系统 课程实验-实验四页式虚拟存储管理中地址转换和缺页中断
实验四页式虚拟存储管理中地址转换和缺页中断一、实验目的深入了解页式存储管理如何实现地址转换;进一步认识页式虚拟存储管理中如何处理缺页中断。
二、实验预备知识页式存储管理中地址转换的方法;页式虚拟存储的缺页中断处理方法。
三、实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。
实验具体包括:首先对给定的地址进行地址转换工作,若发生缺页则先进行缺页中断处理,然后再进行地址转换;最后编写主函数对所做工作进行测试。
假定主存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位)。
在页式虚拟存储管理方式中,作业信息作为副本放在磁盘上,作业执行时仅把作业信息的部分页面装入主存储器,作业执行时若访问的页面在主存中,则按上述方式进行地址转换,若访问的页面不在主存中,则产生一个“缺页中断”,由操作系统把当前所需的页面装入主存储器后,再次执行时才可以按上述方法进行地址转换。
页式虚拟存储管理方式中页表除页号和该页对应的主存块号外,至少还要包括存在标志(该页是否在主存),磁盘位置(该页的副本在磁盘上的位置)和修改标志(该页是否修改过)。
操作系统实验实验报告 虚拟内存
操作系统实验实验报告虚拟内存一、实验目的本次操作系统实验的目的是深入理解虚拟内存的概念、原理和实现机制,通过实际操作和观察,掌握虚拟内存的相关技术,包括页面置换算法、内存分配策略等,并分析其对系统性能的影响。
二、实验环境操作系统:Windows 10 专业版开发工具:Visual Studio 2019编程语言:C++三、实验原理1、虚拟内存的概念虚拟内存是一种计算机系统内存管理技术,它使得应用程序认为自己拥有连续的可用内存(一个连续完整的地址空间),而实际上,这些内存可能是被分散存储在物理内存和外部存储设备(如硬盘)中的。
虚拟内存通过将程序使用的内存地址映射到物理内存地址,实现了内存的按需分配和管理。
2、页面置换算法当物理内存不足时,操作系统需要选择一些页面(内存中的固定大小的块)换出到外部存储设备,以腾出空间给新的页面。
常见的页面置换算法有先进先出(FIFO)算法、最近最少使用(LRU)算法、时钟(Clock)算法等。
3、内存分配策略操作系统在分配内存时,需要考虑如何有效地利用有限的物理内存资源。
常见的内存分配策略有连续分配、分页分配和分段分配等。
四、实验内容与步骤1、实现简单的虚拟内存系统使用 C++编写一个简单的虚拟内存模拟程序,包括内存页面的管理、地址映射、页面置换等功能。
2、测试不同的页面置换算法在虚拟内存系统中,分别实现 FIFO、LRU 和 Clock 算法,并对相同的访问序列进行测试,比较它们的页面置换次数和缺页率。
3、分析内存分配策略的影响分别采用连续分配、分页分配和分段分配策略,对不同大小和类型的程序进行内存分配,观察系统的性能(如内存利用率、执行时间等)。
具体步骤如下:(1)定义内存页面的结构,包括页面号、标志位(是否在内存中、是否被修改等)等。
(2)实现地址映射函数,将虚拟地址转换为物理地址。
(3)编写页面置换算法的函数,根据不同的算法选择要置换的页面。
(4)创建测试用例,生成随机的访问序列,对不同的算法和分配策略进行测试。
虚拟内存的页面置换算法
虚拟内存的页面置换算法一、引言虚拟内存是计算机系统中的一种技术,它将计算机内存的管理从物理内存中分离出来,扩大了可用的内存空间。
而虚拟内存的页面置换算法则是虚拟内存管理中的重要组成部分。
本文将对虚拟内存的页面置换算法进行详细介绍。
二、页面置换算法的作用在计算机系统中,虚拟内存的大小远远大于物理内存的大小。
当系统运行的程序需要的内存超过物理内存的容量时,就需要将一部分数据从内存中置换出来,以腾出空间给新的数据。
而页面置换算法就是决定哪些页面被置换出去的方法。
三、常见的页面置换算法1. 最佳(OPT)页面置换算法最佳算法是一种理想化的算法,它总是选择未来最长时间内不会被访问的页面进行置换。
然而,由于无法预测未来的访问模式,最佳算法无法在实际系统中使用。
2. 先进先出(FIFO)页面置换算法FIFO算法是一种简单的页面置换算法,它总是选择最早进入内存的页面进行置换。
这种算法容易实现,但是它没有考虑到页面的访问模式,可能会导致较高的缺页率。
3. 最近最久未使用(LRU)页面置换算法LRU算法是一种基于页面访问历史的页面置换算法,它总是选择最近最久未使用的页面进行置换。
这种算法通常能够较好地预测未来的访问模式,但是实现起来较为复杂,需要维护一个访问历史记录。
4. 时钟(Clock)页面置换算法时钟算法是一种基于页面访问位的页面置换算法,它使用一个指针来指向内存中的页面,当需要置换页面时,检查指针指向的页面的访问位。
如果访问位为0,则选择该页面进行置换;如果访问位为1,则将访问位置为0,并将指针移动到下一个页面。
这种算法相对简单,并且能够较好地预测未来的访问模式。
5. 最不经常使用(LFU)页面置换算法LFU算法是一种基于页面访问频率的页面置换算法,它总是选择访问频率最低的页面进行置换。
这种算法能够较好地预测未来的访问模式,并且对于访问频率较低的页面有较好的效果。
四、页面置换算法的评价指标评价一个页面置换算法的好坏通常使用缺页率来衡量。
页面置换算法模拟实验报告
if(block[i].timer >= block[pos].timer)
pos = i;//找到应予置换页面,返回BLOCK中位置
return pos;
}
void PRA::display(void)
{
for(int i=0; i<Bsize; i++)
}
}
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)
{
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++)
int findReplace(void); //查找应予置换的页面
void display(void); //显示
void FIFO(void);//FIFO算法
操作系统实验 页面置换算法模拟
实验四页面置换算法模拟一、实验内容简要描述开发语言及实现平台或实验环境C++/JA V ATurbo C / Microsoft Visual Studio 6.0 / Microsoft Visual Studio .NET 2010实验目的(1)了解内存分页管理策略(2)掌握调页策略(3)掌握一般常用的调度算法(4)学会各种存储分配算法的实现方法。
(5)了解页面大小和内存实际容量对命中率的影响。
【实验内容】编程实现页面置换算法,最少实现两种算法,比较算法的优劣,并将调试结果显示在计算机屏幕上,并检测机算和笔算的一致性。
【实验要求】(1)采用页式分配存储方案,通过分别计算不同算法的命中率来比较算法的优劣,同时也考虑页面大小及内存实际容量对命中率的影响;(2)实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟;(3)使用某种编程语言模拟页面置换算法。
二、报告主要内容1.设计思路A、设计页面走向、物理块数等初值。
B、编制程序,使用多种算法实现页面置换。
C、计算和比较缺页率。
最佳置换算法OPT(Optimal)它是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰页面,将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法,通常可保证获得最低的缺页率。
但由于人目前还无法预知一个进程在内存的若干个页面中,哪一个页面是未来最长时间内不再被访问的,因而该算法是无法实现的,但是可以利用此算法来评价其它算法。
如果编写程序模拟该算法,可以提前设定页面访问次序,获知某个页面是否在未来不再被访问。
2.画流程图3.实验结果(输入、输出截图)程序运行结果4.主要代码#include "stdio.h"#include "stdlib.h"#include "math.h"#include "conio.h"#include "time.h"#define TRUE 1#define FALSE 0#define NULL 0#define total_instruction 20#define total_vp 10typedef struct{ int pn,pfn;}pv_type;pv_type pv[10];typedef struct pf_struct{ int pn,pfn;struct pf_struct *next;}pf_type;pf_type pf[20],*free_head,*busy_head,*busy_tail,*q; int page[total_instruction];int total_pf;int count;void initialiaze(){ int i;count=0;for(i=0;i<total_vp;i++){ pv[i].pn=i;pv[i].pfn=-1;}printf("请输入实页数目:");scanf("%d",&total_pf);for(i=0;i<=total_pf-1;i++){ pf[i].next=&pf[i+1];pf[i].pfn=i+1;pf[i].pn=-1;}pf[total_pf-1].next=NULL;free_head=&pf[0];printf("随机产生的页地址流为:\n");for(i=0;i<total_instruction;i++){ page[i]=rand()%10;printf("%2d",page[i]);}}void FIFO(){ int i,j;pf_type *p;q=busy_head=busy_tail=NULL;for(i=0;i<=total_instruction-1;i++){ printf("\n第%d次执行:",i+1);if(pv[page[i]].pfn==-1){ count+=1;printf("缺页,缺页次数count=%d,",count);if(free_head==NULL){printf("实页%d中的页面%d将被置换出去",busy_head->pfn,busy_head->pn);p=busy_head->next;pv[busy_head->pn].pfn=-1;free_head=busy_head;free_head->next=NULL;busy_head=p;}p=free_head->next;free_head->next=NULL;free_head->pn=page[i];pv[page[i]].pfn=free_head->pn;if(busy_tail==NULL)busy_head=busy_tail=free_head;else{ busy_tail->next=free_head;busy_tail=free_head;}free_head=p;}else printf("命中,缺页次数不变,仍为count=%d",count);printf("\npfn pn");for(j=0;j<=total_pf-1;j++){if(pf[j].pn!=-1)printf("\n%d%8d",pf[j].pfn,pf[j].pn);}}printf("\n先进先出算法的命中率为:%6.4f\n缺页总次数为%d\n",1-(float)count/20,count);}void main(){srand((unsigned)time(NULL));initialiaze();FIFO();三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。
操作系统虚拟内存与页面置换算法
操作系统虚拟内存与页面置换算法操作系统的虚拟内存是一种将运行程序所需的内存空间扩展到硬盘上的技术。
通过虚拟内存,操作系统可以更好地管理内存资源,使得多个程序能够同时运行,并且在内存不足时能够有效地置换页面。
一、虚拟内存的概念和作用虚拟内存是操作系统为每个进程提供的一种看似连续、但实则可以存储在物理内存和硬盘上的地址空间。
它的主要作用有以下几点:1. 扩充内存容量:虚拟内存可以将硬盘上的一部分空间作为内存扩充,有效地提高内存的容量。
2. 隔离进程地址空间:每个进程有独立的虚拟内存空间,通过虚拟内存的隔离,进程与进程之间不会相互干扰。
3. 简化物理内存管理:操作系统只需将常用的部分加载到物理内存中,而不必一次性将整个进程加载到内存中,减少物理内存的压力。
二、页面置换算法虚拟内存的管理会面临一个问题——当物理内存不足时,如何选择将哪些页面换出到硬盘中以便腾出空间给其他页面使用。
下面介绍几种常见的页面置换算法:1. 先进先出(FIFO)算法FIFO算法是最简单的页面置换算法。
它根据页面进入物理内存的先后顺序进行置换,即最早进入内存的页面最先被置换。
但是,FIFO算法的缺点是它无法根据页面的访问频率进行调度,可能导致缺页率较高。
2. 最近最久未使用(LRU)算法LRU算法是一种比较常用的页面置换算法。
它通过记录页面最近一次被访问的时间戳,优先置换最长时间未被访问的页面。
LRU算法可以有效地利用页面的访问模式,但是实现起来比较复杂。
3. 时钟(Clock)算法时钟算法是一种简单而高效的页面置换算法。
它通过维护一个指针,在页面发生缺页时从指针所指页面开始扫描。
如果页面被访问过,则将其访问位置为1;如果没有被访问过,则将其换出并将指针指向下一个页面。
时钟算法的优点是实现简单,并且能够适应访问模式的变化。
综上所述,虚拟内存是操作系统管理内存资源的一种技术。
通过虚拟内存,操作系统可以更好地管理内存,提高内存的利用率,使得多个程序能够同时运行。
实验四页面置换算法代码
实验四页面置换算法模拟(2)一.题目要求:设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率:要求设计主界面以灵活选择某算法,且以下算法都要实现1)最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2)先进先出算法(FIFO):淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
3)最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。
4)最不经常使用算法(LFU).实验目的:1、用C语言编写OPT、FIFO、LRU,LFU四种置换算法2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三.相关知识:1 .虚拟存储器的引入:局部性原理:程序在执行时在一较短时间内仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。
2 .虚拟存储器的定义:虚拟存储器是只具有请求调入功能和置换功能,能从逻辑上对内存容量进行扩充的一种存储器系统。
3 .虚拟存储器的实现方式:分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成的段式虚拟存储系统。
4 .页面分配:平均分配算法,是将系统中所有可供分配的物理块,平均分配给各个进程。
按比例分配算法,根据进程的大小按比例分配物理块。
考虑优先的分配算法,把内存中可供分配的所有物理块分成两部分:一部分按比例地分配给各进程;另一部分则根据个进程的优先权,适当的增加其相应份额后,分配给各进程。
5 .页面置换算法:常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
四.设计思想:选择置换算法,先输入所有页面号,为系统分配物理块,依次进行置换:OPT基本思想:是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。
操作系统实验四模拟页面置换算法
实验四实现页面置换算法FIFO和LRU 一、实验目的:(1)进一步理解父子进程之间的关系;(2)理解内存页面调度的机理;(3)掌握页面置换算法的实现方法;(4)通过实验比较不同调度算法的优劣;(5)培养综合运用所学知识的能力。
页面置换算法是虚拟存储管理实现的关键,通过本次试验理解内存页面调度的机制,在模拟实现FIFO、LRU等经典页面置换算法的基础上,比较各种置换算法的效率及优缺点,从而了解虚拟存储实现的过程。
将不同的置换算法放在不同的子进程中加以模拟,培养综合运用所学知识的能力。
二、实验内容及要求:(1)这是一个综合型实验,要求在掌握父子进程并发执行机制和内存页面置换算法的基础上,能综合运用这两方面的知识,自行编制程序;(2)程序涉及一个父进程和两个子进程。
父进程使用rand()函数随机产生若干随机数,经过处理后,存于一数组Acess_Series[]中,作为内存页面访问的序列。
两个子进程根据这个访问序列,分别采用FIFO和LRU两种不同的页面置换算法对内存页面进行调度。
要求:(3)每个子进程应能反映出页面置换的过程,并统计页面置换算法的命中或缺页情况。
设缺页的次数为diseffect。
总的页面访问次数为total_instruction。
缺页率 = disaffect/total_instruction命中率 = 1- disaffect/total_instruction(4)说明FIFO算法存在的Belady现象。
三、实现:数据结构(1)存放页面访问序列的数组:intAcess_Series[total_instruction];int total_instruction; //进程总的页面数(2)用一个结构数组M_Frame[]记录为进程分配的内存页面的使用情况:struct one_frame{ //记录为进程分配的内存页面情况;int page_No; //记录页面号int time; //记录页面进入内存时间int used_time; //记录页面最近使用时间};one_frame M_Frame[frame_num];int frame_num; //驻留集大小(3)本次实验我并没有采用推荐的数据结构——struct one_frame {int page_no;char flag;};struct one_frame M_Frame[frame_num];是因为我认为这个数据结构并没有很好地体现出FIFO依据进入内存时间来置换页面、LRU依据最近使用时间来置换页面。
操作系统实验4虚拟内存页面置换4种算法实验报告
操作系统实验报告实验题目:程序模拟内存页面置换策略学院:计算机学院专业班级:网络工程年级:2011级姓名:学号:完成时间:2013 年12 月8 日指导教师:指导教师评定成绩:指导教师签名:年月日指导教师评定成绩:指导教师签名:年月日指导教师评定成绩:指导教师签名:年月日本科学生实验项目任务书说明:学院、专业、年级均填全称,如:计算机学院、计算机科学与技术、2011。
实验报告正文1 需求分析(1)根据内存访问的局部性原理产生不少于1000次的页面请求序列。
需要从MFC界面的一个编辑框中得到一个大于1000的页面数,再根据页面数随机产生页面地址(本次试验主要将地址控制在0—100)。
(2)统计在不同页框数目下的页面失效率。
首先,要初始化页框,再编写isExit函数,用来判断某页是否已经存在在页框中。
在将FIFO作为置换策略的情况下,我们用一个Button控制该算法,在该算法下,我们设置了页框数分别为8,10,12,14的4种情况。
设置了4个HitNumber变量分别记录4中情况下的命中页数,用于画折线图和计算缺页率。
在将OPT,LUR,COLCK作为置换策略的情况下,基本需求同FIFO。
(3)在画折线图时,主要需要的就是从(1)(2)步骤里得到的页框数和HitNumber数,用CDC的MoveTO和LineTo两个函数。
2 系统设计(类图、模块图等)程序主界面模块图3 关键代码描述(1)初始条件产生函数①获得由界面输入的页面数void COS4aDlg::OnBnClickedButton1(){// TODO: 在此添加控件通知处理程序代码UpdateData(true);m_e3=PageNumber;UpdateData(false);}②随机产生并输出页面访问地址void COS4aDlg::OnBnClickedButton2(){// TODO: 在此添加控件通知处理程序代码CString str;srand(time(NULL));UpdateData(true);int count=0;for(int i=0;i<PageNumber;i++){ count++;CString q;PageOrder[i]=rand()%100;q.Format("%d",PageOrder[i]);if(count%8==0)str+=q+"\r\n";elsestr+=q+"__";}m_e4=str;UpdateData(false);}(2)4种算法的关键代码①FIFO的实现,得到4中页框数下的缺页率和命中数void COS4aDlg::OnBnClickedButton3(){// TODO: 在此添加控件通知处理程序代码U pdateData(true);i nt x=0; //标记最早进入内存的页面C String s2,s3,s4,s5;C String d,e,f,g,h,i,j,k,l,m,n,o;C String str1,str2,str3,str4;f or(int i=0;i<8;i++)In[i]=PageOrder[i];f or(int i=8;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<8;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit1(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%8;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber1++;}s2+=s1+" "+b+c+"\r\n";}f loat lost1=((PageNumber-FHitNumber1)*1.0/PageNumber)*100;d.Format("%f",lost1);e.Format("%d",8);f="在页框数为"+e+"时FIFO缺页率为:"+d;s tr1=s2+"\r\n"+f;f or(int i=0;i<10;i++)In[i]=PageOrder[i];f or(int i=10;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<10;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit2(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%10;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber2++;}s3+=s1+" "+b+c+"\r\n";}f loat lost2=((PageNumber-FHitNumber2)*1.0/PageNumber)*100;g.Format("%f",lost2);h.Format("%d",10);i="当页框数为"+h+"时FIFO缺页率为:"+g;s tr2=s3+"\r\n"+i;for(int i=0;i<12;i++)In[i]=PageOrder[i];f or(int i=12;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<12;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit3(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%12;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber3++;}s4+=s1+" "+b+c+"\r\n";}f loat lost3=((PageNumber-FHitNumber3)*1.0/PageNumber)*100; j.Format("%f",lost3);k.Format("%d",12);l="当页框数为"+k+"时FIFO缺页率为:"+j;s tr3=s4+"\r\n"+l;f or(int i=0;i<14;i++)In[i]=PageOrder[i];f or(int i=14;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<14;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit4(i)==0){b="调出内存的页面是";c.Format("%d",In[x]);In[x]=PageOrder[i];x=(x+1)%14;}else{b="页面命中!";c.Format("%d",PageOrder[i]);FHitNumber4++;}s5+=s1+" "+b+c+"\r\n";}f loat lost4=((PageNumber-FHitNumber4)*1.0/PageNumber)*100; m.Format("%f",lost4);n.Format("%d",14);o="当页框数为"+n+"时FIFO缺页率为:"+m;s tr4=s5+"\r\n"+o;m_e5+=str1+"\r\n\r\n"+str2+"\r\n\r\n"+str3+"\r\n\r\n"+str4+"\r\n"; U pdateData(false);}int COS4aDlg::isExit1(int i){f or(int j=0;j<8;j++){if(In[j]==PageOrder[i])return 1;}r eturn 0;}②OPT的实现,获得4种情况下的缺页率和命中数void COS4aDlg::OnBnClickedButton4(){// TODO: 在此添加控件通知处理程序代码U pdateData(true);i nt x=0; //标记最早进入内存的页面C String s2,s3,s4,s5;C String d,e,f,g,h,i,j,k,l,m,n,o;C String str1,str2,str3,str4;f or(int i=0;i<8;i++)In[i]=PageOrder[i];f or(int i=8;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<8;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit1(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber1++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best1(i);In[x]=PageOrder[i];}s2+=s1+" "+b+c+"\r\n";}f loat lost1=((PageNumber-OHitNumber1)*1.0/PageNumber)*100;d.Format("%f",lost1);e.Format("%d",8);f="当页框数为"+e+"时OPT缺页率为:"+d;s tr1=s2+"\r\n"+f;f or(int i=0;i<10;i++)In[i]=PageOrder[i];f or(int i=10;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<10;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit2(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber2++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best2(i);In[x]=PageOrder[i];}s3+=s1+" "+b+c+"\r\n";}f loat lost2=((PageNumber-OHitNumber2)*1.0/PageNumber)*100;g.Format("%f",lost2);h.Format("%d",10);i="当页框数为"+h+"时OPT缺页率为:"+g;s tr2=s3+"\r\n"+i;f or(int i=0;i<12;i++)In[i]=PageOrder[i];f or(int i=12;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<12;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit3(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber3++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best3(i);In[x]=PageOrder[i];}s4+=s1+" "+b+c+"\r\n";}f loat lost3=((PageNumber-OHitNumber3)*1.0/PageNumber)*100; j.Format("%f",lost3);k.Format("%d",12);l="当页框数为"+k+"时OPT缺页率为:"+j;s tr3=s4+"\r\n"+l;f or(int i=0;i<14;i++)In[i]=PageOrder[i];f or(int i=14;i<PageNumber;i++){CString s1;CString a,b,c;for(int j=0;j<14;j++){a.Format("%d",In[j]);s1+=a+"_";}if(isExit4(i)==1){b="页面命中!";c.Format("%d",PageOrder[i]);OHitNumber4++;}else{b="调出内存的页面是";c.Format("%d",In[x]);x=Best4(i);In[x]=PageOrder[i];}s5+=s1+" "+b+c+"\r\n";}f loat lost4=((PageNumber-OHitNumber4)*1.0/PageNumber)*100;m.Format("%f",lost4);n.Format("%d",14);o="当页框数为"+n+"时OPT缺页率为:"+m;s tr4=s5+"\r\n"+o;m_e5+=str1+"\r\n\r\n"+str2+"\r\n\r\n"+str3+"\r\n\r\n"+str4;U pdateData(false);}int COS4aDlg::Best1(int mi){i nt i=0,j=0,k=0,l=0,n=0,h=0,x=0,y=0;//分别代表In[0],In[1],In[2],等0的为最近最迟出现的页面。
计算机操作系统实验4页面置换算法
实验4 页面置换算法(2学时)一、实验目的通过实验加强对虚拟存储管理中页面置换算法的理解和掌握。
二、实验内容编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法。
三、实验要求1、任意给出一组页面访问顺序(如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2)。
2、分配给该作业一定的物理块(如3块、4块等)。
3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。
4、每访问一个页面均需给出内存中的内容(内存中的页面号),若有淘汰还需给出淘汰的页面号。
5、通过给出特殊的页面访问顺序,分配不同的物理块,利用FIFO 算法计算其缺页率,进一步理解Belady现象。
6、(附加)实现CLOCK置换算法,修改位可在确定页面号时直接任意给出。
程序代码(java)package wcm4;import java.util.LinkedList;import java.util.Scanner;public class Test {/*** @param args*/LinkedList ll=new LinkedList();int a;int leng;int[] all={1,2,5,7,5,7,1,4,3,5,6,4,3,2,1,5,2};//int[] free=new int[all.length];Object o=new Integer(a);public static void main(String[] args) {// TODO Auto-generated method stubTest t=new Test();t.begin();}public void begin(){System.out.println("请选择测试类型:");System.out.println("1 OPT; 2 FiFO; 3 LRU; 4 CLOCK; 5退出");Scanner sc=new Scanner(System.in);int choose=sc.nextInt();while(choose!=5){switch(choose){case 1:this.opt();break;case 2:this.fifo();break;case 3:this.lru();break;case 4:this.clock();break;}System.out.println("请选择测试类型:");System.out.println("1 OPT; 2 FiFO; 3 LRU; 4 CLOCK; 5退出");sc=new Scanner(System.in);choose=sc.nextInt();}}public void need(){System.out.println("请输入分配给该作业的物理块数:");Scanner sc=new Scanner(System.in);leng=sc.nextInt();}public void fifo(){ll=new LinkedList();this.need();int a=0;for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{ll.add(o);o=ll.poll();a++;}}else{o=null;}this.print();}System.out.println("FIFO的缺页率为:");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void opt(){//最佳置换算法//leng=0;ll=new LinkedList();this.need();int a=0;//int temp=0;//int[] b=new int[leng];for(int i=0;i<all.length;i++){int[] b=new int[leng];o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{for(int j=i;j<all.length;j++){Object o1=new Integer(all[j]);for(int k=0;k<leng;k++){if(ll.get(k).equals(o1)){if(b[k]==0){b[k]=j;//待替换的页在以后第一次出现的位置}}}}if(b[leng-1]==0){o=ll.set(leng-1, o);a++;}else{int temp=0;for(int m=0;m<leng;m++){if(b[m]==0){temp=m;break;}else if(b[m]>b[temp]){temp=m;}}o=ll.set(temp, o);//替换以后离得最远的a++;}}}else{o=null;}this.print();}System.out.println("OPT的缺页率为:");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void lru(){//最近最久未使用ll=new LinkedList();this.need();int a=0;for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{ll.add(o);o=ll.poll();a++;}}else{ll.add(o);ll.remove(o);o=null;}this.print();}System.out.println("OPT的缺页率为:");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void clock(){//简单clockll=new LinkedList();this.need();int a=0;int[] b=new int[leng];for(int i=0;i<all.length;i++){o=all[i];if(!ll.contains(o)){if(ll.size()<leng){ll.add(o);o=null;}else{for(int j=0;j<=ll.size();j++){if(b[j%ll.size()]==0){b[j%ll.size()]=1;}else{int temp1=j%ll.size();o=ll.set(temp1, o);b[temp1]=0;//改变该位的标记位break;}}a++;}}else{int temp=ll.indexOf(o);//找到该位b[temp]=0;o=null;}this.print();System.out.println("标记位为:");for(int k=0;k<ll.size();k++){System.out.print(b[k]);}System.out.println();}System.out.println("CLOCK的缺页率为:");System.out.println(a);System.out.println("——");System.out.println(all.length);}public void print(){Object[] op=ll.toArray();for(int i=0;i<ll.size();i++){System.out.print(op[i]);}System.out.print(" ");System.out.println(o);//System.out.println();} }。
操作系统实验-页面置换算法
四种页面置换算法一、实验原理:在存运行过程中,若其所要访问的页面不在存而需要把他们调入存,但存已经没有空闲空间时,为了保证该进程能正常运行,系统必须从存中调出一页程序或数据送磁盘的对换区中。
但应将那个页面调出,需根据一定的算法来确定。
通常,把选择换出页面的算法成为页面置换算法。
置换算法的好坏,将直接影响到系统的性能。
一个好的页面置换算法,应具有较低的页面更换频率。
从理论上讲,应将那些以后不再会访问的页面置换出,或者把那些在较长时间不会在访问的页面调出。
目前存在着许多种置换算法(如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%。
页面置换算法(FIFO算法,LRU算法)
实验四页面置换算法一、实验流程图二、实验程序#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define null 0#define len sizeof(struct page)struct page{ int num;int tag;struct page *next;};struct page *create(int n) /*建立分配的内存空间,并初始化,返回头结点*/{int count=1;struct page *p1,*p2,*head;head=p2=p1=(struct page *)malloc(len); //开辟一个新的单元,并将malloc返回的指针转换为结构体类型的指针p1->tag=-1;p1->num=-1;while(count<n){count++;p1=(struct page *)malloc(len);p1->tag=-1;p1->num=-1;p2->next=p1;p2=p1;}p2->next=null;return(head);}void FIFO(int array[],int n){int *p;struct page *cp,*dp,*head,*new1;int count=0;head=create(n);p=array;while(*p!=-1){ cp=dp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if (cp->num==*p) printf(" ! " );else{ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){cp->num=*p;printf(" * ");}else{new1=(struct page*)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}void LRU(int array[],int n){int count=0,*p=array;struct page *head,*cp,*dp,*rp,*new1,*endp;head=create(n);while(*p!=-1){cp=dp=rp=endp=head;for(;endp->next!=null;) endp=endp->next;for(;cp->num!=*p&&cp->next!=null;){rp=cp;cp=cp->next;}if(cp->num==*p){printf(" ! ");if(cp->next!=null){if(cp!=head)rp->next=cp->next;else head=head->next;}endp->next=cp;cp->next=null;}else{count++;cp=rp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;{printf(" * ");cp->num=*p;cp->tag=0;}else{new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}}p++;}printf("\nQueye Zongshu : %d \n",count);}OPT(int array[],int n){int *p,*q,count=0,i;struct page *head,*cp,*dp,*new1;p=array;head=create(n);while(*p!=-1){ cp=head;for(;cp->num!=*p&&cp->next!=null;) cp=cp->next;if(cp->num!=*p){ count++;cp=head;for(;cp->tag!=-1&&cp->next!=null;) cp=cp->next;if(cp->tag==-1){printf(" * ");cp->num=*p;cp->tag=0;}else{ i=1;q=p;q++;cp=head;while(*q!=-1&&i<n){ for(;*q!=cp->num&&cp->next!=null;) cp=cp->next;if(*q==cp->num){cp->tag=1;i++;}q++;cp=head;}if(i==n){for(;cp->tag!=0;) cp=cp->next;printf(" %d ",cp->num);cp->num=*p;}else{ cp=head;for(;cp->tag!=0;) cp=cp->next;if(cp==head){ for(;cp->next!=null;) cp=cp->next;new1=(struct page *)malloc(len);new1->num=*p;new1->tag=0;new1->next=null;cp->next=new1;dp=head;head=head->next;printf(" %d ",dp->num);free(dp);}else{ printf(" %d ",cp->num);cp->num=*p;}}cp=head;for(;cp->next!=null;) {cp->tag=0;cp=cp->next;}cp->tag=0;}}else printf(" ! ");p++;}printf("\nQueye Zongshu : %d \n",count);}main(){FILE *fp;char pt;char str[10];int i,j=0;int page[50],space=0;for(i=0;i<50;i++)page[i]=-1;fp=fopen("page.txt","r+");if(fp==NULL){printf("Cann't open the file\n");exit(0);}i=0;while((pt=fgetc(fp))!=EOF)/*将数字字符串转化成整型-开始*/ {if(pt>='0'&&pt<='9'){str[i]=pt;i++;space=0;}else{if(pt==' '||pt=='\n'){if(space==1) break;else{str[i]='\0';page[j]=atoi(str);if(pt=='\n') break;else{space=1;j++;i=0;}}}}}/*结束*/if(pt==EOF) {str[i]='\0';page[j]=atoi(str);}i=0;while(page[i]!=-1) {printf(" %d ",page[i]);i++;}fclose(fp);printf("\n");printf(" ! : mean no moved \n * : mean have free space \n\n"); printf("FIFO ");FIFO(page,3);printf("\nLRU ");LRU(page,3);printf("\nOPT ");OPT(page,3);}。
操作系统实验-页面
操作系统实验-页面置换算法四种页面置换算法一、实验原理:在内存运行过程中,若其所要访问的页面不在内存而需要把他们调入内存,但内存已经没有空闲空间时,为了保证该进程能正常运行,系统必须从内存中调出一页程序或数据送磁盘的对换区中。
但应将那个页面调出,需根据一定的算法来确定。
通常,把选择换出页面的算法成为页面置换算法。
置换算法的好坏,将直接影响到系统的性能。
一个好的页面置换算法,应具有较低的页面更换频率。
从理论上讲,应将那些以后不再会访问的页面置换出,或者把那些在较长时间内不会在访问的页面调出。
目前存在着许多种置换算法(如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;}。
虚拟内存的页面置换算法
虚拟内存的页面置换算法一、概述虚拟内存是计算机操作系统中的一种技术,它允许程序使用比实际物理内存更大的内存空间。
但是,由于实际物理内存是有限的,虚拟内存的实现需要使用到一种称为页面置换算法的策略。
页面置换算法的作用是根据一定的规则将内存中的页面从物理内存中换出,以便为新的页面腾出空间。
二、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、实验题目页面置换算法模拟——OPT、FIFO和LRU算法2、实验目的了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法,如最佳(Optimal)置换算法、先进先出(Fisrt In First Out)置换算法和最近最久未使用(Least Recently Used)置换算法3、实验内容1)OPT算法:需要发生页面置换时,算法总是选择在将来最不可能访问的页面进行置换。
2)FIFO算法:算法总是选择在队列中等待时间最长的页面进行置换。
3)LRU算法:如果某一个页面被访问了,它很可能还要被访问;相反,如果它长时间不被访问,那么,在最近未来是不大可能被访问的。
4、程序代码#include<iostream>#include <cstdlib>#include <time.h>#include <cstdio>#define L 30///页面走向长度最大为30using namespace std;int M=4; ///内存块struct P///定义一个结构体{int num,time;}p[30];int Input(int m,P p[L])///打印页面走向状态{m=30;int i,j;j=time(NULL);///取时钟时间srand(j);///以时钟时间x为种子,初始化随机数发生器cout<<"页面走向: ";for(i=0; i<m; i++){p[i].num=rand( )%10;///产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;return m;}void print(P *page1)///打印当前的页面{P *page=new P[M];page=page1;for(int i=0; i<M; i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,P *page1 )///寻找内存块中与e相同的块号{P *page=new P[M];page=page1;for(int i=0; i<M; i++)if(e==page[i].num)return i; ///返回i值return -1;}int Max(P *page1)///寻找最近最长未使用的页面用于OPT算法{P *page=new P[M];page=page1;int e=page[0].time,i=0;while(i<M) ///找出离现在时间最长的页面{if(e<page[i].time) e=page[i].time;i++;}for( i=0; i<M; i++)if(e==page[i].time)return i; ///找到离现在时间最长的页面返回其块号return -1;}int Count(P *page1,int i,int t,P p[L])///记录当前内存块中页面离下次使用间隔长度用于OPT算法{P *page=new P[M];page=page1;int count=0;for(int j=i; j<L; j++){if(page[t].num==p[j].num )break;///当前页面再次被访问时循环结束else count++;///否则count+1}return count;///返回count的值}int main(){int c=1;int m=0,t=0;float n=0;///缺页次数m=Input(m,p);///调用input函数,返回m值M=4;P *page=new P[M];///dowhile(c==1||c==2||c==3){int i=0;for(i=0; i<M; i++) ///初试化页面基本情况{page[i].num=0;page[i].time=m-1-i;}cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"3:OPT页面置换"<<endl;cout<<"按其它键结束程序;"<<endl;cin>>c;if(c==1)///FIFO页面置换///FIFO();{n=0;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0) ///当前页面在内存中{cout<<p[i].num<<" "; ///输出当前页p[i].numcout<<" "<<endl;i++; ///i加1}else ///当前页不在内存中{if(t==M)t=0;else{n++; ///缺页次数加1page[t].num=p[i].num; ///把当前页面放入内存中cout<<p[i].num<<" ";print(page); ///打印当前页面t++; //下一个内存块i++; ///指向下一个页面}}}cout<<"缺页次数:"<<n<<" 缺页率:"<<n<<"/"<<m<<" ="<<n/m<<endl;}if(c==2)///LRU页面置换,最近最久未使用{n=0;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<endl;while(i<m){int a;t=Search(p[i].num,page);if(t>=0)///如果已在内存块中{page[t].time=0;///把与它相同的内存块的时间置0for(a=0; a<M; a++)if(a!=t)page[a].time++;///其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else ///如果不在内存块中{n++; ///缺页次数加1t=Max(page); ///返回最近最久未使用的块号赋值给tpage[t].num=p[i].num; ///进行替换page[t].time=0; ///替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0; a<M; a++)if(a!=t)page[a].time++; ///其它的时间加1}i++;}cout<<"缺页次数:"<<n<<" 缺页率:"<<n<<"/"<<m<<" = "<<n/m<<endl;}if(c==3)///OPT页面置换{n=0;cout<<" OPT算法置换情况如下:"<<endl;cout<<endl;while(i<m){if(Search(p[i].num,page)>=0)///如果已在内存块中{cout<<p[i].num<<" ";cout<<" "<<endl;i++;}else///如果不在内存块中{int a=0;for(t=0; t<M; t++)if(page[t].num==0)a++;///记录空的内存块数if(a!=0) ///有空内存块{int q=M;for(t=0; t<M; t++)if(page[t].num==0&&q>t)q=t;///把空内存块中块号最小的找出来page[q].num=p[i].num;///把缺页换过来n++; ///缺页次数加一cout<<p[i].num<<" ";print(page);i++;}else{int temp=0,s;for(t=0; t<M; t++) ///寻找内存块中下次使用离现在最久的页面if(temp<Count(page,i,t,p)){temp=Count(page,i,t,p);s=t;}///把找到的块号赋给spage[s].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}}}cout<<"缺页次数:"<<n<<" 缺页率:"<<n<<"/"<<m<<" = "<<n/m<<endl;}}///while(c==1||c==2||c==3);return 0;}5、心得体会通过该实验,是我对虚拟内存更加了解,对最佳置换算法、先进先出算法、最近最久算法更加了解。
操作系统实验4(虚拟内存页面置换算法)
操作系统实验报告四【实验题目】虚拟内存页面置换算法【实验目的】通过这次实验, 加深对虚拟内存页面置换概念的理解, 进一步掌握先进先出FIFO, 最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
【实验内容】问题描述:设计程序模拟先进先出FIFO, 最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m, 在进程运行过程中要访问的页面个数为n, 页面访问序列为P1, …,Pn, 分别利用不同的页面置换算法调度进程的页面访问序列, 给出页面访问序列的置换过程, 计算每种算法缺页次数和缺页率。
程序要求如下:1)利用先进先出FIFO, 最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。
2)模拟三种算法的页面置换过程, 给出每个页面访问时的内存分配情况。
3)输入:最小物理块数m, 页面个数n, 页面访问序列P1, …,Pn, 算法选择1-FIFO, 2-OPI, 3-LRU。
4)输出: 每种算法的缺页次数和缺页率。
【实验要求】1) 上机前认真复习页面置换算法, 熟悉FIFO, OPI, LRU三种页面分配和置换算法的过程;2) 上机时独立编程、调试程序;3) 根据具体实验要求, 完成好实验报告(包括实验的目的、内容、要求、源程序、实例运行结果截图)。
【源代码】//--------------- YeMianZhiHuan.cpp -----------------#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();}【效果截图】以作业为测试数据:。
虚拟内存页面置换算法实验报告
软件学院上机实验报告课程名称:操作系统原理实验项目:虚拟内存页面置换算法实验室:地狱018 姓名:死神学号:专业班级:实验时间: 2015/12/13一、实验目的及要求通过这次实验,加深对虚拟内存页面置换概念的理解,进一步掌握先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
结合Linux的内层的分析方法查看内存的分配过程及linux kernel的内存管理机制二、实验性质设计性三、实验学时4学时四、实验环境实验环境1.实验环境: C与C++程序设计学习与实验系统2.知识准备:(1)使用Linux的基本命令;(2)了解Linux vmstat、free、top等命令查看linux系统的内存分配情况;(3)掌握虚拟内存页面置换算法FIFO等基本算法理论。
五、实验内容及步骤假设有n个进程分别在T1, … ,Tn时刻到达系统,它们需要的服务时间分别为S1, … ,Sn。
分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度,计算每个进程的完成时间、周转时间和带权周转时间,并且统计n个进程的平均周转时间和平均带权周转时间。
步骤通过已知最小物理块数、页面个数、页面访问序列、及采用置换方式可以得出页面置换的缺页次数和缺页率,及每次缺页时物理块中存储。
1.输入的形式int PageOrder[MaxNumber];//页面序列int PageNum,LackNum=0,BlockNum;//页面个数,缺页次数,最小物理块数2. 输出的形式double LackPageRate//缺页率缺页个数每次缺页时物理块中存储程序所能达到的功能模拟先进先出FIFO、最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m,在进程运行过程中要访问的页面个数为n,页面访问序列为P1, … ,Pn,分别利用不同的页面置换算法调度进程的页面访问序列,给出页面访问序列的置换过程,计算每种算法缺页次数和缺页率。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
操作系统实验报告四【实验题目】虚拟内存页面置换算法【实验目的】通过这次实验,加深对虚拟内存页面置换概念的理解,进一步掌握先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的实现方法。
【实验内容】问题描述:设计程序模拟先进先出FIFO,最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m,在进程运行过程中要访问的页面个数为n,页面访问序列为P1, …,Pn,分别利用不同的页面置换算法调度进程的页面访问序列,给出页面访问序列的置换过程,计算每种算法缺页次数和缺页率。
程序要求如下:1)利用先进先出FIFO,最佳置换OPI和最近最久未使用LRU三种页面置换算法模拟页面访问过程。
2)模拟三种算法的页面置换过程,给出每个页面访问时的内存分配情况。
3)输入:最小物理块数m,页面个数n,页面访问序列P1, … ,Pn,算法选择1-FIFO,2-OPI,3-LRU。
4)输出:每种算法的缺页次数和缺页率。
【实验要求】1) 上机前认真复习页面置换算法,熟悉FIFO,OPI,LRU三种页面分配和置换算法的过程;2) 上机时独立编程、调试程序;3) 根据具体实验要求,完成好实验报告(包括实验的目的、内容、要求、源程序、实例运行结果截图)。
【源代码】//--------------- YeMianZhiHuan.cpp -----------------#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();}【效果截图】以作业为测试数据:。