操作系统课程设计页面置换算法C语言
操作系统课程设计-页面置换算法C语言
操作系统课程设计-页面置换算法C语言5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三、设计要求1、编写算法,实现页面置换算法FIFO、LRU;2、针对内存地址引用串,运行页面置换算法进行页面置换;3、算法所需的各种参数由输入产生(手工输入或者随机数产生);4、输出内存驻留的页面集合,页错误次数以及页错误率;四.相关知识:1.虚拟存储器的引入:局部性原理:程序在执行时在一较短时间内仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。
2.虚拟存储器的定义:虚拟存储器是只具有请求调入功能和置换功能,能从逻辑上对内存容量进行扩充的一种存储器系统。
3.虚拟存储器的实现方式:分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成的段式虚拟存储系统。
4.页面分配:平均分配算法,是将系统中所有可供分配的物理块,平均分配给各个进程。
按比例分配算法,根据进程的大小按比例分配物理块。
考虑优先的分配算法,把内存中可供分配的所有物理块分成两部分:一部分按比例地分配给各进程;另一部分则根据个进程的优先权,适当的增加其相应份额后,分配给各进程。
5.页面置换算法:常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
五、设计说明1、采用数组页面的页号2、FIFO算法,选择在内存中驻留时间最久的页面予以淘汰;分配n个物理块给进程,运行时先把前n个不同页面一起装入内存,然后再从后面逐一比较,输出页面及页错误数和页错误率。
3、LRU算法,根据页面调入内存后的使用情况进行决策;同样分配n个物理块给进程,前n个不同页面一起装入内存,后面步骤与前一算法类似。
选择置换算法,先输入所有页面号,为系统分配物理块,依次进行置换:六.设计思想:OPT基本思想:是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。
操作系统页面置换算法_课程设计论文
操作系统页面置换算法_课程设计论文《操作系统》课程设计任务书题目:常用页面置换算法模拟实验学号: 学生姓名:班级:题目类型:软件工程,R,指导教师: 一、设计目的学生通过该题目的设计过程,掌握常用页面置换算法的原理、软件开发方法并提高解决实际问题的能力。
二、设计任务1、了解UNIX的命令及使用格式,熟悉UNIX/LINUX的常用基本命令,练习并掌握UNIX提供的vi编辑器来编译C程序,学会利用gcc、gdb编译、调试C程序。
2、设计一个虚拟存储区和内存工作区,并使用最佳淘汰算法,OPT,、先进先出算法,FIFO,、最近最久未使用算法,LRU,计算访问命中率。
,命中率,,,页面失效次数,页地址流长度,三、设计要求1、分析设计要求,给出解决方案,要说明设计实现所用的原理、采用的数据结构,。
2、设计合适的测试用例,对得到的运行结果要有分析。
3、设计中遇到的问题,设计的心得体会。
4、文档:课程设计打印文档每个学生一份,并装在统一的资料袋中。
5、光盘:每个学生的文档和程序资料建在一个以自己学号和姓名命名的文件夹下,刻录一张光盘,装入资料袋中。
四、提交的成果1. 设计说明书一份,内容包括:1) 中文摘要100字;关键词3-5个;2) 设计思想;3,各模块的伪码算法;4,函数的调用关系图;5,测试结果;6,源程序,带注释,;7,设计总结;8) 参考文献、致谢等。
2. 刻制光盘一张。
五、主要参考文献1. 汤子瀛,哲凤屏.《计算机操作系统》.西安电子科技大学学出版社.2. 王清,李光明.《计算机操作系统》.冶金工业出版社.3.,钟秀等. 操作系统教程. 高等教育出版社4.曾明. Linux操作系统应用教程. 陕西科学技术出版社.5. 张丽芬,刘利雄.《操作系统实验教程》. 清华大学出版社.6. 孙静, 操作系统教程,,原理和实例分析. 高等教育出版社7. 周长林,计算机操作系统教程. 高等教育出版社8. 张尧学,计算机操作系统教程,清华大学出版社9. 任满杰,操作系统原理实用教程,电子工业出版社10.张坤.操作系统实验教程,清华大学出版社六、各阶段时间安排,共2周,周次日期内容地点教师讲解设计要求教室星期一~二查找参考资料图书馆第1周星期三~五算法设计,编程实现教室星期一~三算法设计,编程实现教室第2周星期四~五检查程序,答辩教室2013年12月9日摘要操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源,控制程序运行改善人机界面,为其它应用软件提供支持等,使计算机系统所有资源最大限度地发挥作用,为用户提供方便的、有效的、友善的服务界面。
操作系统课设页面置换算法
目录一、课程设计目的及要求 (1)二、相关知识 (1)三、题目分析 (2)四、概要设计 (3)五、代码及流程 (3)六、运行结果 (7)七、设计心得 (8)八、参考文献 (9)一、课程设计目的及要求页面置换算法实验目的:深入掌握内存调度算法的概念原理和实现方法。
设计要求:编写程序实现:1)先进先出页面置换算法(FIFO)2)最近最久未使用页面置换算法(LRU)3)最佳置换页面置换算法(OPT)演示页面置换的三种算法。
二、相关知识2.1 先进先出(FIFO)算法这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单,只需把一个进程已调入内存的页面,按照先后次序链接成一个队列,并设置一个指针,称为替换指针,使它总指向最老的页面。
但该算法与进程实际运行的规律不相适应,因为在进程中,有些页面经常被访问,比如,含有全局变量、常用函数、例程等的页面,FIFO算法并不能保证这些页面不被淘汰。
2.2 最近最久未使用(LRU)算法FIFO置换算法性能之所以较差,是因为它所依据的条件是各个页面调入内存的时间,而页面调入的先后并不能反映页面的使用情况。
最近最久未使用(LRU)的页面置换算法,是根据页面调入内存后的使用情况进行决策的。
由于无法预测各页将来的使用情况,只能利用“最近的过去”作为“最近的将来”的近似,因此,LRU置换算法是选择最近最久未使用的页面予以淘汰。
该算法赋予每个页面一个访问字段,用来记录一个页面自上次被访问以来所经历的时间t,当须淘汰一个页面时,选择现有页面中其t值最大的,即最近最久未使用的页面予以淘汰。
2.3 最佳(Optimal)算法最佳置换算法是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰的页面,将是以后永不使用的,或是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法,通常可保证获得最低的缺页率。
但由于人们目前还无法预知一个进程在内存的若干个页面中,哪一个页面是将来最长时间内不再访问的,因而该算法时无法实现的,但可以利用该算法评价其他算法。
17--页面置换算法的模拟实现二
《操作系统课程设计》任务书
设计题目:页面置换算法的模拟实现二
课程设计的目的:
操作系统课程设计是计算机专业重要的教学环节,它为学生提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。
●进一步巩固和复习操作系统的基础知识。
●培养学生结构化程序、模块化程序设计的方法和能力。
●提高学生调试程序的技巧和软件设计的能力。
●提高学生分析问题、解决问题以及综合利用C 语言进行程序设计的能力。
设计内容:
根据设计要求实现对页面置换算法的模拟
设计要求:
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率。
用C语言实现,要求设计主界面以灵活选择某算法,且以下算法都要实现
1.最佳淘汰算法(OPT)
2.最少访问页面算法(LFU)
设计结束需提交下列资料:
1、课程设计报告。
报告中至少应包括:相关操作系统的知识介绍,程序总的功能说明、程序各模块的功能说明、程序设计的流程图、源程序清单。
2、源程序和编译连接后的可执行程序文件。
时间安排:
分析设计贮备阶段(1天)
编程调试阶段(7天)
写课程设计报告、考核(2天)。
实验三页面置换算法模拟实验
计算机科学系实验报告书课程名:《操作系统》题目:虚拟存储器管理页面置换算法模拟实验班级:学号:姓名:一、实验目的与要求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值,表示该虚页的最后一次被访问时间。
页面置换算法模拟实验 操作系统大作业(含源文件)
“计算机操作系统”课程设计大作业页面置换算法模拟实验(含完整资料,可直接提交)一、题目: 页面置换算法模拟实验二、目的分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法对用户输入的页面号请求序列进行淘汰和置换,从而加深对页面置换算法的理解。
三、内容和要求请用C/C++语言编一个页面置换算法模拟程序。
用户通过键盘输入分配的物理内存总块数,再输入用户逻辑页面号请求序列,然后分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法三种算法对页面请求序列进行转换,最后按照课本P150页图4-26的置换图格式输出每次页面请求后各物理块内存放的虚页号,并算出总的缺页率(缺页次数/总的请求次数)。
最后三种页面置换算法的优缺点。
三种页面置换算法的思想可参考教材P149-P152页。
假设页面号请求序列为4、3、2、1、4、3、5、4、3、2、1、5,当分配给某进程的物理块数分别为3块和4块时,试用自己编写的模拟程序进行页面转换并输出置换图和缺页次数、缺页率。
四、提交内容本大作业每个人必须单独完成。
最后需提交的内容包括:源程序(关键代码需要注释说明)、可运行程序、运行结果、算法思路及流程图、心得体会。
大作业严禁抄袭。
发现抄袭一律以不及格论。
请大家严格按照大作业题目来编写程序,不要上交以前布置的大作业。
如果提交的大作业题目与本文档要求不符,成绩一律为及格。
目录摘要 (2)正文 (2)1、设计思路 (3)2、各模块的伪码算法 (6)3、函数的调用关系图 (8)4、测试 (13)设计总结 (15)参考文献 (16)致谢 (17)附录:部分源程序代码 (18)摘要UNIX中,为了提高内存利用率,提供了内外存进程对换机制;内存空间的分配和回收均以页为单位进行;一个进程只需将其一部分(段或页)调入内存便可运行;还支持请求调页的存储管理方式。
c语言实现页面置换
#include "stdio.h"#include "stdlib.h"#define true 1#define false 0int wang;/*是否有元素*/int have(int a[],int t){int i=0,j=0;for(j=0;j<4;j++){if(a[j]==t){i=1; /*有元素*/break;}}return i;}/*先进先出页面置换算法*/void FIFO(int num[]){int i,j,k;int a[4]={-1,-1,-1,-1} ;for(i=0,j=0;i<20;i++){if(j<4){if(have(a,num[i])==0) a[j++]=num[i];}else{if(have(a,num[i])==0) {for(j=1;j<4;j++) a[j-1]=a[j]; a[3]=num[i];}}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}/*最近最久未使用*/void LRU(int num[]){int i,j,k,temp;int a[4]={-1,-1,-1,-1} ;for(i=0;i<20;i++){if(i==0)a[0]=num[0];else{for(j=0;j<4;j++){if(a[j]==num[i]) break;}for(k=j;k>0;k--){a[k]=a[k-1];}a[0]=num[i];}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}/*选择排序*/void SelectSort(int r[],int n){int i,j,temp;for(i=0;i<n;i++){for(j=i+1;j<n;j++) /*不考虑后面元素,可视从j往前的数据都是排好的*/ {if(r[i]>r[j])/*如果当前元素r[j]比索引指向的元素r[i]小,换位*/ {temp=r[i];r[i]=r[j];r[j]=temp;}}}}/*返回要置换的位置*/int del(int a[],int num[],int n){int i,j;int s[4]={0,0,0,0};int t[4]={0,0,0,0};for(i=0;i<4;i++){for(j=n;j<20;j++){if(a[i]==num[j]){s[i]=j;t[i]=j;break;}}if(j==20){ s[i]=20;t[i]=20;}}SelectSort(s,4);for(i=0;i<4;i++){if(t[i]==s[3])break;}return i;}/*最佳置换算法*/void Optimal(int num[]){int i,j,k,temp;int a[4]={-1,-1,-1,-1} ;for(i=0,j=0;i<20;i++){if(j<4){if(have(a,num[i])==0) a[j++]=num[i];}else{if(have(a,num[i])==0) {temp=del(a,num,i); a[temp]=num[i];}}for(k=0;k<4;k++)printf(" %2d",a[k]); printf(" \n");}}void main(){loop: /* 循环 */{char ch;int i;int num[20];/*初始化页面调用数组*/for(i=0;i<20;i++){num[i]=rand()%10;printf(" %d",num[i]);}printf("\n");printf("----------------------------------\n");printf(" 1---FIFO;2---LRU;3---Optimal\n");printf("----------------------------------\n\n");printf("intput the NO. :");i=0;scanf("%d",&i);printf("\n [1] [2] [3] [4]\n");switch (i){case 1:FIFO(num);break;case 2:LRU(num); break;case 3:Optimal(num);break;default:printf("input wrong No.!!!");}printf("again?(y or n)\ninput:");loop_1:{ch=getch();if(ch=='y') /* y 再次输入 */goto loop;else if(ch=='n') /* n 退出 */exit(0);else /* 都不是提示输入错误 */{printf("\ninput wrong!again please!!!\ninput:"); goto loop_1;}}}}。
操作系统课程设计页面置换算法
操作系统课程设计说明书题目: 页面置换算法程序设计院系:计算机科学与工程专业班级:学号:学生姓名:指导教师:2014年 11月 21 日2014年11月21日安徽理工大学课程设计(论文)成绩评定表目录1 问题描述 (1)2 需求分析 (1)3 概要设计 (1)3.1 设计思路 (1)3.2 功能模块设计 (2)3.3 算法流程图 (2)4 详细设计 (4)4.1 相关知识 (4)4.2 置换算法函数代码设计 (4)4.3 辅助函数代码设计 (10)5 调试分析 (12)6 测试结果 (13)7 设计体会 (15)参考文献 (15)1 问题描述编写程序实现:(1)先进先出页面置换算法(FIFO)(2)最近最久未使用页面置换算法(LRU)(3)最佳置换页面置换算法(OPT)设计一个虚拟存储区和内存工作区,编程序演示以上三种算法的具体实现过程,并计算访问命中率。
演示页面置换的三种算法。
通过随机数产生一个指令序列,将指令序列转换成为页地址流。
计算并输出各种算法在不同内存容量下的命中率。
2 需求分析在地址映射过程中,若在页面中发现所要访问的页面不再内存中,则产生缺页中断。
当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存,以便为即将调入的页面让出空间。
而用来选择淘汰哪一页的规则叫做页面置换算法。
在进程运行过程中,若其所要访问的页面不在内存需把它们调入内存,但内存已无空闲空间时,为了保证该进程能正常运行,系统必须从内存中调出一页程序或数据,送磁盘的对换区中。
但应将哪个页面调出,所以需要根据一定的算法来确定。
常用的算法有先进先出置换算法(FIFO)、最近最久未使用置换算法(LRU)和最佳置换算法(OPT),该设计是在VC++6.0环境下用上述三种算法来实现页面置换算法的模拟程序,然后计算访问命中率,并测试结果。
3 概要设计3.1 设计思路选择置换算法,先输入所有页面号,为系统分配物理块,依次进行置换: FIFO基本思想:是用队列存储内存中的页面,队列的特点是先进先出,与该算法是一致的,所以每当发生缺页时,就从队头删除一页,而从队尾加入缺页。
操作系统课程设计-页面置换算法C语言
页面置换算法一.题目要求:通过实现页面置换算法的FIFO和LRU两种算法,理解进程运行时系统是怎样选择换出页面的,对于两种不同的算法各自的优缺点是哪些。
要求设计主界面以灵活选择某算法,且以下算法都要实现1) 最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO):淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)二.实验目的:1、用C语言编写OPT、FIFO、LRU,LFU四种置换算法。
2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三、设计要求1、编写算法,实现页面置换算法FIFO、LRU;2、针对内存地址引用串,运行页面置换算法进行页面置换;3、算法所需的各种参数由输入产生(手工输入或者随机数产生);4、输出内存驻留的页面集合,页错误次数以及页错误率;四.相关知识:1.虚拟存储器的引入:局部性原理:程序在执行时在一较短时间内仅限于某个部分;相应的,它所访问的存储空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。
2.虚拟存储器的定义:虚拟存储器是只具有请求调入功能和置换功能,能从逻辑上对内存容量进行扩充的一种存储器系统。
3.虚拟存储器的实现方式:分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成的段式虚拟存储系统。
4.页面分配:平均分配算法,是将系统中所有可供分配的物理块,平均分配给各个进程。
按比例分配算法,根据进程的大小按比例分配物理块。
考虑优先的分配算法,把内存中可供分配的所有物理块分成两部分:一部分按比例地分配给各进程;另一部分则根据个进程的优先权,适当的增加其相应份额后,分配给各进程。
实验报告页面置换算法(c语言实现)
实验三页面置换算法#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20int M; struct Proi nt num,time;};I nput(int m,Pro p[L]){i nt i,j,c;c out<<"请输入实际页面走向长度L(15<=L<=20):";d o{c in>>m;i f(m>20||m<15)cout<<"实际页面长度须在15~20之间;请重新输入L:";e lse break;}while(1);j=time(NULL);s rand(j);c out<<"输出随机数: ";f or(i=0;i<m;i++){p[i].num=rand( )%10+1;p[i].time=0;c out<<p[i].num<<" ";}c out<<endl;r eturn m;}v oid print(Pro *page1){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++)i f(page[i].num==-1)c out<<" ";e lsec out<<page[i].num<<" ";c out<<"√"<<endl;}i nt Search(int e,Pro *page1 ){P ro *page=new Pro[M];p age=page1;f or(int i=0;i<M;i++) if(e==page[i].num) return i; r eturn -1;}i nt Max(Pro *page1){}i nt Count(Pro *page1,int i,int t,Pro p[L]){}i nt main(){i nt c;i nt m=0,t=0;f loat n=0;P ro p[L];c out<<"********************************************* "<<endl;c out<<" * 页式存储管理*"<<endl;c out<<"********************************************* "<<endl;c out<<"请输入可用内存页面数m(3~5): ";d o{c in>>M;i f(M>5||M<3)c out<<"内存块M须在3~5之间,请重新输入M:";e lse break;}while(1);m=Input(m,p);P ro *page=new Pro[M];c out<<"^-^欢迎进入操作系统界面^-^"<<endl;c out<<"1:FIFO页面置换"<<endl;c out<<"2:LRU页面置换"<<endl;c out<<"3:OPT页面置换"<<endl;c out<<"4:退出"<<endl;d o{c out<<"按1~4键操作:"<<endl;c in>>c;s ystem("cls");f or(int i=0;i<M;i++){p age[i].num=-1;p age[i].time=m-1-i;}i=0;i f(c==1){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0) {cout<<p[i].num<<" "; p[i].numc out<<"不缺页"<<endl;i++;}e lse {i f(t==M)t=0;e lse{n++;p age[t].num=p[i].num;c out<<p[i].num<<" ";p rint(page);t++;i++;}}}c out<<"缺页次数:"<<n<<" }i f(c==2){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" LRU算法页面置换情况如下: "<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i nt a;t=Search(p[i].num,page);i f(t>=0){p age[t].time=0;for(a=0;a<M;a++)i f(a!=t)page[a].time++;cout<<p[i].num<<" ";c out<<"不缺页"<<endl;}e lse{n++; t=Max(page);page[t].num=p[i].num; page[t].time=0;cout<<p[i].num<<" ";p rint(page);f or(a=0;a<M;a++)i f(a!=t)page[a].time++;}i++;}c out<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}i f(c==3){n=0;c out<<"******************************************"<<endl;c out<<endl;c out<<" OPT算法置换情况如下:"<<endl;c out<<endl;c out<<"******************************************"<<endl;w hile(i<m){i f(Search(p[i].num,page)>=0){c out<<p[i].num<<" ";c out<<"不缺页"<<endl;i++;}e lse{i nt a=0;f or(t=0;t<M;t++)i f(page[t].num==0)a++;if(a!=0) {i nt q=M;f or(t=0;t<M;t++)i f(page[t].num==0&&q>t)q=t;p age[q].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}e lse{i nt temp=0,s;f or(t=0;t<M;t++)i f(temp<Count(page,i,t,p)){t emp=Count(page,i,t,p);s=t;}page[s].num=p[i].num;n++;c out<<p[i].num<<" ";p rint(page);i++;}}}c out<<"缺页次数:"<<n<<" 缺页率:"<<n/m<<endl;}i f(c==4){c out<<" ^-^再见!^-^ "<<endl;}}while(c==1||c==2||c==3||c==4);r eturn 0;}结果:完成相关实验并且获得预期结果.。
操作系统页面置换算法实验报告
学生实验报告姓名:年级专业班级学号成绩【实验结果或总结】(对实验结果进行相应分析,或总结实验的心得体会,并提出实验的改进意见1.程序的执行结果如下:(1)先进先出页面置换算法(2)最佳页面置换法(3)最近最久未使用置换算法2.以上三个程序通过数组和排序语句实现页面的三种基本调度算法。
(1)先进先出算法事先设定标志k=3,页面每发生一次置换k值增加1。
通过取k对3的余数来确定被置换的内存中的页面,当被访问页面存在于内存时,不置换,而直接输出原内存中的3个页面。
(2)最佳置换算法通过设定c1,c2,c3来记录当前内存中的页面被下一次访问的位置(时间),通过对c1,c2,c3的大小比较确定内存中需要被置换的页面。
三者中值最大的对应的内存页面选择被置换。
即实现了未来最长时间未访问的机制,即最佳置换算法。
(3)最近最久未使用置换算法的原理跟最佳置换算法类似。
初始设定变量c1,c2,c3记录当前内存中的以前的最近一次未被访问的位置(时间),比较三者的大小来确定需要被置换的页面。
三者中至最小的对应的内存页面选择被置换。
即实现了最近最久未使用的机制,即最近最久未使用置换算法。
3.上述三个程序分别能较好的模拟页面的基本调度算法,实现页面的置换,保证进程的正常执行。
但也分别存在一些不足。
(1)当内存中三个页面有部分相同时,程序不能很好的实现调度。
即c1,c2,c3中有部分变量值相等,源程序可能不能准确的找到调度顺序,如图所示。
(LRU算法)改进的方法为在c1,c2,c3间的大小比较判断语句中增加关系语句的默认处理办法,当三者间有部分相同时,默认选择按从前到后的顺序执行。
比如当c2=c3的时候选择页面a[2]进行置换。
当c1=c2=c3时则选择页面a[0]进行置换。
也就相当于无法运用LRU算法调用的时候折衷采取先进先出置换算法,以实现页面的合理调度,提高页面的利用效率。
指导教师签名:20 年月日【备注】。
烟台大学操作系统课程设计页面置换算法
烟台大学计算机与控制工程学院计算机操作系统课程设计报告题目:页面置换算法班级计165姓名王承乾学号 201658501234日期 2018-7-3指导教师翟一鸣实验地点计算机与控制工程学院实验室一、实验内容页面置换算法:淘汰掉内存中的某些页为必须进入内存的页面腾出空间的策略。
最优算法(OPT):从内存中移出以后不再使用的页面,如果没有这样的页面,则选择以后最长时间内不需要访问的页面。
先进先出算法(FIFO):总是先淘汰那些驻留在内存时间最长的页面,即先进入内存的页面先被置换掉。
最近最久未使用算法(LRU):当需要置换一页时,选择最近一段时间最久未使用的页面予以淘汰。
设计程序模拟先进先出(FIFO)置换算法,最佳(OPT)置换算法和最近最少用(LRU)置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m,在进程运行过程中要访问的页面个数为n,页面访问序列为P1, … ,Pn,分别利用不同的页面置换算法调度进程的页面访问序列,给出页面访问序列的置换过程,计算每种算法缺页次数和缺页率。
程序的设计主要是测试先进先出FIFO,最佳置换OPT和最近最少用LRU页面置换算法的效率以及过程。
二、实验目的使用系统函数以及c语言的相关语句实现页面置换的三个算法三、实验环境开发环境:Windows编译环境:gcc,g++开发软件:Codeblocks 16.01四、设计思路和流程图(一)程序总体控制左上:FIFO和数据输入右上:OPT算法左下:退出右下:LRU算法六、感想通过对页面置换算法模拟程序的程序设计,让我对虚拟页式存储管理有了更深的了解。
刚开始拿到这个题目觉得很难,不知道该怎么下手,因为是自己第一次用C语言编写操作系统程序。
当时搞懂了页面置换的思想以后,对编程就有了一定的思路。
经过几天的编写,程序也最终编写出来了。
但是却遇到了许多困难,程序的调试也出现了许多的错误。
经过几次上机操作,在老师的指导和帮助下,程序最终还是完成了。
页面置换算法(C语言)
《操作系统》实验报告题目:页面置换算法班级:网络工程姓名:朱锦涛学号:E31314037一、实验目的用代码实现页面置换算法,通过代码的具体实现,加深对两个页面置换算法:先进先出页面置换算法和最近最久未使用算法的核心的理解。
二、实验原理1.先进先出页面置换算法:地址映射过程中,若在页面中发现所要访问的页面不再内存中,则产生缺页中断。
当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存,以便为即将调入的页面让出空间。
而用来选择淘汰哪一页的规则叫做页面置换算法。
最简单的页面置换算法是先入先出(FIFO)法。
2.最近最久未使用算法:LRU算法的提出,是基于这样一个事实:在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。
反过来说,已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。
这个,就是著名的局部性原理——比内存速度还要快的cache,也是基于同样的原理运行的。
因此,我们只需要在每次调换时,找到最少使用的那个页面调出内存。
这就是LRU算法的全部内容。
三、实验内容源程序:#include<iostream.h>#include <stdlib.h>#include <time.h>#include <stdio.h>#define L 20//页面走向长度最大为20 int M; //内存块struct Pro//定义一个结构体{int num,time;};void print(Pro *page1)//打印当前的页面{Pro *page=new Pro[M];page=page1;for(int i=0;i<M;i++)cout<<page[i].num<<" ";cout<<endl;}int Search(int e,Pro *page1 )//寻找内存块中与e相同的块号{Pro *page=new Pro[M];page=page1;for(int i=0;i<M;i++) //遍历内存if(e==page[i].num)return i;//返回i值}int Max(Pro *page1)//寻找最近最长未使用的页面{Pro *page=new Pro[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;//找到离现在时间最长的页面返回其块号}int Count(Pro *page1,int i,int t,Pro p[L])//记录当前内存块中页面离下次使用间隔长度{Pro *page=new Pro[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,i;int t=0;f loat n=0;P ro p[L]; //20个结构体srand(time(NULL));//随机数发生器c out<<"输出随机数: ";f or(i=0;i<20;i++) //20 个随机数{p[i].num=rand( )%10+1;//产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}cout<<endl;cout<<"请输入可用内存页面数m(3~5): ";do{cin>>M;if(M>5||M<3)cout<<"内存块m须在3~5之间,请重新输入m: ";else break;}while(1);Pro *page=new Pro[M];//动态结构体数组do{for(int i=0;i<M;i++)//初试化页面基本情况 {page[i].num=0;page[i].time=20-1-i;}cout<<"1:FIFO页面置换"<<endl;cout<<"2:LRU页面置换"<<endl;cout<<"按其它键结束程序;"<<endl;cin>>c;system("cls"); //清屏if(c==1)//FIFO页面置换{n=0;cout<<"******************************************"<<endl;cout<<endl;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;cout<<"******************************************"<<endl;while(i<20){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/20<<endl;}if(c==2)//LRU页面置换{n=0;cout<<"******************************************"<<endl;cout<<endl;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<endl;cout<<"******************************************"<<endl;while(i < 20){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/20<<endl;}}while(c==1||c==2);return 0;}实验结果:FIFO置换算法:LRU置换算法:四.实验小结本次试验,使用顺序表来存储包括内存页面和页面号引用串,struct Pro{int num,time;};其中num表示页面号,页面号引用串用随机数循环20次来初始化20个页面号,同时物理块号可由用户自己在3~5之间选择,初始化页面号全为0。
页面置换算法c语言
页面置换算法(Page Replacement Algorithm)是操作系统中用于管理计算机内存的一种算法。
当系统中的物理内存不足时,操作系统会选择内存中的一些页面,将它们从内存中移动到磁盘上,以便为新的页面提供空间。
以下是使用C语言实现FIFO(First-In, First-Out)页面置换算法的示例代码:c复制代码#include<stdio.h>#include<stdlib.h>#define MAX_FRAMES 100#define MAX_PAGES 1000int frames[MAX_FRAMES];int page_faults = 0;void insert(int page, int frames[], int* page_faults) {int i;for (i = 0; i < *page_faults; i++) {if (frames[i] == page) {// Page already exists in memoryreturn;}}for (i = *page_faults; i < MAX_FRAMES; i++) {if (frames[i] == -1) {// Frame is empty, insert page at the end of the arrayframes[i] = page;(*page_faults)++;return;}}// All frames are full, page must be replaced to make room for the new page frames[*page_faults] = page;(*page_faults)++;}int main() {int pages[MAX_PAGES];int num_pages, num_frames, i, j;int page_faults_array[MAX_PAGES];int page_faults = 0;int current_frames[MAX_FRAMES];for (i = 0; i < MAX_FRAMES; i++) {current_frames[i] = -1; // Initialize all frames as empty}printf("Enter the number of pages: ");scanf("%d", &num_pages);printf("Enter the number of frames: ");scanf("%d", &num_frames);for (i = 0; i < num_pages; i++) {printf("Enter page %d: ", i + 1);scanf("%d", &pages[i]);insert(pages[i], current_frames, &page_faults); // Insert page into memorypage_faults_array[i] = page_faults; // Store page fault count for each page in an array}printf("Page Faults: %d\n", page_faults); // Print total number of page faults for the entire sequence of pagesprintf("Page Faults for each page in the sequence:\n"); // Print page fault count for each page in the sequence of pagesfor (i = 0; i < num_pages; i++) {printf("Page %d: %d\n", pages[i], page_faults_array[i]); // Print the page fault count for each page in the array of page fault counts for each page in the sequence of pages (nested array) (Duh) (Sorry for the confusion) (It's actually not that confusing once you see it written out like this) (If you're still con。
先进先出(FIFO)页面置换算法C语言实现、最近最久未使用(LRU)页面置换算法C语言实现
先进先出(FIFO)页⾯置换算法C语⾔实现、最近最久未使⽤(LRU)页⾯置换算法C语⾔实现1.实现效果2.实现源代码1 #include<iostream>2 #include<process.h>3 #include<stdlib.h>4 #include<ctime>5 #include<conio.h>6 #include<stdio.h>7 #include<string.h>8using namespace std;910#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n")/*表格控制*/11#define bsize 4 //物理块⼤⼩12#define psize 16 //进程⼤⼩13void chushihua();//初始化函数14void ymzh();16void changeaddr(struct Page p[], int logaddr);17void dizhizhuanhuan();18void menu();19int wang();2021int yemianliu[32]={0};//全局变量数组,地址流22int p;23struct Page {24int pno;//页号25int flag;//标志位26int cno;//主存号27int modf;//修改位28int addr;//外存地址29 }Page; //全局变量p是⼀共有多少地址流3031 typedef struct pagel32 {33int num; /*记录页⾯号*/34int time; /*记录调⼊内存时间*/35 }Pagel; /*页⾯逻辑结构,⽅便算法实现*/3637 Pagel b[bsize]; /*内存单元数*/38int c[bsize][psize];/*保存内存当前的状态:缓冲区*/39int queue[100];/*记录调⼊队列*/40int k;/*调⼊队列计数变量*/41int phb[bsize]={0};//物理块标号42int pro[psize]={0};//进程序列号43int flag[bsize]={0};//进程等待次数(存放最久未被使⽤的进程标志)*/ 44int i=0,j=0;//i表⽰进程序列号,j表⽰物理块号*/45int m =-1,n =-1;//物理块空闲和进程是否相同判断标志*/46int mmax=-1, maxflag=0;//标记替换物理块进程下标*/47int count =0; //统计页⾯缺页次数4849void chushihua() //初始化函数50 {51int t;52 srand(time(0));//随机产⽣指令序列53 p=12+rand()%32;54 cout<<"地址流序列:";55 cout<<endl;56for(i=0; i<p; i++)57 {58 t=1+rand()%9;59 yemianliu[i]=t;//将随机产⽣的指令数存⼊页⾯流60 }61for (i=p-1;i>=0;i--)62 {63 cout<<yemianliu[i]<<"";64 }65 cout<<endl;66 }67void ymzh()68 {69 chushihua();70 yemianzhihuan();71 }7273void yemianzhihuan()74 {75int a;76 printf("----------------------------------\n");77 printf("☆☆欢迎使⽤分页模拟实验系统☆☆\n");78 printf("----------------------------------");79 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");80 printf("☆☆1.进⼊硬件地址变换算法☆☆\n");81 printf("☆☆------------------------☆☆\n");82 printf("☆☆2.进⼊页⾯置换算法☆☆\n");83 printf("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");84 printf("请输⼊您的选择:");85switch(a)86 {87case1:88 ymzh();89break;90case2:91 wang();92break;93default:94 cout<<"输⼊有误,请重新输⼊!"<<endl;95break;96 }97 }98100int j=logaddr/64;//对应的块号101int k=logaddr%64; //对应的偏移量102int flag=0;103int addr;104for(int i=0;i<8;i++)105 {106if(p[i].pno==j)//找到对应的页号107 {108if(p[i].flag==1)//页⾯标志为1109 {110 addr=p[i].cno*64+k;111 cout<<"物理地址为:"<<addr<<endl;112 cout<<"详细信息:"<<"\t页⾯号:"<<p[i].pno<<"\t 主存号:"<<p[i].cno<<"\t偏移量:"<<k<<endl; 113 flag=1;114break;115 }116 }117 }118119if(flag==0)120 cout<<"该页不在主存,产⽣缺页中断"<<endl;121 }122123void dizhizhuanhuan()124 {125int a;126int ins;//指令逻辑地址127struct Page p[8];128 p[0].pno=0;p[0].flag=1;p[0].cno=5;p[0].modf=1;p[0].addr=011;129 p[1].pno=1;p[1].flag=1;p[1].cno=8;p[1].modf=1;p[1].addr=012;130 p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;131 p[3].pno=3;p[3].flag=1;p[3].cno=10;p[3].modf=0;p[3].addr=015;132 p[4].pno=4;p[4].flag=0;p[4].addr=017;133 p[5].pno=5;p[5].flag=0;p[5].addr=025;134 p[6].pno=6;p[6].flag=0;p[6].addr=212;135 p[7].pno=7;p[7].flag=0;p[7].addr=213;136 printf("\t\t\t--------------------------------\n");137 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");138 printf("\t\t\t---------------------------------\n");139 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");140 printf("\t\t\t☆☆1.输⼊指令☆☆\n");141 printf("\t\t\t☆☆------------------------☆☆\n");142 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");143 printf("\t\t\t☆☆------------------------☆☆\n");144 printf("\t\t\t☆☆0.EXIT ☆☆\n");145 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");146while(a!=0)147 {148 cout<<endl<<"请输⼊您的选择:";149 cin>>a;150151 cout<<"页号"<<"标记位"<<"外存地址"<<"主存号"<<endl;152for(int i=0;i<8;i++)153 {154 cout<<p[i].pno<<"\t"<<p[i].flag<<"\t"<<p[i].addr<<"\t";155if(p[i].flag)156 cout<<p[i].cno;157 cout<<endl;158 }159160switch(a)161 {162case0:printf("\t\t\t再见!\t\t\t\n"); break;163case1:164 cout<<"请输⼊指令的逻辑地址:";165 cin>>ins;166 changeaddr(p, ins);break;167case2: system("CLS"); a=wang();break;168default:cout<<"输⼊有误,请重新输⼊!"<<endl;break;169 }170 }171 }172173void menu()174 {175int a;176 printf("\t\t\t--------------------------------\n");177 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");178 printf("\t\t\t---------------------------------\n");179 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");180 printf("\t\t\t☆☆1.输⼊指令☆☆\n");181 printf("\t\t\t☆☆------------------------☆☆\n");182 printf("\t\t\t☆☆2.进⼊页⾯置换算法☆☆\n");184 printf("\t\t\t☆☆0.EXIT ☆☆\n");185 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n"); 186 printf("请选择所要执⾏的操作:");187 scanf("%d",&a);188switch(a)189 {190case0: printf("\t\t\t-再见!-\t\t\t\n");break;191case1: dizhizhuanhuan (); break;192case2: wang (); break;193default:cout<<"输⼊有误,请重新输⼊!"<<endl;break; 194 }195 }196int main()197 {198 menu();199 }200201//****************随机产⽣序列号函数202int* build()203 {204 printf("随机产⽣⼀个进程序列号为:\n");205int i=0;206for(i=0; i<psize; i++)207 {208 pro[i]=10*rand()/(RAND_MAX+1)+1;209 printf("%d ", pro[i]);210 }211 printf("\n");212return(pro);213 }214215//***************************************查找空闲物理块216int searchpb()217 {218for (j=0;j<bsize; j++)219 {220if(phb[j] == 0)221 {222 m=j;223return m;224break;225 }226 }227return -1;228 }229//************************************查找相同进程230int searchpro()231 {232for(j=0;j< bsize;j++)233 {234if(phb[j] =pro[i])235 {236 n=j;237return j;238 }239 }240return -1;241 }242243//*************************初始化内存244void empty()245 {246for(i=0;i<bsize;i++)247 phb[i]=0;248 count=0; //计数器置零249 } //******先进先出页⾯置换算法250void FIFO()251 {252for( i=0; i<psize; i++)253 {254// m=searchpb();255// n=searchpro();256//找到第⼀个空闲的物理快257for(j=0;j<bsize;j++) {258if(phb[j] == 0){259 m=j;260break;261 }262 }263//找与进程相同的标号264for(j=0;j<bsize;j++) {265if(phb[j] == pro[i]){266 n=j;268 }269270//找flag值最⼤的271for(j=0;j<bsize;j++)272 {273if(flag[j]>maxflag)274 {275 maxflag = flag[j];276 mmax = j;277 }278 }279280if(n == -1)//不存在相同进程281 {282if(m != -1)//存在空闲物理块283 {284 phb[m]=pro[i];//进程号填⼊该空闲物理块285// count++;286 flag[m]=0;287for (j=0;j<=m; j++)288 {289 flag[j]++;290 }291 m=-1;292 }293else//不存在空闲物理块294 {295 phb[mmax] =pro[i];296 flag[mmax] =0;297for (j=0;j<bsize;j++)298 {299 flag[j]++;300 }301 mmax = -1;302 maxflag = 0;303 count++;304 }305 }306else//存在相同的进程307 {308 phb[n] = pro[i];309for(j=0;j<bsize;j++)310 {311 flag[j]++;312 }313 n=-1;314 }315for(j=0;j < bsize;j++)316 {317 printf("%d ", phb[j]);318 }319 printf("\n");320 }321 printf("缺页次数为:%d\n",count);322 printf("缺页率 :%16. 6f",(float)count/psize);323 printf("\n");324 }325/*初始化内存单元、缓冲区*/326void Init(Pagel *b,int c[bsize][psize])327 {328int i,j;329for (i=0;i<psize;i++)330 {331 b[i].num=-1;332 b[i].time=psize-i-1;333 }334for(i=0;i<bsize;i++)335for(j=0;j<psize;j++)336 c[i][j]=-1;337 }338/*取得在内存中停留最久的页⾯,默认状态下为最早调⼊的页⾯*/ 339int GetMax(Pagel *b)340 {341int i;342int max=-1;343int tag=0;344for(i=0;i<bsize;i++)345 {346if(b[i].time>max)347 {348 max=b[i].time;349 tag= i;350 }353 }354355/*判断页⾯是否已在内存中*/356int Equation(int fold, Pagel *b)357 {358int i;359for(i=0;i<bsize;i++)360 {361if(fold==b[i]. num)362return i;363 }364return -1;365 }366/*LRU核⼼部分*/367void Lruu(int fold, Pagel *b)368 {369int i;370int val;371 val=Equation(fold, b);372if (val>=0)373 {374 b[val].time=0;375for(i=0;i<bsize;i++)376if (i!=val)377 b[i].time++;378 }379else380 {381 queue[++k]=fold;/*记录调⼊页⾯*/382 val=GetMax(b);383 b[val].num=fold;384 b[val].time=0;385for (i=0;i<bsize;i++){386387// URLcount++;388if (i!=val)389 b[i].time++;390 }391 }392 }393394void LRU()395 {396int i,j;397 k=0;398 Init(b, c);399for(i=0; i<psize; i++)400 {401 Lruu(pro[i],b);402 c[0][i]=pro[i];403/*记录当前的内存单元中的页⾯*/404for(j=0;j<bsize;j++)405 c[j][i]=b[j].num;406 }407408/*结果输出*/409 printf("内存状态为:\n");410 Myprintf;411for(j=0;j<psize;j++)412 printf("|%2d", pro[j]);413 printf("|\n");414 Myprintf;415416for(i=0;i<bsize;i++)417 {418for(j=0; j<psize; j++)419 {420if(c[i][j]==-1)421 printf("|%2c",32);422else423 printf("|%2d",c[i][j]);424 }425 printf("|\n");426 }427428 Myprintf;429// printf("\n调⼊队列为:");430// for(i=0;i<k;i++)431// printf("%3d", queue[i]);432433 printf("\n缺页次数为:%6d\n 缺页率 :%16. 6f", k+1,(float)(k+1)/psize); 434 }437int wang()438 {439int sel;440do{441 printf("\t\t\t--------------------------------\n");442 printf("\t\t\t☆☆欢迎使⽤分页模拟实验系统☆☆\n");443 printf("\t\t\t---------------------------------\n");444 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");445 printf("\t\t\t☆☆虚拟内存☆☆\n");446 printf("\t\t\t☆☆------------------------☆☆\n");447 printf("\t\t\t☆☆1.产⽣随机序列☆☆\n");448 printf("\t\t\t☆☆------------------------☆☆\n");449 printf("\t\t\t☆☆2.最近最久未使⽤☆☆\n");450 printf("\t\t\t☆☆------------------------☆☆\n");451 printf("\t\t\t☆☆3.先进先出☆☆\n");452 printf("\t\t\t☆☆------------------------☆☆\n");453 printf("\t\t\t☆☆0.退出☆☆\n");454 printf("\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\n");455 printf("请选择所要执⾏的操作:");456 scanf("%d",&sel);457switch(sel)458 {459case0: printf("\t\t\t再见!t\t\t\n"); break;460case1: build(); break;461case2: printf("最近最久未使⽤\n"); LRU();empty(); printf("\n");break; 462case3: printf("先进先出算法\n"); FIFO();empty();printf("\n");break; 463default:printf("请输⼊正确的选项号!");printf("\n\n");break;464 }465 }while(sel !=0 );466return sel;467 }。
lru页面置换算法实验c语言总结
LRU页面置换算法实验C语言总结1.引言在计算机科学中,页面置换算法是解决主存容量有限的情况下,如何有效地管理页面(或称为内存块)的一种重要方法。
L RU(L ea st Re ce nt ly Us e d)页面置换算法是其中一种经典的策略,通过淘汰最久未使用的页面来提高内存的利用率。
本文将总结使用C语言实现L RU页面置换算法的相关实验。
2.算法原理L R U页面置换算法的核心思想是:最近被访问的页面可能在未来继续被访问,而最久未被使用的页面可能在未来也不再被访问。
基于这一思想,L R U算法维护一个页面访问的时间顺序链表,每次发生页面置换时,选择链表头部(即最久未使用)的页面进行淘汰。
3.实验设计本次实验旨在使用C语言实现LR U页面置换算法,并通过模拟页面访问的过程来验证算法的正确性。
具体设计如下:3.1数据结构为了实现LR U算法,我们需要定义几个关键的数据结构:3.1.1页面节点结构t y pe de fs tr uc tP age{i n tp ag eI D;//页面I Ds t ru ct Pa ge*n ex t;//下一个节点指针s t ru ct Pa ge*p re v;//上一个节点指针}P ag e;3.1.2内存块结构t y pe de fs tr uc tM emo r y{i n tc ap ac it y;//内存块容量i n ts iz e;//当前存储的页面数量P a ge*h ea d;//内存块链表头指针P a ge*t ai l;//内存块链表尾指针}M em or y;3.2实验步骤本次实验主要包括以下几个步骤:3.2.1初始化内存块根据实际需求,设置内存块的容量,并初始化链表头指针和尾指针。
3.2.2页面置换每次发生页面访问时,检查访问的页面是否已经在内存块中。
如果在,将该页面移动到链表尾部;如果不在,执行页面置换。
3.2.3页面淘汰当内存块已满时,选择链表头部的页面进行淘汰,将新访问的页面加入链表尾部。
操作系统课程设计 页面置换算法C语言word文档良心出品
页面置换算法一•题目要求:通过实现页面置换算法的FIFO 和LRU 两种算法,理解进程运行时系统是怎样选择换出页面的,对于两种不同的算法各自的优缺点是哪些。
要求设计主界面以灵活选择某算法,且以下算法都要实现最佳置换算法(OPT):将以后永不使用的或许是在最长(未来)时间内不再被访问的页 面换出。
先进先出算法(FIFO):淘汰最先进入内存的页面,即选择在内存中驻留时间最久的 页面予以淘汰。
最近最久未使用算法(LRU):淘汰最近最久未被使用的页面。
最不经常使用算法(LFU)1、 编写算法,实现页面置换算法 FIFO 、LRU2、 针对内存地址引用串,运行页面置换算法进行页面置换;3、算法所需的各种参数由输入产生(手工输入或者随机数产生);4、输出内存驻留的页面集合,页错误次数以及页错误率; 四. 相关知识:1虚拟存储器的引入:局部性原理:程序在执行时在一较短时间内仅限于某个部分;相应的,它所访问的存储 空间也局限于某个区域,它主要表现在以下两个方面:时间局限性和空间局限性。
2. 虚拟存储器的定义:虚拟存储器是只具有请求调入功能和置换功能,能从逻辑上对内存容量进行扩充的一种 存储器系统。
3. 虚拟存储器的实现方式:分页请求系统,它是在分页系统的基础上,增加了请求调页功能、页面置换功能所形成 的页面形式虚拟存储系统。
请求分段系统,它是在分段系统的基础上,增加了请求调段及分段置换功能后,所形成 的段式虚拟存储系统。
4. 页面分配:平均分配算法,是将系统中所有可供分配的物理块,平均分配给各个进程。
按比例分配算法,根据进程的大小按比例分配物理块。
考虑优先的分配算法,把内存中可供分配的所有物理块分成两部分:一部分按比例地分 配给各进程;另一部分则根据个进程的优先权,适当的增加其相应份额后,分配给各进程。
1) 2) 3) 4)二•实验目的:1、 用C 语言编写OPT 、FIFO 、LRU , LFU 四种置换算法。
【操作系统】页面置换算法(最佳置换算法)(C语言实现)
【操作系统】页⾯置换算法(最佳置换算法)(C语⾔实现)【操作系统】页⾯置换算法(最佳置换算法)(C语⾔实现)(编码⽔平较菜,写博客也只是为了个⼈知识的总结和督促⾃⼰学习,如果有错误,希望可以指出)1.页⾯置换算法:在地址映射过程中,若在页⾯中发现所要访问的页⾯不在内存中,则产⽣缺页中断。
当发⽣缺页中断时,如果操作系统内存中没有空闲页⾯,则操作系统必须在内存选择⼀个页⾯将其移出内存,以便为即将调⼊的页⾯让出空间。
⽽⽤来选择淘汰哪⼀页的规则叫做页⾯置换算法。
⼀个好的页⾯置换算法,应具有较低的页⾯更换频率。
从理论上讲,应该保留最近重复访问的页⾯,将以后都不再访问或者很长时间内不再访问的页⾯调出。
----百度百科2.具体的页⾯置换算法:2.1 最佳置换算法:⼀个进程在内存的若⼲个页⾯中,哪⼀个页⾯是未来最长时间内不再被访问的,那么如果发⽣缺页中断时,就将该页⾯换出,以便存放后⾯调⼊内存中的页⾯。
1.这是计算机操作系统(第四版)中的⼀个例⼦。
系统⾸先为进程分配了三个物理块。
上⾯⼀排数字是作业号。
在转满三个物理块后,要访问2号作业,2号作业不在内存,所以会发⽣缺页中断,然后系统需要将2号作业调⼊内存,但是此时物理块已经装满。
2.依据最佳置换算法,会将7号页换出(0号页在2号页后第1个就会被访问,1号页在2号页后第10个会被访问,7号页在2号页后第14个会被访问,7号页在已经装⼊内存的作业中是未来最长时间不会被访问的,所以换出7号页)。
3.后⾯依次类推。
2.2 先进先出算法:如果发⽣缺页中断,需要换出⼀个页⾯的时候,总是选择最早进⼊内存的页⾯,即选择在内存中驻留时间最久的页⾯进⾏换出。
有点不清楚。
就是每次发⽣缺页就将最早进⼊内存的页⾯换出,然后将刚调⼊的页⾯换⼊该物理块。
2.3 最近最久未使⽤(LRU)置换算法:LRU算法是缺页中断发⽣时选择最久未使⽤的页⾯进⾏换出。
这个算法其实也很好判断。
分享⼀个⼩技巧。
内存分配了k个物理块,发⽣缺页中断将要往内存调⼊某个页⾯的时候,在该页⾯往前⾯数K个物理块最前⾯的那个就会是要换出的,因为该页⾯最长时间未被使⽤过。
操作系统课程设计页面置换算法
《操作系统》实验报告实验题目:班级:学号:姓名:实验日期:报告日期:成绩:实验内容简要描述1、实验目的(1)掌握先进先出页面置换算法;(2)掌握最近最久未使用页面置换算法;(3)掌握改进的CLOCK页面置换算法,了解其他页面置换算法;(4)熟悉C/C++或其他语言编程。
2、实验要求要求掌握C/C++语言进行编码,掌握页面缺页率的算法和基本思想,理解先进先出,最近最久未使用页面置换算法的,计算并记录缺页率。
根据实验数据撰写实验报告3、实验内容编写程序,设置不同的页面数,使用不同的页面替换策略算法进行模拟页面替换。
先进先出,最近最久未使用页面置换算法等,并计算缺页率。
4、实验环境1.PC微机2.Windows 操作系统3.C/C++或其他语言开发环境实验体会通过这次实验我学到了C/C++语言进行编码,以及页面缺页率的算法和基本思想,和页面置换算法的基本知识,发现了自己的一些不足,对今后编写C/C++语言提供了帮助。
附件:源程序[包括截图]#include<conio.h>#include<stdio.h>#include<dos.h>#include<stdlib.h>#include<math.h>#include<time.h>int add[256],page[256];int k,j,ram,t;float rate;struct s1{ int page; int free; int tag;}fifo[33],opt[33],lru[33];struct s2{ int time;};int random(int x){ return rand() % x;}void address();int random(int x);float FIFO(int ram);float OPT(int ram);float LRU(int ram);void main(){ int i,p[256]; address(); srand(time(0));for(k=1;k<=8;){ printf("the size of the page is %d k\n",k);printf("the page number is ...\n");for(i=0;i<256;i++){ p[i]=add[i]/(k*1024); printf("%d ",p[i]);}j=0;for(i=0;i<256;i++){ while(p[i]==p[i+1]) i++; page[j]=p[i]; j++;}printf("\nafter connect the same pages the page num is:\n"); for(i=0;i<j;i++)printf("%d ",page[i]);printf("\n");getch();for(ram=1;ram<=32;ram++){ if (ram==10)getch();printf("\nblock=%d pages=%d,absent rate:",ram,j);printf("FIFO=%0.2f%%",FIFO(ram));printf("LRU=%0.2f%%",LRU(ram));printf("OPT=%0.2f%%",OPT(ram));}k=k*2; getch();}}void address(){ int i; add[0]=1000;for(i=1;i<=255;i++){int x=random(1024);if((x>=0)&&(x<512))add[i]=add[i-1]+1;if((x>=512)&&(x<768))add[i]=random(add[i-1]-1)+1;if((x>=768)&&(x<1024))add[i]=add[i-1]+random(30*1024-add[i-1]-1)+1; }}float FIFO(int ram) /{ int absent=0,t=0,i,z,l,yn;for(i=0;i<ram;i++){ fifo[i].page=-1; fifo[i].free=1; fifo[i].tag=0;}i=0;while(i<j){yn=0; for(z=0;z<ram;z++)if(fifo[z].page==page[i]){yn=1;for(z=0;z<ram;z++)if(fifo[z].free==0)fifo[z].tag+=1;}if(yn!=1){absent+=1; l=0;while((l<ram)&&(fifo[l].free==0))l++;if((l<ram)&&(fifo[l].free==1)){fifo[l].page=page[i];fifo[l].free=0;for(l=0;l<ram;l++)if(fifo[l].free==0)fifo[l].tag+=1;}else{t=0;for(l=0;l<ram;l++)if(fifo[l].tag<fifo[t].tag)t=l;fifo[t].page=page[i];fifo[t].free=0;fifo[t].tag=1;l=0;}}i++;}rate=(float)absent/j*100;return rate;}float LRU(int ram) /{int absent=0,yn,t,i,l,z,now=0;struct s2 P[250];for(i=0;i<j;i++)P[i].time=0;for(i=0;i<ram;i++){ lru[i].page=-1; lru[i].free=1;}i=0;while(i<j){for(l=0;z<ram;z++)yn=0;for(z=0;z<ram;z++){ if(lru[z].page==page[i]){ now+=1;P[lru[z].page].time=now;yn=1;}if(yn!=1){ absent+=1; now+=1; l=0;while((l<=ram)&&(lru[l].free==0)) l++;if((l<=ram)&&(lru[l].free==1)){lru[l].page=page[i];P[lru[l].page].time=now;lru[l].free=0;}else{t=0;for(l=0;l<ram;l++)if(P[lru[l].page].time<P[lru[t].page].time)t=1;lru[t].page=page[i];P[lru[t].page].time=now;}}}i++;}rate=(float)absent/j*100;return rate;}float OPT(int ram){int yn,t,absent=0,i,l1,k,l;for (i=0;i<ram;i++){opt[i].page=-1; opt[i].free=1; opt[i].tag=0;}i=0;while(i<j){yn=0;for (l1=0;l1<ram;l1++)if (page[i]==opt[l1].page){yn=1;for(k=0;k<ram;k++)opt[k].tag-=1;}if(yn!=1){ absent+=1; l=0;while((l<ram)&&(opt[l].free==0)) l++;if((l<=ram)&&(opt[l].free==1)){ opt[l].page=page[i]; opt[l].free=0; opt[l].tag=1;for(l=0;l<ram;l++){ opt[l].tag-=1;}}else{for(l=0;l<ram;l++){t=i;while(t<j&&opt[l].page!=page[t]){ t++;opt[l].tag+=1;}}t=0;for(l=0;l<ram;l++)if(opt[l].tag>opt[t].tag) t=l;opt[t].page=page[i];opt[t].tag=1;}}i++;}rate=(float)absent/j*100;return rate;}运行结果:。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
页面置换算法的演示一.题目要求:设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率:要求设计主界面以灵活选择某算法,且以下算法都要实现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]是存储装入物理块中的页面。
数组next[mSIZE]记录物理块中对应页面的最后访问时间。
每当发生缺页时,就从物理块中找出最后访问时间最大的页面,调出该页,换入所缺的页面。
【特别声明】若物理块中的页面都不再使用,则每次都置换物理块中第一个位置的页面。
FIFO基本思想:是用队列存储内存中的页面,队列的特点是先进先出,与该算法是一致的,所以每当发生缺页时,就从队头删除一页,而从队尾加入缺页。
或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间,每次需要置换时换出进入时间最小的页面。
LRU基本思想:是用一维数组page[pSIZE]存储页面号序列,memery[mSIZE]是存储装入物理块中的页面。
数组flag[10]标记页面的访问时间。
每当使用页面时,刷新访问时间。
发生缺页时,就从物理块中页面标记最小的一页,调出该页,换入所缺的页面。
五.流程图:如下页所示六.源代码:如下页所示【使用C语言】#include <stdio.h>#include <stdlib.h>/*全局变量*/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 main(){int i,k,code;system("color 0A");designBy();printf("┃请按任意键进行初始化操作... ┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");printf(" >>>");getch();system("cls");system("color 0B");printf("请输入物理块的个数(M<=10):");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100):");scanf("%d",&pSIZE);puts("请依次输入页面号引用串(连续输入,无需隔开):");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);download();system("cls");system("color 0E");do{puts("输入的页面号引用串为:");for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}}printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("* 请选择页面置换算法:\t\t\t *\n");printf("* ----------------------------------------- *\n");printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n");printf("* 3.最佳(OPT) 4.退出*\n");printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("请选择操作:[ ]\b\b");scanf("%d",&code);switch(code){case 1:FIFO();break;case 2:LRU();break;case 3:OPT();break;case 4:system("cls");system("color 0A");designBy(); /*显示设计者信息后退出*/printf("┃谢谢使用页面置换算法演示器! 正版授权㊣┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");exit(0);default:printf("输入错误,请重新输入:");}printf("按任意键重新选择置换算法:>>>");getch();system("cls");}while (code!=4);getch();}/*载入数据*/void download(){int i;system("color 0D");printf("╔════════════╗\n");printf("║正在载入数据,请稍候║\n");printf("╚════════════╝\n");printf("Loading...\n");printf(" O");for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++){mDelay((pSIZE+mSIZE)/2);printf(">");}printf("\nFinish.\n载入成功,按任意键进入置换算法选择界面:>>>");getch();}/*设置延迟*/void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}/*显示设计者信息*/void designBy(){printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("┃㊣课题三:页面置换算法㊣┃\n");printf("┃学号:081001117 ┃\n");printf("┃姓名:邢磊<Visual C++ 6.0>┃\n");printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"); }void print(unsigned int t){int i,j,k,l;int flag;for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}for(j=0;j<mSIZE;j++){for(i=20*k;(i<mSIZE+20*k)&&(i<pSIZE);i++){if(i>=j)printf(" |%d|",temp[i][j]);elseprintf(" | |");}for(i=mSIZE+20*k;(i<pSIZE)&&(i<20*(k+1));i++){for(flag=0,l=0;l<mSIZE;l++)if(temp[i][l]==temp[i-1][l])flag++;if(flag==mSIZE)/*页面在物理块中*/printf(" ");elseprintf(" |%d|",temp[i][j]);}/*每行显示20个*/if(i%20==0)continue;printf("\n");}}printf("----------------------------------------\n");printf("缺页次数:%d\t\t",t+mSIZE);printf("缺页率:%d/%d\n",t+mSIZE,pSIZE);printf("置换次数:%d\t\t",t);printf("访问命中率:%d%%\n",(pSIZE-(t+mSIZE))*100/pSIZE);printf("----------------------------------------\n");}/*计算过程延迟*/void compute(){int i;printf("正在进行相关计算,请稍候");for(i=1;i<20;i++){mDelay(15);if(i%4==0)printf("\b\b\b\b\b\b \b\b\b\b\b\b");elseprintf("Θ");}for(i=0;i++<30;printf("\b"));for(i=0;i++<30;printf(" "));for(i=0;i++<30;printf("\b"));}/*先进先出页面置换算法*/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];}else{for(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];}else {for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}七.运行结果:【运行环境——Visual C++ 6.0】1. 按任意键进行初始化:2. 载入数据:3. 进入置换算法选择界面:4.运算中延迟操作:5.三种算法演示结果:6.退出界面:八.参考文献:1. 严蔚敏, 吴伟民. 数据结构. 清华大学出版社, 2005.112. 谭浩强. C语言程序设计. 清华大学出版社, 2005.113. 于帆, 赵妮. 程序设计基础(C语言版). 清华大学出版社, 2006.114. 汤小丹, 梁红兵, 哲凤屏, 汤子瀛. 计算机操作系统. 西安电子科技大学出版社, 2007.5。