第7次 常用页面置换算法模拟实验
页面置换算法模拟实验报告材料
实验编号４名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计，以便：1、了解虚拟存储技术的特点2、掌握请求页式存储管理中页面置换算法实验内容与步骤设计一个虚拟存储区和内存工作区，并使用FIFO和LRU算法计算访问命中率。
<程序设计>先用srand()函数和rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算相应的命中率。
<程序1>#include <windows.h> //Windows版，随机函数需要，GetCurrentProcessId()需要//#include <stdlib.h>//Linux版，随机函数srand和rand需要#include <stdio.h> //printf()需要#define TRUE 1#define FALSE 0#define INV ALID -1#define NULL 0#define total_instruction 320 //共320条指令#define total_vp 32 //虚存页共32页#define clear_period 50 //访问次数清零周期typedef struct{//定义页表结构类型〔页面映射表PMT〕int pn, pfn, counter, time;//页号、页框号(块号)、一个周期内访问该页面的次数、访问时间}PMT;PMT pmt[32];typedef struct pfc_struct{//页面控制结构int pn, pfn;struct pfc_struct *next;}pfc_type;pfc_type pfc[32];pfc_type *freepf_head,*busypf_head,*busypf_tail;//空闲页头指针，忙页头指针，忙页尾指针int NoPageCount; //缺页次数int a[total_instruction];//指令流数组int page[total_instruction], offset[total_instruction];//每条指令的页和页内偏移void initialize( int );void FIFO( int );//先进先出void LRU( int );//最近最久未使用void NRU( int );//最近最不经常使用/****************************************************************************main()*****************************************************************************/ void main(){int i,s;//srand(10*getpid());//用进程号作为初始化随机数队列的种子//Linux版srand(10*GetCurrentProcessId());//用进程号作为初始化随机数的种子//Windows版s=rand()%320;//在[0，319]的指令地址之间随机选取一起点mfor(i=0;i<total_instruction;i+=4){//产生指令队列if(s<0||s>319){printf("when i==%d,error,s==%d\n",i,s);exit(0);}a[i]=s;//任意选一指令访问点m。
实验七 页面置换算法的模拟实现报告_川农
实验7页面置换算法的模拟实现三、实验内容与步骤1、定义相关数据#define InitPysiBlocks 4#define MaxPages 16：unsigned int PysicalBlocks[InitPysiBlocks] = { 0 };unsigned int PageSequence[30] = { 1,2,3,6,4,7,3,2,1,4,7,5,6,5,2,1};2、按照教材中FIFO、LRU算法描述进行算法设计unsigned FIFO(unsigned *py,unsigned *pg)unsigned LRU(unsigned *py,unsigned *pg)3、查看运行结果是否与手工计算一致。
四、实验材料的提交与成绩评定1.代码：#include<iostream>usingnamespace std;#define InitPysiBlocks 4#define MaxPages 16unsignedint PysicalBlocks[InitPysiBlocks] = { 0 };unsignedint PageSequence[30] = { 1,2,3,6,4,7,3,2,1,4,7,5,6,5,2,1 };//FIFO算法unsigned FIFO(unsigned *py, unsigned *pg){//初始化填满数据for (int i = 0; i <InitPysiBlocks; i++){py[i] = pg[i];}cout <<"FIFO置换过程如下："<< endl;cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;//判断新获取数据进来的时间int time[4] = { 3,2,1,0 };//开始检测for (int i = 4; i <MaxPages; i++){for (int j = 0; j <InitPysiBlocks; j++){//如果新获取的已存在，直接输出if (py[0] == pg[i] || py[1] == pg[i] || py[2] == pg[i] || py[3] == pg[i]){cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;break;}else{for (int k = 0; k < 4; k++){if (time[k] == 3){time[k] = 0;py[k] = pg[i];}else{time[k]++;}}cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;break;}}}cout <<"置换结束"<< endl;return 0;}//LRU算法//LRU辅助函数:返回除某一排下标后数组中最大元素下标int Max(unsigned *py, int te){int max = 0;int index = -1;for (int i = 0; i <InitPysiBlocks; i++){if (i == te){continue;}else{if (py[i] > max){max = py[i];index = i;}else{continue;}}}return index;}unsigned LRU(unsigned *py, unsigned *pg){//初始化填满数据for (int i = 0; i <InitPysiBlocks; i++){py[i] = pg[i];}cout <<"LRU置换过程如下："<< endl;cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;//判断新获取数据进来的时间unsigned time[4] = { 3,2,1,0 };//统计命中次数int count[4] = { 0 };//开始检测for (int i = InitPysiBlocks; i < 16; i++){for (int j = 0; j <InitPysiBlocks; j++){//如果新获取的已存在，直接输出,并将对应的命中变为1if (py[0] == pg[i] || py[1] == pg[i] || py[2] == pg[i] || py[3] == pg[i]){cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;if (py[0] == pg[i]){count[0] = 1;}elseif (py[1] == pg[i]){count[1] = 1;}elseif (py[2] == pg[i]){count[2] = 1;}elseif (py[3] == pg[i]){count[3] = 1;}else{count[4] = { 0 };}break;}else{if (count[0] == 1){//返回数组中最大值int temp = Max(time, 0);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[0] = 0;}elseif (count[1] == 1){//返回数组中最大值int temp = Max(time, 1);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[1] = 0;}elseif (count[2] == 1){//返回数组中最大值int temp = Max(time, 2);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[2] = 0;}elseif (count[3] == 1){//返回数组中最大值int temp = Max(time, 3);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;count[3] = 0;}else{//返回数组中最大值int temp = Max(time, -1);py[temp] = pg[i];for (int k = 0; k <InitPysiBlocks; k++){time[k]++;}time[temp] = 0;}cout <<py[0] <<" "<<py[1] <<" "<<py[2] <<" "<<py[3] << endl;break;}}}cout <<"置换结束"<< endl;return 0;}int main(){FIFO(PysicalBlocks, PageSequence);LRU(PysicalBlocks, PageSequence);return 0;}2.运行截图：运行结果与手工计算结果一致。
页面置换算法模拟实验报告
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算法
【精品】页面置换算法实验报告
【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现FIFO、LRU和Clock算法。
二、实验原理页面置换算法是操作系统中用到的一种算法，其作用是在内存不够用时，选择牺牲已经在内存中的一些页，腾出更多的空间给新的内容。
本次实验主要实现了FIFO、LRU和Clock算法。
1、FIFO算法FIFO算法是最简单的页面置换算法，它采用先进先出的原则，即最先进入内存的页面应该最早被替换出去。
该算法的实现非常简单，只需要维护一个队列即可。
当需要置换页面时，选择队列的第一个页面进行替换即可。
2、LRU算法LRU算法是Least Recently Used的缩写，即最近最少使用算法。
该算法的核心思想是选择最久没有被使用的页面进行替换。
为了实现该算法，需要维护记录页面使用时间的链表、栈或队列等结构。
3、Clock算法Clock算法也叫做二次机会算法，是一种改良的FIFO算法。
它是基于FIFO算法的思想，并且每个页面都设置了一个使用位（use bit），用于记录该页面是否被使用过。
当需要置换一个页面时，检查该页面的使用位，如果该页面的使用位为1，则将该页面的使用位设置为0并移到队列的末尾，表示该页面有“二次机会”继续待在内存中；如果该页面的使用位为0，则选择该页面进行替换。
三、实验过程本次实验采用Python语言实现页面置换算法，并使用样例进行测试。
1、FIFO算法实现FIFO算法的实现非常简单，只需要用一个队列来维护已经在内存中的页面，当需要置换页面时，选择队列的第一个元素即可。
代码如下：```pythonfrom collections import dequeclass FIFO:def __init__(self, frame_num):self.frame_num = frame_numself.frames = deque(maxlen=frame_num)def access(self, page):if page in self.frames:return Falseif len(self.frames) >= self.frame_num:self.frames.popleft()self.frames.append(page)return True```2、LRU算法实现LRU算法的实现需要维护一个记录页面使用时间的链表或队列。
页面置换算法
《操作系统原理》课程设计任务书题目：常用页面置换算法模拟实验学生姓名：学号：班级：计算机科学与技术（2）班题目类型：软件工程（R）指导教师：一、设计目的学生通过该题目的设计过程，可以初步掌握操作系统中有关文件系统的原理、软件开发方法并提高解决实际问题的能力。
二、设计任务设计一个虚拟存储区和内存工作区，并使用最佳淘汰算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）计算访问命中率。
（命中率=1-页面失效次数/页地址流长度）三、设计要求1、分析设计要求，给出解决方案（要说明设计实现所用的原理、采用的数据结构）。
2、设计合适的测试用例，对得到的运行结果要有分析。
3、设计中遇到的问题，设计的心得体会。
4、文档：课程设计打印文档每个学生一份，并装在统一的资料袋中，资料袋前面要贴有学校统一的资料袋封面。
5、光盘：每个学生文档和程序资料分别建在一个以自己学号和姓名命名的文件夹下，并要求每班负责人汇总每个学生的文件放在以班级名命名的文件夹下，刻录成5寸光盘，并复制四份（共五张内容相同的光盘），放在一个专门的资料袋中。
四、提交的成果1、设计任务书一本（学校统一格式）2、设计说明书一份，内容包括：1）中文摘要100字；关键词3-5个；2）设计思想；3）各模块的伪码算法；4）函数的调用关系图；5）测试结果；6）涉及总结；7）参考文献、致谢等。
五、各阶段时间安排（共2周）周次日期内容地点完成情况第1周星期一~二教师讲解课设要求查找参考资料教室2D302图书馆星期三~五检查总体及各模块流程图教室2D302第2周星期一~二检查源程序调试情况及文档排版教室2C417星期三~五检查程序，答辩教室2C417指导教师签字：______________日期：2011年12月30日摘要在地址映射过程中，若在页面中发现所要访问的页面不再内存中，则产生缺页中断。
当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。
《FIFO算法来模拟实现页面的置换》实验报告
struct pageInfor
{
int content;//页面号
int timer;//被访问标记
};
class PRA
{
public:
PRA(void);
int findSpace(void); //查找是否有空闲内存
int findExist(int curpage); //查找内存中是否有该页面
FIFO算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序连接成一个队列，并设置一个替换指针，使它总指向最老的页面。
pageInfor * page; //页面号串
private:
}
运行界面：
总结
在进程运行过程中，若其所访问的页面不存在内存而需要把它们调入内存，但内存已无空闲时，为了保证该进程能够正常运行，系统必须从内存中调出一页程序或数据送磁盘的对换区中。但应调出哪个页面，需根据一定的算法来确定，算法的好坏，直接影响到系统的性能。
int findReplace(void); //查找应予置换的页面
void display(void); //显示
void FIFO(void); //FIFO算法
void BlockClear(void);//BLOCK清空，以便用另一种方法重新演示
pageInfor * block; //物理块
《FIFO算法来模拟实现页面的置换》实验报告
实验
时间
2011年05月16日
实验人
虎胆英侠
专业
计算机
学号
实验
名称
FIFO算法来模拟实现页面的置换
目的
常用页面置换算法模拟实验
目录一、摘要 (3)二、正文 (4)三、设计总结 (8)四、参考文献 (10)五、附录：源程序代码 (11)摘要Windows中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺页中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页，为实现请求调页，核心配置了四种数据结构：页表、页框号、访问位、修改位、有效位、保护位等。
此设计为了了解Windows XP的操作接口及系统调用方式，熟悉Windows XP常用操作的实现过程，练习并掌握Visual C++开发环境。
利用Windows SDK（System Development Kit）提供的API（应用程序接口）设计一个虚拟存储管理程序，并使用最佳淘汰算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）计算访问命中率。
（命中率＝１－页面失效次数／页地址流长度）。
关键字Windows；请求调页；数据结构；存储管理正文一、设计思路页面置换算法：当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
此设计为了了解Windows XP的操作接口及系统调用方式，熟悉Windows XP常用操作的实现过程，练习并掌握Visual C++开发环境。
利用Windows SDK（System Development Kit）提供的API（应用程序接口）设计一个虚拟存储管理程序，并使用最佳淘汰算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）计算访问命中率。
页面置换算法实验报告
页面置换算法实验报告页面置换算法实验报告一、引言在计算机操作系统中，页面置换算法是一种重要的内存管理策略。
当物理内存不足以容纳所有需要运行的进程时，操作系统需要根据一定的算法将部分页面从内存中换出，以便为新的页面腾出空间。
本实验旨在通过实际操作，对比不同的页面置换算法在不同场景下的性能表现。
二、实验背景在计算机系统中，每个进程都有自己的虚拟内存空间，而物理内存空间是有限的。
当进程需要访问某个页面时，如果该页面不在物理内存中，就会发生缺页中断，操作系统需要根据页面置换算法选择一个页面将其换出，然后将需要访问的页面换入。
常见的页面置换算法有先进先出（FIFO）、最近最久未使用（LRU）、时钟（Clock）等。
三、实验目的本实验旨在通过模拟不同的页面置换算法，比较它们在不同情况下的缺页率和效率。
通过实验结果，评估各个算法在不同场景下的优劣，为实际系统的内存管理提供参考。
四、实验设计与方法本实验选择了三种常见的页面置换算法进行比较：FIFO、LRU和Clock。
我们使用C++编程语言模拟了一个简单的内存管理系统，并通过产生不同的访存序列来模拟不同的场景。
实验中，我们设置了不同的物理内存大小，访存序列长度和页面大小，以模拟不同的系统环境。
五、实验结果与分析在实验中，我们分别测试了FIFO、LRU和Clock算法在不同的系统环境下的表现。
通过统计不同算法的缺页率和运行时间，得出以下结论：1. FIFO算法FIFO算法是最简单的页面置换算法，它按照页面进入内存的顺序进行置换。
实验结果表明，FIFO算法在缺页率方面表现一般，特别是在访存序列具有局部性的情况下，其性能明显下降。
这是因为FIFO算法无法区分不同页面的重要性，可能会将经常使用的页面换出，导致缺页率升高。
2. LRU算法LRU算法是一种基于页面访问时间的置换算法，它认为最近被访问的页面很可能在未来会被再次访问。
实验结果表明，LRU算法在缺页率方面表现较好，特别是在访存序列具有较强的局部性时，其性能明显优于FIFO算法。
实验页面置换算法模拟实验ok
实验 5 页面置换算法模拟实验一．实验目地1.进一步掌握虚拟存储器地实现方法.2.掌握各种页面置换算法.3.比较各种页面置换算法地优缺点. 二．实验内容模拟实现页面置换算法, 步骤为：①使用产生随机数函数得到一个随机地数列, 作为将要载入地页面序列.②使用先进先出vFIFO)算法、最近最久未使用<LRU置换算法和最佳vOPT置换算法, 列出所需淘汰地页面号序列. b5E2RGbCAP③列出缺页中断次数. 三．参考源程序如下：#include vstdio.h> #include vstdlib.h> #include vtime.h> #define N 10 #define B 4/* ------------------------------------------------------ p1EanqFDPw函数名：IslnBuf(>,返回某个数X在不在缓冲Buf[],如在，返回位置，否则返回－1--- */ DXDiTa9E3dint IsInBuf(int buf[],int x>{int i,j=-1 。
for(i=0 o i<B。
i++>{ if(buf[i]==x>{ j=i 。
break 。
}else if(buf[i]==-1>{ buf[i]=x 。
j=i 。
break 。
} } return j 。
}/* ------------------------------------------------------ RTCrpUDGiT函数名：oldest(>, 返回最近最久未使用地页面位置--- */ 5PCzVD7HxAint oldest(int f[]>{int i,j=0,max=-1 。
for(i=0 。
ivB 。
i++>{ if(f[i]>max>{ max=f[i] 。
页面置换算法实验报告
页面置换算法实验报告背景页面置换算法是计算机操作系统中的一个重要概念，它用于解决操作系统需要共享有限的物理内存资源给多个进程使用的问题。
在操作系统中，每个进程都有自己的虚拟地址空间，但实际的物理内存资源是有限的。
当物理内存不足时，操作系统需要根据一定的策略将一部分进程暂时从内存中移出，以便为其他进程让出空间，而后再从外存中将其重新加载到内存中。
这个过程就是页面置换。
页面置换算法有很多种，比如最优页面置换算法（Optimal）、先进先出页面置换算法（FIFO）、最近最久未使用页面置换算法（LRU）等等。
不同的算法对于系统性能、响应时间等指标有着不同的影响，因此在实际应用中需要选择合适的算法来平衡各种需求。
本实验旨在通过模拟页面置换算法，并对不同算法进行性能分析，以便了解各种算法的优缺点，为实际系统的选择提供依据。
分析在实验中，我们选择了三种常用的页面置换算法，分别是FIFO、LRU和Optimal。
下面对这三种算法进行详细的分析和说明。
先进先出页面置换算法（FIFO）FIFO算法是最简单和最直观的页面置换算法。
它按照页面进入内存的顺序来选择被淘汰的页面。
当内存不足时，选择最早进入内存的页面进行置换，即将其从内存中移出。
FIFO算法不需要进行进一步的页面访问计算，只需要维护一个页面进入内存的队列即可，因此实现起来比较简单。
然而，由于FIFO算法没有考虑页面的访问频率和重要性，所以可能会导致被频繁访问的页面被淘汰出内存，从而影响系统的性能。
最近最久未使用页面置换算法（LRU）LRU算法是一种基于”最近使用原则”的页面置换算法。
它根据页面最近被访问的时间来选择被淘汰的页面。
当内存不足时，选择最长时间未被访问的页面进行置换，即将其从内存中移出。
LRU算法需要维护一个页面访问时间的记录，以便在需要置换时能够快速找到最近最久未使用的页面。
相比于FIFO算法，LRU算法更加合理地利用了页面的访问情况，但实现起来相对复杂一些。
页面置换算法实验报告
（3）优先数改变的原则：
进程在就绪队列中呆一个时间片，优先数增加1。
进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。
实验题目
进程调度算法程序设计
一、实验目的
通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。
二、设备与环境
1.硬件设备：PC机一台
2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java等编程语言环境。
int state;//进程状态
};
int i,n;//n--作业数
//输入函数
void input(struct pcb job[])
{
printf("请输入作业个数:");
scanf("%d",&n);
getchar();
for(i=0;i<n;i++)
{
printf("请输入第%d个作业：\n作业号，到达时间，服务时间\n",i+1);
华北科技学院计算机系综合性实验
实 验 报 告
课程名称操作系统A
实验学期2010至2011学年 第2学期
学生所在系部计算机系
年级2008专业班级信管B081班
学生姓名杨杭州学号************
任课教师杜杏菁
实验成绩
页面置换算法的模拟实现及命中率对比实验报告
页面置换算法的模拟实现及命中率对比实验报告一、问题描述课程设计目的（1）、通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储术的特点，掌握请求页式存储管理中的页面置换算法。
（2）、课程设计内容模拟实现OPT（最佳置换）、FIFO和LRU算法，并计算命中率。
（3）、课程设计要求：a)首先用随机数生成函数产生“指令”序列，然后将指令序列变换成相应的页地址流，再计算不同算法下的命中率。
b)通过随机数产生一个指令序列，共产生400条。
其中50%的指令是顺序执行的（灵位50%就是非顺序），且25%的指令分布在前半部分地址空间，25%的指令分布在后半部分地址空间。
c)将指令地址流变换成页地址流d)循环运行，使用户内存容量从4到40,。
计算每个内存容量下不同页面置换算法的命中率。
二、概要设计1.程序的数据结构：#define total_instruction 100 /*指令流长*/#define M 100 /*实际页数*/#define N 5 //可用页面数struct Pro{int num,time;};int a[total_instruction];int page[N];2.程序的主函数：int main(){Pro p[total_instruction];Pro *page=new Pro[N];char c;int t=0,i;float n=0;Input(p);do{for( i=0;i<N;i++)//初试化页面基本情况{page[i].num=-1;page[i].time=2-i;}printf("系统产生的随机数为：");for(int e=0;e<M;e++)cout<<p[e].num<<" ";cout<<endl;i=0;cout<<"f:FIFO页面置换"<<endl;cout<<"l:LRU页面置换"<<endl;cout<<"o:OPT页面置换"<<endl;cout<<"按其它键结束"<<endl;cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"页面置换情况: "<<endl;while( i< total_instruction){if(Search(p[i].num,page)>=0)i++;//找到相同的页面else{if(t==N)t=0;else{n++;//page[t].num=p[i].num;print(page);t++;}}}cout<<"缺页次数："<<n<<" 命中率："<<1-n/total_instruction<<endl; }if(c=='l')//LRU页面置换{n=0;cout<<"页面置换情况: "<<endl;while(i<total_instruction){int k;k=t=Search(p[i].num,page);if(t>=0)page[t].time=0;else{n++;t=Max(page);page[t].num=p[i].num;page[t].time=0;}for(int j=0;j<N;j++){if(j!=t)page[j].time++;}/*if(t==0){page[t+1].time++;page[t+2].time++;}if(t==1){page[2].time++;page[0].time++;}if(t==2){page[1].time++;page[0].time++;}*/if(k==-1) print(page);i++;}cout<<"缺页次数："<<n<<" 命中率："<<1-n/total_instruction<<endl; }if(c=='o')//OPT页面置换{n=0;while(i<total_instruction){if(Search(p[i].num,page)>=0)i++;else{if(page[N-1].num==-1){for(int g=0;g<N;g++)if(page[g].num==-1){page[g].num=p[i].num;i++;n++;print(page);break;}}else{int temp=-1,cn;for(t=0;t<N;t++){if(temp<Compfu(page,i,t,p)){temp=Compfu(page,i,t,p);cn=t;}}page[cn]=p[i];n++;print(page);i++;}}}cout<<"缺页次数："<<n<<" 命中率："<<1-n/total_instruction<<endl;}}while(c=='f'||c=='l'||c=='o');return 0;}三、详细设计程序代码如下：#include<stdlib.h>#include<iostream>#include<time.h>#include<stdio.h>using namespace std;#define total_instruction 100 /*指令流长*/#define M 100 /*实际页数*/#define N 5 //可用页面数struct Pro{int num,time;};int a[total_instruction];int page[N];void Input(Pro p[total_instruction]){int m,i,m1,m2;srand( (unsigned int )time(NULL));m=rand( )%400; //for(i=0;i<total_instruction;) /*产生指令队列*/{if(m<0||m>399){printf("When i==%d,Error,m==%d\n",i,m);exit(0);}a[i]=m; /*任选一指令访问点m*/ a[i+1]=a[i]+1;a[i+2]=a[i]+2; /*顺序执行两条指令*/int m1=rand( )%m; /*执行前地址指令m1 */a[i+3]=m1;a[i+4]=m1+1;a[i+5]=m1 + 2;/*顺序执行两条指令*/// s=(158-a[i+5])*rand( )/32767/32767/2+a[i+5]+2;m2 = rand()%(157-m1)+m1+3;a[i+6]=m2;if( (m2+2) > 159 ){a[i+7] = m2+1;i +=8;}else{a[i+7] = m2+1;a[i+8] = m2+2;i = i+9;}m = rand()%m2;}for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/ {p[i].num=a[i]/10;p[i].time = 0;}}void print(Pro *page1)//打印当前的页面{Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)printf("%-4d",page[i].num);//cout<<page[i].num<<" ";cout<<endl;//free(page);}int Search(int e,Pro *page1 ){Pro *page=new Pro[N];page=page1;for(int i=0;i<N;i++)if(e==page[i].num)return i;return -1;}int Max(Pro *page1){Pro *page=new Pro[N];page=page1;int e=page[0].time,i=0;while(i<N)//找出离现在时间最长的页面{if(e<page[i].time)e=page[i].time;i++;}for( i=0;i<N;i++)if(e==page[i].time)return i;return -1;}int Compfu(Pro *page1,int i,int t,Pro p[M]){Pro *page=new Pro[N];page=page1;int count=0;for(int j=i;j<M;j++){if(page[t].num==p[j].num )break;else count++;}return count;}int main(){Pro p[total_instruction];Pro *page=new Pro[N];char c;int t=0,i;float n=0;Input(p);do{for( i=0;i<N;i++)//初试化页面基本情况{page[i].num=-1;page[i].time=2-i;}printf("系统产生的随机数为：");for(int e=0;e<M;e++)cout<<p[e].num<<" ";cout<<endl;i=0;cout<<"f:FIFO页面置换"<<endl; cout<<"l:LRU页面置换"<<endl;cout<<"o:OPT页面置换"<<endl;cout<<"按其它键结束"<<endl; cin>>c;if(c=='f')//FIFO页面置换{n=0;cout<<"页面置换情况: "<<endl;while( i< total_instruction){if(Search(p[i].num,page)>=0)i++;//找到相同的页面else{if(t==N)t=0;else{n++;//page[t].num=p[i].num;print(page);t++;}}}cout<<"缺页次数："<<n<<" 命中率："<<1-n/total_instruction<<endl”}if(c=='l')//LRU页面置换{n=0;cout<<"页面置换情况: "<<endl;while(i<total_instruction){int k;k=t=Search(p[i].num,page);if(t>=0)page[t].time=0;else{n++;t=Max(page);page[t].num=p[i].num;page[t].time=0;}for(int j=0;j<N;j++){if(j!=t)page[j].time++;}/*if(t==0){page[t+1].time++;page[t+2].time++;}if(t==1){page[2].time++;page[0].time++;}if(t==2){page[1].time++;page[0].time++;}*/if(k==-1) print(page);i++;}cout<<"缺页次数："<<n<<" 命中率："<<1-n/total_instruction<<endl;}if(c=='o')//OPT页面置换{n=0;while(i<total_instruction){if(Search(p[i].num,page)>=0)i++;else{if(page[N-1].num==-1){for(int g=0;g<N;g++)if(page[g].num==-1){page[g].num=p[i].num;i++;n++;print(page);break;}}else{int temp=-1,cn;for(t=0;t<N;t++){if(temp<Compfu(page,i,t,p)){temp=Compfu(page,i,t,p);cn=t;}}page[cn]=p[i];n++;print(page);i++;}}}cout<<"缺页次数："<<n<<" 命中率："<<1-n/total_instruction<<endl; }}while(c=='f'||c=='l'||c=='o');return 0;}四、调试与分析程序的主界面：这里测试用的数据是M=40，N=5，三种算法置换结果如以下的图：FIFO算法：LRU算法：OPT算法：多运行几次，产生不同的随机数组，查看对比结果。
常用页面置换算法模拟实验
操作系统课程实验报告代码：#i nclude <stdio.h>#i nclude <stdlib.h>#include <string.h>#defi ne page_frame_ nu mber 4 // 页框数#defi ne virtual_page_ nu mber 8 // 虚拟页面数int page_id, counter= 0;// 输入id 和计数器char algorithm[20];〃算法选择int page_i nterrupt_ nu mber = 0;struct Page_table{int page_id; // 页号int load_time; // 装入时间int last_visit_time; // 最后访问时间}page_table[page_frame_ nu mber];int cmp(c onst void *p,c onst void *q){(*(struct int c = (*(struct Page_table*)p).load_time Pagetable*)q).load time;if(c > 0)return 1;elsereturn -1;}int cmp1(c onst void *p,c onst void *q){(*(struct int c = (*(struct Page_table*)p).last_visit_timePage_table*)q).last_visit_time;if(c > 0)return 1;elsereturn -1;}void in it(){// 初始化int i;for(i = 0; i < page_frame_number; i++){page_table[i].page_id = -1; page_table[i].load_time = -1;page_table[i].last_visit_time = -1;} }打印信息void prin t(i ntx){// int i,j;switch(x){ case0: for(i = 0; i < 80; i++)prin tf("-"); prin 试验七常用页面置换算法模拟头验\n");for(i = 0; i < 80; i++)prin tf("-");prin tf("\n");printf(" 选择算法：F/L (FIFO算法/LRU 算法)\n");break;case 1:printf(" 请输入访问页面的顺序,以“-1 ”结束：\n");break;case 2: printf(" 页表信息：\n页号页框号装入时间最近访问时间\n");for(j = 0; j < page_frame_ nu mber; j++){printf("%4d%8d%7d%7d\n",page_table[j].page_id,j,page_table[j].load_time,page_table[j].last_visit_time);};break;case 3:for(i = 0; i < 80; i++)prin tf("-");printf("\t\tFIFO 算法模拟过程\n"); for(i = 0; i < 80; i++)prin tf("-");prin tf("\n");break;case 4:for(i = 0; i < 80; i++)prin tf("-");printf("\t\tLRU 算法模拟过程\n");for(i = 0; i < 80; i++)prin tf("-");prin tf("\n");}}int judge(){int i;for(i = 0; i < page_frame_ nu mber;i++){ if(page_table[i].page_id == -1||page_table[i].page_idreturn i;}return -1;}void fifo(){int j;prin t(3);prin t(1);while(1){scan f("%d",&page_id);if(page_id == -1)break;j = judge();if(j == -1){qsort(page_table, page_frame_ nu mber,Page_table), cmp);// 按照最后访问时间从小到大排序page_table[O].page_id = page_id;page_table[0].load_time = coun ter;page_table[O].last_visit_time = coun ter;page_i nterrupt_ nu mber++;}else{if(page_table[j].page_id == -1){ page_table[j].page_id = page_id; page_table[j].load_time = coun ter;page_table[j].last_visit_time = coun ter; page_interrupt_ nu mber++;} 一一else{page_table[j].last_visit_time = coun ter;k==page_id)sizeof(struct评阅教师:日期:。
操作系统实验页面置换算法实验
淮海工学院计算机科学系实验报告书课程名：《操作系统原理》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求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%。
页面置换算法模拟 实验报告
int select;
PRA test;
while(select)
{
cin>>select;
switch(select)
{
case 0:
break;
case 1:
cout<<"LRU算法结果如下:"<<endl;
test.LRU();
test.BlockClear();
3、实验要求
编程实现页面置换算法，最少实现两种算法，比较算法的优劣，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。
（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；
（2）实现OPT算法(最优置换算法)、LRU算法(Least Recently)、FIFO算法(First IN First Out)的模拟；
}
}
int PRA::findSpace(void)
{
for(int i=0; i<Bsize; i++)
if(block[i].content == -1)
return i;//找到空闲内存，返回BLOCK中位置
return -1;
}
int PRA::findExist(int curpage)
{
for(int i=0; i<Bsize; i++)
{
block[i].content = -1;
block[i].timer = 0;
}
page = new pageInfor[Psize];
操作系统—页面置换算法实验报告
操作系统—页面置换算法实验报告本报告旨在介绍操作系统中的页面置换算法，包括实验的目的和背景以及页面置换算法的概念和作用。
本实验旨在描述实验环境以及所使用的页面置换算法，包括FIFO、LRU、OPT等。
同时，还会详细介绍实验步骤和设置的参数。
实验环境操作系统：Windows 10编程语言：C++开发环境：Visual。
2019页面置换算法FIFO（First-In-First-Out）算法：按照先进先出的原则置换页面，最早进入内存的页面会被置换出去。
LRU（Least Recently Used）算法：根据页面的使用情况，置换最长时间没有被访问过的页面。
OPT（Optimal）算法：理论上最优的页面置换算法，根据未来一段时间内页面的访问情况，选择最少使用的页面进行置换。
实验步骤创建一个模拟操作系统的C++程序。
设定内存大小、页面大小和页面数等参数。
实现FIFO算法，将其应用于模拟操作系统中的页面置换过程。
实现LRU算法，将其应用于页面置换过程。
实现OPT算法，将其应用于页面置换过程。
运行模拟程序，观察不同页面置换算法的效果。
分析比较不同算法的页面置换结果，评估其优缺点。
参数设置内存大小：512MB页面大小：4KB页面数：128以上是本次实验的实验设计，将通过创建模拟操作系统程序，实现FIFO、LRU和OPT等页面置换算法，并对其结果进行比较和评估。
本实验展示了页面置换算法的不同性能，并分析了各种算法的优缺点。
实验结果表明，不同的页面置换算法对系统性能有显著影响。
以下是对各种算法的性能分析：先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。
先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。
优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。
实验七 请求页式存储管理中常用页面置换算法模拟
实验七请求页式存储管理中常用页面置换算法模拟实验学时：4实验类型：设计实验要求：必修一、实验目的（1）了解内存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。
（5）了解页面大小和内存实际容量对命中率的影响。
二、实验内容（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；（2）实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟；（3）会使用某种编程语言。
三、实验原理分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。
在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。
但应将哪个页面调出，须根据一定的算法来确定。
通常，把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。
一个好的页面置换算法，应具有较低的页面更换频率。
从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。
1、最佳置换算法OPT(Optimal)它是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，便可以利用此算法来评价其它算法。
2、先进先出(FIFO)页面置换算法这是最早出现的置换算法。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
山东大学操作系统实验七
软件学院操作系统实验报告实验题目：实验七、内存页面置换算法实验学号：201100300124日期：2013年05月31日班级：5班姓名：韩俊晓Email：hanjunxiao188@实验目的：加深对于存储管理的了解，掌握虚拟存储器的实现原理；观察和了解重要的页面置换算法和置换过程。
练习模拟算法的编程技巧，锻炼分析试验数据的能力。
实验要求：请在以上示例实验程序中补充“增强二次机会”等置换算法的模拟程序。
输入不同的内存页面引用串和实存帧数，观察并分析其页面置换效果和性能，并将其与LRU和FIFO算法进行比较。
改进以上示例实验程序，使之能够随机的产生内存页面引用串，以便能动态的观测各种置换算法的性能。
硬件环境：实验室计算机软件环境：Ubuntu08.4－Linux操作系统BASH_VERSION='3.2.33(1)-releasegcc version 4.1.2gedit 2.18.2OpenOffice 2.3实验步骤：1.实验说明：1. 示例实验程序中模拟两种置换算法：LRU算法和FIFO算法2. 能对两种算法给定任意序列不同的页面引用串和任意帧实内存块数的组合测试，显示页置换的过程。
3. 能统计和报告不同置换算法情况下依次淘汰的页号、缺页次数（页错误数）和缺页率。
比较两种置换算法在给定条件下的优劣。
4. 为了能方便的扩充页面置换算法，更好的描述置换过程，示例实验程序采用了C++语言用Replace类描述了置换算法及其属性。
2.调试过程：1）建立程序，将代码写到程序中；2）再建立以下名为vmrp.h的C语言头文件：#include <iostream>#include <iomanip>#include <malloc.h>using namespace std;class Replace{public:Replace();~Replace();void InitSpace(char * MethodName); //初始化页号记录void Report(void); // 报告算法执行情况void Fifo(void); //先进先出算法void Lru(void); //最近最旧未用算法void Clock(void); //时钟(二次机会）置换算法void Eclock(void); //增强二次机会置换算法void Lfu(void); //最不经常使用置换算法void Mfu(void); //最经常使用置换算法private:int * ReferencePage ; //存放要访问到的页号int * EliminatePage ; //存放淘汰页号int * PageFrames ; //存放当前正在实存中的页号intPageNumber; //访问页数intFrameNumber; //实存帧数intFaultNumber; //失败页数int * Referencebit;//引用位int * count;int * Modifybit;//修改位};3）建立以下项目管理文件Makefilehead = vmrp.hsrcs = objs = vmrp.oopts = -w -g -call: vmrpvmrp: $(objs)g++ $(objs) -o vmrpvmrp.o: $(srcs) $(head)g++ $(opts) $(srcs)clean:rmvmrp *.o4)输入make命令编译连接生成可执行的vmrp程序$ g makeg++ -g -c vmrp.hg++ vmrp.o -o vmrp5)执行程序实验代码：#include "vmrp.h" Replace::Replace(){//设定总得访问页数,并分配相应的引用页号和淘汰页号记录数组空间cout<< "Please input page numbers :" ;cin>>PageNumber;//存放要访问到的页号ReferencePage = new int[sizeof(int) * PageNumber];//访问页数EliminatePage = new int[sizeof(int) * PageNumber];//存放淘汰页号cout<< "Please input reference page string :";for (i = 0; i <PageNumber; i++)cin>>ReferencePage[i];cout<< "Please input page frames :";cin>>FrameNumber;//实存帧数PageFrames = new int[sizeof(int) * FrameNumber];//存放当前正在实存中的页号Referencebit=new int[sizeof(int) * FrameNumber];//引用位count=new int[sizeof(int)*FrameNumber];Modifybit=new int[sizeof(int)*FrameNumber];//修改位}Replace::~Replace(){}void Replace::InitSpace(char * MethodName){cout<<endl<<MethodName<<endl;FaultNumber=0;//失败页数//引用还未开始,-1表示无引用页for (i = 0; i <PageNumber; i++)EliminatePage[i] = -1;//淘汰页号初始都设为-1for(i = 0; i <FrameNumber; i++){PageFrames[i] = -1;//存放当前正在实存中的页号Referencebit[i]=0;//未被使用引用位设置为0count[i]=0;//计数Modifybit[i]=0;//修改位初始为0}}//分析统计选择的算法对于当前输入的页面走向的性能void Replace::Report(void){//报告淘汰页顺序cout<<endl<< "Eliminate page:";for(int i=0; EliminatePage[i]!=-1; i++) cout<<EliminatePage[i] << " "; //报告缺页数和缺页率cout<<endl<< "Number of page faults = " <<FaultNumber<<endl; cout<<setw(6) <<setprecision(3) ;cout<< "Rate of page faults = " <<100*(float)FaultNumber/(float)PageNumber<< "%"<<endl;}//最近最旧未用置换算法void Replace::Lru(void){inti,j,k,l,next;InitSpace("LRU");//初始化页号记录//循环装入引用页for(k=0,l=0; k <PageNumber; k++){ //l为淘汰页的标记next=ReferencePage[k];//检测引用页当前是否已在实存for (i=0; i<FrameNumber; i++){if(next == PageFrames[i]){//与当前正在实存中的页号比较//引用页已在实存将其调整到页记录栈顶next= PageFrames[i];for(j=i;j>0;j--) PageFrames[j] = PageFrames[j-1];PageFrames[0]=next;break;}}if(PageFrames[0] == next){//如果引用页已放栈顶，则为不缺页，报告当前内存页号for(j=0; j<FrameNumber; j++)if(PageFrames[j]>=0) cout<<PageFrames[j] << " ";cout<<endl;continue; //继续装入下一页}else// 如果引用页还未放栈顶，则为缺页，缺页数加1 FaultNumber++;//栈底页号记入淘汰页数组中EliminatePage[l] = PageFrames[FrameNumber-1];//向下压栈for(j=FrameNumber-1;j>0;j--) PageFrames[j]= PageFrames[j-1]; PageFrames[0]=next; //引用页放栈顶//报告当前实存中页号for(j=0; j<FrameNumber; j++)if(PageFrames[j]>=0) cout<<PageFrames[j] << " ";//报告当前淘汰的页号if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}//分析统计选择的算法对于当前引用的页面走向的性能Report();}//先进先出置换算法void Replace::Fifo(void){inti,j,k,l,next;InitSpace("FIFO");//循环装入引用页for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];//如果引用页已在实存中，报告实存页号for (i=0; i<FrameNumber; i++) if(next==PageFrames[i]) break; if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;// 继续引用下一页}//引用页不在实存中，缺页数加1FaultNumber++;//最先入页号记入淘汰页数组EliminatePage[l]=PageFrames[j];PageFrames[j]=next;//引用页号放最先入页号处j = (j+1)%FrameNumber;//最先入页号循环下移//报告当前实存页号和淘汰页号for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " ";if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//时钟(二次机会）置换算法void Replace::Clock(void){intj,i,k,l,next;InitSpace("Clock");for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];for (i=0; i<FrameNumber; i++)//检测引用页当前是否已在实存if(next==PageFrames[i]){Referencebit[i]=1;//引用位设置为1break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;}if(Referencebit[j]==1){//如果引用位为1 Referencebit[j]==0;//在判断之后，重新设置成0}EliminatePage[l]=PageFrames[j];//最先入页号记入淘汰页数组PageFrames[j]=next; //引用页号放最先入页号处Referencebit[j]=1;//引用位设置为1FaultNumber++;//缺页数加1j=(j+1)%FrameNumber;//最先入页号循环下移for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " ";if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//增强二次机会置换算法void Replace::Eclock (void){intj,i,k,l,next;InitSpace("EClock");for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];//循环装入引用页for (i=0; i<FrameNumber; i++)//检测引用页当前是否已在实存if(next==PageFrames[i]){Referencebit[i]=1;//引用位设置为1count[i]++;//如果被引用了两次，就把修改位设置成1 if(count[i]%2==0)Modifybit[i]=0;//修改位设置为0elseModifybit[i]=1;break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;}if(Referencebit[j]==1){Referencebit[j]==0;}if(Modifybit[j]==1){Modifybit[j]=0;}int min=10*Referencebit[j]+Modifybit[j];int index=j;for(i=0;i<FrameNumber;i++){if(10*Referencebit[i]+Modifybit[i]<min){min=10*Referencebit[i]+Modifybit[i];index=i;}}EliminatePage[l]=PageFrames[index];PageFrames[index]=next;Referencebit[index]=0;Modifybit[index]=1;count[index]=0;FaultNumber++;//引用页不在实存中，缺页数加1j=(j+1)%FrameNumber;//最先入页号循环下移for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " ";if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//最不经常使用置换算法void Replace::Lfu(void){intj,i,k,l,next;InitSpace("Lfu");for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];for (i=0; i<FrameNumber; i++)if(next==PageFrames[i]){count[i]++;//记录使用次数break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " ";cout<<endl;continue;}FaultNumber++;int min=count[0];int index=0;for(i=0;i<FrameNumber;i++){if(count[i]<min){min=count[i];index=i;}}EliminatePage[l]= PageFrames[index];//最不经常使用的页号记入淘汰页数组PageFrames[index]=next;count[index]=1;for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " "; if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}//最经常使用置换算法void Replace::Mfu(void){intj,i,k,l,next;InitSpace("Mfu");for(i=0;i<FrameNumber;i++)count[i]=1;for(k=0,j=l=0; k <PageNumber; k++){next=ReferencePage[k];for (i=0; i<FrameNumber; i++)if(next==PageFrames[i]){count[i]++;break;}if (i<FrameNumber){for(i=0; i<FrameNumber; i++) cout<<PageFrames[i] << " "; cout<<endl;continue;}FaultNumber++;int max=count[0];int index=0;for(i=0;i<FrameNumber;i++){if(count[i]>max){max=count[i];index=i;}}EliminatePage[l]=PageFrames[index];PageFrames[index]=next;count[index]=0;for(i=0; i<FrameNumber; i++)if(PageFrames[i]>=0) cout<<PageFrames[i] << " "; if(EliminatePage[l]>=0)cout<< "->" <<EliminatePage[l++] <<endl;elsecout<<endl;}Report();}int main(intargc,char *argv[]){Replace * vmpr = new Replace();vmpr->Lru();vmpr->Fifo();vmpr->Clock();vmpr->Eclock();vmpr->Lfu();vmpr->Mfu();return 0;}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统课程实验报告断。
当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。
而用来选择淘汰哪一页的规则叫做页面置换算法。
最简单的页面置换算法是先入先出（FIFO）法。
2、算法流程图3、步骤说明（1）初始化void init(){//初始化int i;for (i = 0; i < page_frame_number; i++){page_table[i].page_id = -1;page_table[i].load_time = -1;page_table[i].last_visit_time = -1;}}（2）选择算法，输入插入页面号。
进入判断函数int judge(){//判断页框是否满，或者页框里面是否已存在页面int i;for (i = 0; i < page_frame_number; i++){if (page_table[i].page_id == -1 || page_table[i].page_id == page_id)return i;}return -2;}之后根据返回数的不同决定了不同类型返回-2则说明页框满且页框里面没有存在要插入的页面。
返回-1则说明页框未满返回其它数则说明页框里存在相同的页面（3）//当没有空页框，并且页面本身也没有存在，则执行一下代码qsort(page_table, page_frame_number, sizeof(struct Page_table), cmp);//按照装入时间从小到大排序page_table[0].page_id = page_id;page_table[0].load_time = counter;page_table[0].last_visit_time = counter;page_interrupt_number++;将页框号为0的页面置换成最新插入的页面。
int cmp(const void *p, const void *q){//按照装入时间从小到大排序int c = (*(struct Page_table*)p).load_time - (*(struct Page_table*)q).load_time;if (c > 0)return 1;elsereturn -1;}排序函数，将页面按装入时间从小到大排序（4）//如果页面未满，则将页面替换在空页框里if (page_table[j].page_id == -1){page_table[j].page_id = page_id;page_table[j].load_time = counter;page_table[j].last_visit_time = counter;page_interrupt_number++;则将页面替换在页框号最小的空页框里（5）//如果页面本身存在页框中，则执行一下代码page_table[j].last_visit_time = counter;则更新页面的最近访问时间（6）qsort(page_table, page_frame_number, sizeof(struct Page_table), cmp3);//按照装入时间从小到大排序print(2);打印出页表详细信息printf("页表信息：\n页号页框号装入时间最近访问时间\n");for (j = 0; j < page_frame_number; j++){printf("%4d%8d%7d%7d\n", page_table[j].page_id, j, page_table[j].load_time,page_table[j].last_visit_time);}; break;排序函数int cmp3(const void *p, const void *q){//按照装入时间从小到大排序,，并且不要排序没页面的部分if ((*(struct Page_table*)p).page_id != -1 && (*(struct Page_table*)q).page_id != -1){ int c = (*(struct Page_table*)p).load_time - (*(struct Page_table*)q).load_time;if (c > 0)return 1;elsereturn -1;}}（7）并计算出中断页面次数及命中概率，并打印页表出来int sum;sum = ((virtual_page_number - page_interrupt_number) * 100 / virtual_page_number);printf("缺页中断次数：%d\n", page_interrupt_number);printf("中断命中率：%d%%\n", sum);printf("打印出页面\n");for (int i = 0; i < page_frame_number; i++){for (int g = 1; g <= virtual_page_number; g++){printf("%4d", pr[i][g]);}printf("\n");}4、实现（1）选择FIFO算法（2）输入页面号，列出页表详细信息（3）输入-1，结束输入，显示统计结果及页表二、最近最少使用页面置换算法1、基本思想：在前面几条指令中使用频繁的页面很可能在后面的几条指令中频繁使用。
反过来说，已经很久没有使用的页面很可能在未来较长的一段时间内不会被用到。
这个，就是著名的局部性原理——比内存速度还要快的cache，也是基于同样的原理运行的。
因此，我们只需要在每次调换时，找到最近最久使用的那个页面调出内存。
2、算法流程图3、步骤说明：（1）初始化void init(){//初始化int i;for (i = 0; i < page_frame_number; i++){page_table[i].page_id = -1;page_table[i].load_time = -1;page_table[i].last_visit_time = -1;}}（2）选择算法，输入插入页面号。
进入判断函数int judge(){//判断页框是否满，或者页框里面是否已存在页面int i;for (i = 0; i < page_frame_number; i++){if (page_table[i].page_id == -1 || page_table[i].page_id == page_id) return i;}return -2;}之后根据返回数的不同决定了不同类型返回-2则说明页框满且页框里面没有存在要插入的页面。
返回-1则说明页框未满返回其它数则说明页框里存在相同的页面（3）//当没有空页框，并且页面本身也没有存在，则执行一下代码qsort(page_table, page_frame_number, sizeof(struct Page_table), cmp1);//按照最后访问时间从小到大排序page_table[0].page_id = page_id;page_table[0].load_time = counter;page_table[0].last_visit_time = counter;page_interrupt_number++;将页框号为0的页面置换成最新插入的页面。
int cmp1(const void *p, const void *q){//按照最后访问时间从小到大排序int c = (*(struct Page_table*)p).last_visit_time - (*(structPage_table*)q).last_visit_time;if (c > 0)return 1;elsereturn -1;}排序函数，将页面按最后访问时间从小到大排序（4）//如果页面未满，则将页面替换在空页框里if (page_table[j].page_id == -1){page_table[j].page_id = page_id;page_table[j].load_time = counter;page_table[j].last_visit_time = counter;page_interrupt_number++;则将页面替换在页框号最小的空页框里（5）//如果页面本身存在页框中，则执行一下代码page_table[j].last_visit_time = counter;则更新页面的最近访问时间（6）qsort(page_table, page_frame_number, sizeof(struct Page_table), cmp2);//按照最后访问时间从小到大排序print(2);打印出页表详细信息printf("页表信息：\n页号页框号装入时间最近访问时间\n");for (j = 0; j < page_frame_number; j++){printf("%4d%8d%7d%7d\n", page_table[j].page_id, j, page_table[j].load_time, page_table[j].last_visit_time);}; break;排序函数int cmp2(const void *p, const void *q){//按照最后访问时间从小到大排序,，并且不要排序没页面的部分if ((*(struct Page_table*)p).page_id != -1 && (*(struct Page_table*)q).page_id != -1){ int c = (*(struct Page_table*)p).last_visit_time - (*(structPage_table*)q).last_visit_time;if (c > 0)return 1;elsereturn -1;}}（7）并计算出中断页面次数及命中概率，并打印页表出来int sum;sum = ((virtual_page_number - page_interrupt_number) * 100 / virtual_page_number);printf("缺页中断次数：%d\n", page_interrupt_number);printf("中断命中率：%d%%\n", sum);printf("打印出页面\n");for (int i = 0; i < page_frame_number; i++){for (int g = 1; g <= virtual_page_number; g++){printf("%4d", pr[i][g]);}printf("\n");}4、实现（1）选择LRU算法（2）输入页面号，并打印出详细页表（3）输入-1，结束输入，显示统计结果及页表三、代码// ConsoleApplication2.cpp : 定义控制台应用程序的入口点。