实验六请求分页系统页面置换算法

合集下载

实验六页面置换

实验六页面置换算法模拟一、实验目的（1）了解内存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。

（5）了解页面大小和内存实际容量对命中率的影响。

二、实验预备知识分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。

在进程运行过程中，若其所要访问的页面不在内存而需把它们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区中。

但应将哪个页面调出，须根据一定的算法来确定。

通常，把选择换出页面的算法称为页面置换算法(Page_Replacement Algorithms)。

一个好的页面置换算法，应具有较低的页面更换频率。

从理论上讲，应将那些以后不再会访问的页面换出，或将那些在较长时间内不会再访问的页面调出。

1、最佳置换算法OPT(Optimal)它是由Belady于1966年提出的一种理论上的算法。

其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。

采用最佳置换算法，通常可保证获得最低的缺页率。

但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，便可以利用此算法来评价其它算法。

2、先进先出(FIFO)页面置换算法这是最早出现的置换算法。

该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

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

3、最近最久未使用置换算法1) LRU(Least Recently Used)置换算法的描述FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。

最近最久未使用（LRU）置换算法，是根据页面调入内存后的使用情况进行决策的。

页面置换算法PPT课件

第24页/共36页
练习
在一个请求分页系统中，假定系统分配给一个进程的内存块数为3，进程的页面走向为2，3，2，1，5，2，4，5，3， 2，5，2。试用最近最久未使用置换算法（LRU），请画图表示访问过程中发生的页面置换过程，并计算缺页次数。（假定开始时，物理块为空，每次调入页面都作为一次缺页处理）
第5页/共36页
4.6.3
1. 何时调入页面
第6页/共36页
2. 从何处调入页面在请求分页系统中的外存分为两部分：用于存放文件的
文件区和用于存放对换页面的对换区。通常，由于对换区是采用连续分配方式，而事件是采用离散分配方式，故对换区的磁盘I/O速度比文件区的高。这样，每当发生缺页请求时，系统应从何处将缺页调入内存，
第11页/共36页
4.7.1
1. 最佳(Optimal) Belady于1966年提出的一种理论上的算法，思想是选择的被淘汰页面以后将永不使用，或者在最长（未来）时间内不再被访问。
第12页/共36页
假定系统为某进程分配了三个物理块，并考虑有以下
7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1
第25页/共36页
4.7.3 Clock置换算法
1. 简单的Clock置换算法 Clock置换算法是LRU算法的近似算法，也称为最近未用算法。在简单的Clock算法中，为每页设置一访问位，当被访问则设置为1，未访问为0。
第26页/共36页
1. 简单的Clock置换算法
入口
查寻指针前进一步，指向下一个表目
进程运行时，先将7，0，1三个页面装入内存。以后，当进程要访问页面2时，将会产生缺页中断。此时OS根据最佳置换算法，将选择页面7予以淘汰。

【精品】页面置换算法实验报告

【精品】页面置换算法实验报告一、实验目的了解操作系统中的页面置换算法，并实现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算法的实现需要维护一个记录页面使用时间的链表或队列。

页面置换算法实验(内含完整代码)

实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。

二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。

1、最佳淘汰算法（OPT）2、先进先出的算法（FIFO）3、最近最久未使用算法（LRU）4、简单时钟(钟表)算法（CLOCK）命中率＝１－页面失效次数／页地址流(序列)长度三、实验原理简述UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。

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

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

为实现请求调页，核心配置了四种数据结构：页表、页帧（框）号、访问位、修改位、有效位、保护位等。

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

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

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

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

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

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

四、算法描述本实验的程序设计基本上按照实验内容进行。

即使用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。

（1）通过随机数产生一个指令序列，共320条指令。

指令的地址按下述原则生成：A：50%的指令是顺序执行的B：25%的指令是均匀分布在前地址部分C：25%的指令是均匀分布在后地址部分具体的实施方法是：A：在[0，319]的指令地址之间随机选取一起点mB：顺序执行一条指令，即执行地址为m+1的指令C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’D：顺序执行一条指令，其地址为m’+1E：在后地址[m’+2，319]中随机选取一条指令并执行F：重复步骤A-E，直到320次指令（2）将指令序列变换为页地址流设：页面大小为1K；用户内存（页帧）容量为4页~32页；用户虚存容量为32K。

实验请求页式存储管理页面置换算法

操作系统实验报告班级:计科0801班姓名：韩伟伟学号：08407106 时间：2018-5-25实验五请求页式存储管理的页面置换算法一．实验目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。

二．实验属性设计三．实验内容1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。

2.将指令序列变换成为页地址流设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。

在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条至第9条指令为第0页；第10条至19条指令为第1页；…第310条至319条指令为第31页。

3.计算并输出下述各种算法在不同内存容量下的命中率。

(1>先进先出算法<FIFO）(2>最近最少使用算法<LRU）(3>最佳使用算<OPT）命中率＝１－页面失效次数／页地址流长度本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。

四．思路关于随机数的产生办法。

首先要初始化设置随机数，产生序列的开始点，例如，通过下列语句实现：srand ( 400 > ；(1>计算随机数，产生320条指令序列m＝160；for (i＝0；i＜80；i++＝{j＝i﹡4；a[j]＝m；a[j+1]＝m+1；a[j+2]＝a[j] ﹡1.0﹡ rand( >/32767；a[j+3]＝a[j+2]+1m＝a[j+3]+(319-a[j+3]> ﹡1.0﹡rand( >/32767；}(2>将指令序列变换成为页地址流for ( k＝0；k＜320；k++>{ pt＝a[k]/10；pd= a[k]%10；…}(3>计算不同算法的命中率rate＝1-1.0﹡U/320 ；其中U为缺页中断次数，320是页地址流长度。

请求页式管理的页面置换算法

实验报告课程：操作系统班级：成绩：指导教师：实验密级：预习程度：仪器组次：必修/选修：姓名：学号：实验日期：实验时间：实验序号：实验名称：访问实验二请求页式管理中的置换算法实验目的与要求：１．采用FIFO〔先进先出〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。

２．采用LFU〔最不经常使用〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。

实验仪器：名称型号数量微机1一、实验内容１．假设有一个用户进程P的地址空间为n〔n=60〕页，系统已在内存中给该进程分配有m〔m<n，m=8〕个页面，且该进程的第0、5、6页〔p0、p5、p6〕已经装入内存，页长为1K。

根据进程访问的字地址序列，采用不同的置换算法，分别计算缺页中断率。

２．进程依次要访问的字地址序列〔访问串〕，在0~1024*n-1〔0~61439〕中模拟随机发生，访问序列的随机生成规那么为：50%的字地址前向顺序增长，25%的字地址均匀分布在前地址〔低地址〕局部，25%的字地址均匀分布在后地址〔高地址〕局部，为了减少模拟次数，前向顺序递增产生的字地址如小于1024*n-51360927〕那么自动加512。

模拟访问串长度为100。

以n=60为例，字地址序列〔访问串〕的随机生成方法如下：〔1〕在[0，61439]之间随机产生起始字地址，当前访问的字地址记为k；〔2〕前向顺序递增产生的字地址为 k+1+512；〔3〕前地址〔低地址〕在[0，k-1]内随机产生；〔4〕后地址〔高地址〕在[k+1，61439]内随机产生；〔5〕重复顺序递增、前地址区间随机产生、后地址区间随机产生的过程，概率分别为：50%、25%、25%。

二、实验要求１．采用FIFO〔先进先出〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。

２．采用LFU〔最不经常使用〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。

操作系统请求分页式存储管理页面置换算法课程设计报告

操作系统程序设计课程设计报告课题: 请求分页式存储管理页面置换算法姓名：学号：同组姓名：专业班级：指导教师：设计时间：目录1. 系统描述 (3)2. 分析与设计 (3)2.1.系统功能模块图 (3)2.2.系统文件结构描述 (3)2.3.系统功能流程图 (4)2.4．UI设计以及操作说明： (4)2.5.测试数据及期望 (11)3.系统测试 (12)4.总结心得体会 (12)5.参考文献 (13)6.核心代码 (13)1. 系统描述系统使用.net framework 4.0开发的，图形用户界面使用winform程序设计，功能模块分别实现了请求分页式存储管理的LRU算法，FIFO 算法。

通过虚拟系统存储的概念和实现方法，进行运行的时候不需要把所有页面都装入内存中，只需要将部分页面调入内存，就可以运行。

在运行过程中，若要访问的页面不在内存中，则需用请求调入的功能将其装入内存中，如果此时内存中没有空白的物理块，就通过页面置换功能淘汰一个页面，根据LRU,FIFO两种淘汰算法来进行页面置换，并能计算出FIFO，LRU两种算法在不同内存容量中的的命中率。

系统运行时通过输入访问内存的顺序，以及分配的内存页面数，来进行二种算法的页面置换，实现了虚拟存储的功能和特点。

2. 分析与设计2.1.系统功能模块图图4.1 页式存储管理模块划分2.2.系统文件结构描述2.3.系统功能流程图开始还有指令？计算页号找到了吗？新页进入计算过程数组第一位，其余为一次下移计算命中率结束YNNY FIFO开始还有指令？计算页号找到了吗？比较现有页面计数项的大小，新页面替换最大项页面计算命中率结束YNNY LRU2.4．UI 设计以及操作说明：主窗体：#region访问顺序private void btnSure_Click(object sender, EventArgs e){if (txtOrder.Text.Equals("")){MessageBox.Show("访问顺序字符串不能为空！！！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);return;}order = txtOrder.Text;listBox1.Items.Clear();string[] page = order.Split(' ');foreach (string pg in page){listBox1.Items.Add(pg);}txtOrder.Text = "";allocation alca = new allocation();this.Hide();DialogResult d = alca.ShowDialog();if (d == DialogResult.OK){this.Show();btnAlloc.Enabled = true;btnFifo.Enabled = true;btnlru.Enabled = true;alpage = alca.page;}}#endregion输入访问内存顺序，点击确定：#region确定内存页分配private void button1_Click(object sender, EventArgs e){if (textBox1.Text.Equals("")){MessageBox.Show("内存页面数不能为空！！！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);return;}page = Convert.ToInt32(textBox1.Text.Trim());this.Close();}#endregion输入分配内存页面数，点击确定：点击FIFO置换：FIFO 算法：淘汰最先进入的页面，也就是淘汰进入内存中驻留时间最长的页面，先进先出。

实验六请求分页存储管理

实验六：请求分页存储管理一．实验目的深入理解请求页式存储管理的基本概念和实现方法，重点认识其中的地址变换、缺页中断、置换算法等实现思想。

二．实验属性该实验为综合性、设计性实验。

三．实验仪器设备及器材普通PC386以上微机四．实验要求本实验要求2学时完成。

本实验要求完成如下任务：（1）建立相关的数据结构：页表、页表寄存器、存储块表等；（2）指定分配给进程的内存物理块数，设定进程的页面访问顺序；（3）设计页面置换算法，可以选择OPT、FIFO、LRU等，并计算相应的缺页率，以比较它们的优劣；（4）编写地址转换函数，实现通过查找页表完成逻辑地址到物理地址的转换；若发生缺页则选择某种置换算法（OPT、FIFO、LRU等）完成页面的交换；（5）将整个过程可视化显示出来。

实验前应复习实验中所涉及的理论知识和算法，针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。

实验后认真书写符合规范格式的实验报告（参见附录A），并要求用正规的实验报告纸和封面装订整齐，按时上交。

三、设计过程3.1算法原理分析OPT算法是未来最远出现，当当前内存中没有正要访问的页面时，置换出当前页面中在未来的访问页中最远出现的页面或再也不出现的页面。

FIFO算法是先进先出，当当前内存中没有正要访问的页面时，置换出最先进来的页面。

LRU算法是最近最久未使用，当当前内存中没有正要访问的页面时，置换出在当前页面中最近最久没有使用的页面。

3.2数据定义int length,num_page,count,seed; //length记录访问串的长度，num_page页面数，count记录缺页次数int result[20][30],order[30],a[10]; //result记录结果,order存储访问串,a存储当前页面中的值int pos1,flag1,flag2,flag3; //pos1位置变量，flag1等为标志变量 char result1[30]; //记录缺页数组 void opt() //最佳void fifo() //先进先出bool search(int n) //查找当前内存中是否已存在该页3.3流程图与运行截图图6.1 FIFO （）函数流程图;否是是否开始得到执行的指令指令是否在内存中最先存入指令被淘汰下面是否还有指令结束得出命中率图2.2 OPT算法流程图四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。

操作系统实验报告6-页面置换算法模拟综述

}BlockNode;
struct{
intlength;//当獭?前°物?理え?块é长¤度è
intmiss_flag;//缺ā?页?标括?志?，?若?为a1，?则ò缺ā?页?
intmiss_count;//缺ā?页?次?数簓
BlockNode*front;
BlockNode*rear;
}Block;
if(!Block.front){
printf("内ú存?分?配?失骸?败悒?\n");
exit(0);
}
Block.length=0;
Block.miss_count=0;
Block.rear->next=NULL;
}
voidenqueue(intpage_index)//入?队ó
{
BlockNode*node=(BlockNode*)malloc(sizeof(BlockNode));
if((i+1)%5== 0){
printf("\n");
}//if
}
printf("\n");
}
voidFIFO_Replace(intpage_index)//FIFO置?换?
{
BlockNode*node;
if(!Block.length){
enqueue(page_index);
Block.miss_flag=0;
if(num>=down&& num<=up)
break;
printf("输?入?范?围§有瓺误ó,请?重?新?输?入?:");
}//while
returnnum;

页面置换算法的实验报告.

操作系统课程设计报告院（系）：衡阳师范学院专业：计算机科学与技术姓名:陈建元齐欢班级：＿1103班＿学号:******** ********题目：页面置换算法****:***2013年12月10日至12月28日目录摘要 (3)第一章设计任务和需求 (4)1.1课程设计任务 (4)1.2课程设计需求 (4)第二章概要设计 (4)2.1系统分析 (4)2.2调页策略 (5)2.2.1何时调入页面 (5)2.2.2请求调页策略 (5)2.2.3从何处调入页面 (5)2.3模块设计 (6)第三章详细设计 (6)3.1系统设计 (6)3.2算法思想及流程图 (7)3.2.1 主程序流程图 (7)3.2.2先进先出(FIFO)页面置换算法 (8)3.2.3最佳页面置换置换算法（OPT） (9)3.2.4最近最久未使用页面置换算法（LRU） (10)第四章源程序结构分析 (10)4.1程序结构 (10)4.2 源代码分析 (11)第五章调试 (16)第六章体会与自我评价 (17)第七章参考文献 (18)摘要操作系统（英语；Operating System，简称OS）是一管理电脑硬件与软件资源的程序，同时也是计算机系统的内核与基石。

操作系统身负诸如管理与配置内存、决定系统资源供需的优先次序、控制输入与输出设备、操作网络与管理文件系统等基本事务。

操作系统是管理计算机系统的全部硬件资源包括软件资源及数据资源;控制程序运行;改善人机界面;为其它应用软件提供支持等，使计算机系统所有资源最大限度地发挥作用，为用户提供方便的、有效的、友善的服务界面。

操作系统是一个庞大的管理控制程序，大致包括5个方面的管理功能:进程与处理机管理、作业管理、存储管理、设备管理、文件管理。

在地址映射过程中，若在页面中发现所要访问的页面不再内存中，则产生缺页中断。

当发生缺页中断时操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。

请求页式存储管理中常用页面置换算法模拟

记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时候选择现有页面中其时间值最大的进行淘汰。最佳置换算法的替换规则：其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。先进先出(FIFO)页面置换算法的替换规则：该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。三种替换算法的命中率由高到底排列OPT>LRU>FIFO。本次的程序是在网上查找的相关代码然后自己进行修改，先自己仔细地研读了这段代码，在这过程中我对C++代码编写有了更深的了解。总之，本次实验使我明白要学会把课堂上的理论应用到实际操作中。我需要在今后熟练掌握课堂上的理论基础，只有坚实的基础，才能在实际操作中更得心应手。附录： #include "iostream.h" #include <iomanip.h> const int DataMax=100; const int BlockNum = 10; int DataShow[BlockNum][DataMax]; // 用于存储要显示的数组 bool DataShowEnable[BlockNum][DataMax]; // 用于存储数组中的数据是否需要显示 int Data[DataMax]; // 保存数据 int Block[BlockNum]; // 物理块 int count[BlockNum]; // 计数器 int N ; // 页面个数 int M;//最小物理块数 int ChangeTimes; void DataInput(); // 输入数据的函数 void DataOutput(); void LRU(); // LRU函数 ///* int main(int argc, char* argv[]) { DataInput();// DataInput();

操作系统页面置换算法实验报告

学生实验报告姓名：年级专业班级学号成绩【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见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 年月日【备注】。

页面置换算法实验

页面置换算法实验报告一、实验目的：设计和实现最佳置换算法、随机置换算法、先进先出置换算法、最近最久未使用置换算法、简单Clock置换算法及改进型Clock置换算法；通过支持页面访问序列随机发生实现有关算法的测试及性能比较。

二、实验容：●虚拟存页面总数为N，页号从0到N-1●物理存由M个物理块组成●页面访问序列串是一个整数序列，整数的取值围为0到N - 1。

页面访问序列串中的每个元素p表示对页面p的一次访问●页表用整数数组或结构数组来表示❑符合局部访问特性的随机生成算法1.确定虚拟存的尺寸N，工作集的起始位置p，工作集中包含的页数e，工作集移动率m（每处理m个页面访问则将起始位置p +1），以及一个围在0和1之间的值t；2.生成m个取值围在p和p + e间的随机数，并记录到页面访问序列串中；3.生成一个随机数r，0 ≤r ≤1；4.如果r < t，则为p生成一个新值，否则p = (p + 1) mod N；5.如果想继续加大页面访问序列串的长度，请返回第2步，否则结束。

三、实验环境：操作系统：Windows 7软件：VC++6.0四、实验设计：本实验包含六种算法，基本容相差不太，在实现方面并没有用统一的数据结构实现，而是根据不同算法的特点用不同的数据结构来实现：1、最佳置换和随机置换所需操作不多，用整数数组模拟存实现；2、先进先出置换和最近最久未使用置换具有队列的特性，故用队列模拟存来实现；3、CLOCK置换和改进的CLOCK置换具有循环队列的特性，故用循环队列模拟存实现；4、所有算法都是采用整数数组来模拟页面访问序列。

五、数据结构设计：//页面访问序列数组：int ref[ref_size];//存数组：int phy[phy_size];//队列数据结构定义：typedef struct QNode //定义队列数据结构{int data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front; //头指针QueuePtr rear; //尾指针}LinkQueue;//定义链表数据结构typedef struct LNode //定义循环链表数据结构{int data;int flag; //访问位int modify; //修改位struct LNode *next;}LNode,*LinkList;六、主要函数说明：1、void set_rand_num() //产生具有局部特性的随机数列；2、int Exchange_LNode(LinkList &L,int e,int i)//将链表L中序号为i的结点替换为容为e的结点；3、bool Search_LinkList(LinkList &L,int e,int &i)//找到链表L中容为e的结点，并用i返回其位置，i=1表示第一个非头结点，依次类推；4、void Search_LL_Flag(LinkList &L,int &i)//用i返回第一个flag为0的结点的位置,i=1表示第一个非头结点，以此类推；5、void Set_LL_Flag(LinkList &L,int i) //设置链表L中的序号为i的结点的flag标志为1；6、int Search_LL_ModifyClock(LinkList &L,int &modify_num)//找到改进的CLOCK算法所需要淘汰的页，用modify_num返回其位置；此函数根据书上给的思路，第一遍扫描A=0且M=0的页面予以淘汰，若失败，则进行第二轮扫描A=0且M=1的页面，第二轮扫描时将所有访问过的页面的访问位A置0；若失败则重复上述两部；7、void Set_LL_modify(LinkList &L,int i) //设置链表L中的序号为i的结点的modify标志为1；8、bool SearchQueue(LinkQueue &Q,int e,int &i) //寻找队列Q中结点data域等于e的结点，并用i返回其在Q中的位置；9、int getnum(int a,int b) //用b返回元素a在被引用数列中的下一个位置10、void ORA() //实现最佳置换算法，包括判断页面是否在存中、页面进存、输出存状态等容；11、void RAND() //随机置换算法12、void FIFO() //先进先出算法13、void LRU() //最近最久未使用算法实现最近最久未使用算法的思想是：判断待进入存的页面，如果与存中的第一个页面相同，则将它移到最后一个，即标志为最近使用的页；如果与存中的第二个页面相同，则将它删除，并在队列尾部添加相同元素，即标志为最近使用的页；14、void CLOCK() //实现CLOCK算法15、void Modified_Clock() //实现改进的CLOCK算法16、int main() //主函数，调用实现各算法的6个主要函数，并输出各算法的缺页率。

页面置换算法实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

页面置换算法实验报告

操作系统课程设计报告课程名称：操作系统课程设计课程设计题目：页面置换算法学院：计算机科学与技术学院专业：科技小组成员: 庞思慧E01114081王蒙E01114161姚慧乔E01114349朱潮潮E01114408指导老师：***目录1 实验目的 (3)2 实验要求 (3)3 实验内容与步骤 (3)4 算法思想 (4)5 模块设计 (4)6 程序设计 (5)7 测试结果 (7)8 结果分析 (9)9 程序代码 (9)10 课程设计小结 (24)页面置换算法模拟设计1.实验目的（1）通过模拟实现几种基本页面置换的算法，了解虚拟存储技术的特点。

（2）掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想，并至少用三种算法来模拟实现。

（3）通过对几种置换算法命中率的比较，来对比他们的优缺点。

2.实验要求计算并输出下述各种算法在不同内存容量下的命中率。

A 先进先出的算法（FIFO）B 最近最少使用算法（LRU）C最佳淘汰算法（OPT）3.实验内容与步骤(1)通过随机数产生一个指令序列，共320条指令，具体的实施方法是：A．[0，319]的指令地址之间随机选取一起点M;B．顺序执行一条指令，即执行地址为M+1的指令；C．在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’;D．顺序执行一条指令，其地址为M’+1；E．在后地址[M’+2，319]中随机选取一条指令并执行；F．重复A—E，直到执行320次指令。

(2)指令序列变换成页地址流A.页面大小为1K；B.用户内存容量为4页到32页；C.用户虚存容量为32K。

在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条—第9条指令为第0页（对应虚存地址为[0，9]）；第10条—第19条指令为第1页（对应虚存地址为[10，19]）；。

第310条—第319条指令为第31页（对应虚存地址为[310，319]）；(3)计算并输出上述各种算法在不同内存容量下的命中率。

实验六请求分页系统页面置换算法

实验六请求分页系统页面置换算法实验目的：实现分页式存储地址转换过程，在此基础上实现请求分页的地址转换。

实现请求分页式地址转换中出现的缺页现象中，用到的FIFO、LRU、OPT置换算法。

实现方法：用一张位示图，来模拟内存的分配情况，利用随机数产生一组0和1的数对应内存的使用情况。

利用结构体数组将页表和内存块封装。

实现过程：[cpp] view plaincopy01.#include<stdio.h>02.#include<stdlib.h>03.#include<iostream.h>04.#include<time.h>05.struct Page06.{07. int kuai;08. int stage;09.}FPage[1000],LPage[1000];10.11.struct Memory12.{13. int num;14. int page;15.}FMemory[1000],LMemory[1000],OMemory[1000];16.17.int PageLength; /*页表长度*/18.int Memsize; /*内存块数*/19.int FAbsent,LAbsent,OAbsent,visit; /*FIFO中的缺页次数LRU中的缺页次数访问内存次数*/20.int Logical; /*逻辑地址*/21.int Pagenumber,Pageaddr;/*页号页内地址*/22.int Physical; /*物理地址*/23.int PageSize; /*块的大小*/24.int Freemem; /*空闲内存*/25.26.int G[8][8];27.28.int opt[10000]; int oth=0;29.int temp[1000];30.31.void GShow()32.{33. int i,j;34. printf("位式图：\n");35. for(i=0;i<8;i++)36. {37. printf("\t");38. for(j=0;j<8;j++)39. printf("%d ",G[i][j]);40. printf("\n");41. }42.}43.44.45.void init() /*初始化*/46.{47. srand((unsigned)time(NULL));48. int i,j;49. for(i=0;i<8;i++)50. G[0][i]=1;51. for(i=1;i<8;i++)52. {53. for(j=0;j<8;j++)54. G[i][j]=rand()%2;55. }56.57. for(i=0;i<PageLength;i++)58. {59. FPage[i].kuai=-1; FPage[i].stage=0;60. LPage[i].kuai=-1; LPage[i].stage=0;61. }62. for(i=0;i<Memsize;i++)63. {64. FMemory[i].page=-1;65. }66. for(i=0;i<Memsize;i++)67. {68. LMemory[i].page=-1;69. }70. for(i=0;i<Memsize;i++)71. {72. OMemory[i].num=i;73. OMemory[i].page=-1;74. }75.76. FAbsent=LAbsent=visit=0;77.}78.79.80.void Show()81.{82. int i;83.84. printf("FPage：\t\t\t\t\tLPage:\n");85. printf("\t页号\t块号\t状态位\t\t\t页号\t块号\t状态位\n");86. for(i=0;i<PageLength;i++)87. {88. printf("\t%d\t",i);89. if(FPage[i].kuai==-1)90. printf(" \t");91. else92. printf("%d\t",FPage[i].kuai);93. printf("%d",FPage[i].stage);94. printf("\t\t\t%d\t",i);95. if(LPage[i].kuai==-1)96. printf(" \t");97. else98. printf("%d\t",LPage[i].kuai);99. printf("%d\n",LPage[i].stage);100. }101. printf("\nFMemory：\t\t\t\tLMemory：\n");102. printf("\t块号\t页号\t\t\t\t块号\t\t页号\n");103. for(i=Memsize-1;i>=0;i--)104. {105. printf("\t%d\t",i);106. if(FMemory[i].page==-1)107. printf(" \t\t");108. else109. printf("%d\t\t",FMemory[i].page);110. printf("\t\t%d\t",i);111. if(LMemory[i].page==-1)112. printf("\n");113. else114. printf("\t%d\n",LMemory[i].page);115. }116. printf("Logical: %d\n",Logical);117. printf("Count: %d %d\n",Pagenumber,Pageaddr);118. printf("Physical: %d\n",Physical);119. printf("PageSize: %d\n",PageSize);120. printf("Visit: %d\n",visit);121. printf("FAbsent: %d LAbsent: %d\n",FAbsent,LAbsent);122. printf("FRate: %.2f%% LRate: %.2f%%\n",(double)FAbsent*100/(double)visit,(double)LAbsent*100/(double)visit); 123.}124.125.126.void FIFO() /*FIFO算法*/127.{128. int i;129. int m,n;130.131.132. if(FPage[Pagenumber].stage==1) /*命中*/133. ;134. else /*缺页*/135. {136. FAbsent++;137. FPage[Pagenumber].stage=1;138.139. for(i=0;i<Memsize;i++)140. {141. if(FMemory[i].page==-1)142. {143. for(m=1;m<8;m++)144. {145. for(n=0;n<8;n++)146. if(G[m][n]==0)147. {148. break;149. }150. if(n<8)151. break;152. }153. Freemem=(m-1)*8+n;154. FMemory[i].page=Pagenumber;155. FPage[Pagenumber].kuai=Freemem;156.157. break;158. }159. }160. if(i==Memsize)161. {162. FPage[Pagenumber].kuai=FPage[FMemory[0].page].kuai; 163. FPage[FMemory[0].page].kuai=-1;164. FPage[FMemory[0].page].stage=0;165. for(i=0;i<Memsize-1;i++)166. FMemory[i].page=FMemory[i+1].page;167. FMemory[i].page=Pagenumber;168. }169. }170.171.}172.void LRU() /*LRU算法*/173.{174. int i,j,m,n,l;175.176. //bool flag=true;177.178. for(l=0;l<Memsize;l++)179. if(LMemory[l].page==-1)180. break;181.182. if(LPage[Pagenumber].stage==1)/*命中*/183. {184. for(i=0;i<l;i++)185. {186. if(LMemory[i].page==Pagenumber)187. {188. for(j=i;j<l-1;j++)189. {190. LMemory[j].page=LMemory[j+1].page;191. }192. LMemory[j].page=Pagenumber;193. break;194. }195. }196. }197. else /*没命中*/198. {199. LAbsent++;200. LPage[Pagenumber].stage=1;201.202. if(l<Memsize) //问题出在这里,l++之前需要判断一下如果l<memsize 说明有空闲块，则l++ ,否则块已经满了,l不能++ ...203. l++;204. for(i=0;i<l;i++)205. {206. if(LMemory[i].page==-1)207. {208. for(m=1;m<8;m++)209. {210. for(n=0;n<8;n++)211. if(G[m][n]==0)212. {213. G[m][n]=1;214. break;215. }216. if(n<8)217. break;218. }219. Freemem=(m-1)*8+n;220. LMemory[i].page=Pagenumber;221. LPage[Pagenumber].kuai=Freemem;222. for(j=i;j<l-1;j++)223. {224. LMemory[j].page=LMemory[j+1].page;225. }226. LMemory[j].page=Pagenumber;227. break;228. }229. }230. if(i==l)231. {232. LPage[LMemory[0].page].stage=0;233. LPage[Pagenumber].kuai=LPage[LMemory[0].page].kuai;234. LPage[LMemory[0].page].kuai=-1;235. for(j=0;j<l-1;j++)236. LMemory[j].page=LMemory[j+1].page;237. LMemory[j].page=Pagenumber;238. }239. }240.}241.242.void OPTshow()243.{244. int i;245. printf("\t");246. for(i=Memsize-1;i>=0;i--)247. {248. if(OMemory[i].page==-1)249. printf(" ");250. else251. printf(" %d",OMemory[i].page);252. }253. printf("\n");254.}255.256.void OPT()257.{258. printf("\nOPTMemory：\n");259. printf("\t 2 1 0\n\n");260. int i,j,k,l,m,n;261. int count=0;262. for(i=0;i<oth;i++)263. {264. for(j=0;j<Memsize;j++)265. {266. if(OMemory[j].page==opt[i])267. break;268. }269. if(j<Memsize)270. ;271. else272. {273. for(j=0;j<Memsize;j++)274. {275. if(OMemory[j].page==-1) /*如果此时内存没满还有空缺就直接将页号写进去*/276. {277. OMemory[j].page=opt[i];278. break;279. }280. }281. if(j==Memsize) /*需要发生置换*/ 282. {283. OAbsent++;284. for(n=0;n<Memsize;n++)285. temp[n]=0;286.287. for(k=i+1;k<oth;k++)288. {289. for(l=0;l<Memsize;l++)290. {291. if(OMemory[l].page==opt[k])292. {293. temp[l]++;294. break;295. }296. }297. count=0;298. for(m=0;m<Memsize;m++)299. {300. if(temp[m]==0)301. count++;302. }303. if(count>1&&k<oth-1)304. ;305. else306. {307. for(m=0;m<Memsize;m++)308. if(temp[m]==0)309. {310. OMemory[m].page=opt[i]; 311. break;312. }313. }314. }315. }316. }317. OPTshow();318. }319. printf("OAbsent: %d\n",OAbsent);320. printf("ORate: %.2f%%\n",(double)OAbsent*100/(double)visit); 321.322.}323.324.void cometrue()325.{326. printf("输入页表长度（页）：");327. scanf("%d",&PageLength);328. printf("输入内存块数（块）：");329. scanf("%d",&Memsize);330. printf("输入页面大小（kb）：");331. scanf("%d",&PageSize);332. init();333. while(printf("输入逻辑地址(10进制): ")&&scanf("%d",&Logical)) 334. {335. if(Logical!=-1)336. {337. Pagenumber=Logical/(PageSize*1024);338. Pageaddr=Logical%(PageSize*1024);339. if(Pagenumber>=PageLength)340. {341. printf("越界中断......!\n");342. continue;343. }344. opt[oth++]=Pagenumber;345. GShow();346. FIFO();347. LRU();348.349. Physical=Freemem*PageSize*1024+Pageaddr;350. visit++;351.352. Show();353. }354. else if(Logical==-1)355. {356. int i;357. printf("页号访问序列：\n");358. for(i=0;i<oth;i++)359. printf("%d ",opt[i]);360. printf("\n");361. OPT();362. break;363. }364. }365.}366.367.int main()368.{369. cometrue(); 370. return 0; 371.}。

操作系统实验报告材料6-页面置换算法模拟

实验报告（ 2013 / 2014学年第1学期）课程名称操作系统原理实验名称实验6：页面置换算法模拟实验时间2013 年12 月 10 日指导单位软件工程系指导教师杨健学生姓名班级学号学院(系) 软件工程系专业计算机软件与服务外包//物?理え?块é定¨义?typedef struct BlockNode{int page_index;//page数簓组哩?的?下?标括?struct BlockNode * next;}BlockNode;struct{int length;//当獭?前°物?理え?块é长¤度èint miss_flag;//缺ā?页?标括?志?，?若?为a1，?则ò缺ā?页?int miss_count;//缺ā?页?次?数簓BlockNode*front;BlockNode*rear;}Block;//本?程ì序ò中D全?局?变?量?名?均ù由?两?个?单蹋?词洙?组哩?成é，?且ò开a头?字?母?大洙?写′int BlockSize = 5;//物?理え?块é大洙?小?int PageCount = 200;//页?面?总哩?数簓int PageSize = 1024;//页?面?大洙?小?int AddrRange = 8*1024;//访?问ê地?址·范?围§int get_num(int down,int up)//得?到?一?个?down~up之?间?的?整?数簓{int num;char str[111];while(1){fgets(str,111*sizeof(int),stdin);num=atoi(str);//把?字?符?串?中D的?数簓字?转羇换?为a整?数簓if(num>=down&& num<=up)break;printf("输?入?范?围§有瓺误ó,请?重?新?输?入?:");}//whilereturn num;}void init_block()//构1造ì一?个?空?的?物?理え?块é队ó列{Block.rear=Block.front=(BlockNode*)malloc(sizeof(BlockNode)); if(!Block.front){printf("内ú存?分?配?失骸?败悒?\n");exit(0);}Block.length=0;Block.miss_count=0;Block.rear->next=NULL;}void enqueue(int page_index)//入?队óvoid clear_block()//清?空?物?理え?块é{while(Block.rear=Block.front->next){ Block.front->next=Block.rear->next;free(Block.rear);Block.length--;}Block.rear=Block.front;Block.length=0;Block.miss_count=0;}void destroy_block()//销ú毁ù物?理え?块é{while(Block.rear=Block.front){Block.front=Block.front->next;free(Block.rear);}free(page);}void init_page()//初?始?化ˉ页?面?系μ列int i,j;srand(time(NULL));//用?当獭?前°系μ统?时骸?间?来ぁ?初?始?化ˉ随?机ú种?子哩? page=(struct node_page*) malloc(PageCount*sizeof(struct node_page));for(i=0;i<PageCount;i++){page[i].address=rand()%AddrRange;page[i].page_num=page[i].address/PageSize;}for(i=0;i<PageCount;i++){for(j=i+1;j<PageCount;j++){if(page[i].page_num== page[j].page_num){page[i].next_order=j;break;}//if}//forif(j== PageCount)//说μ明÷page[i]以?后ó都?不?会á再ù访?问êpage[i].next_order= PageCount;}//for}void print_page()//打洙?印?页?面?系μ列{int i;printf("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); printf("页?面?系μ列为a：阰\n");for(i=0;i<PageCount;i++){printf("[%-2d,%-4d]",page[i].page_num,page[i].address%PageSize); if((i+1)%5== 0){printf("\n");}//if}printf("\n");}void FIFO_Replace(int page_index)//FIFO置?换?{BlockNode*node;if(!Block.length){enqueue(page_index);Block.miss_flag=0;return;}node=Block.front;while(node=node->next){if(page[node->page_index].page_num==page[page_index].page_num){destroy_block(); return 0;}截图。

请求页式存储管理中常用页面置换算法

计算机操作系统实验报告济南大学信息科学与技术学院2013年xx月xx日一、实验概述1. 实验名称请求页式存储管理中常用页面置换算法管理2. 实验目的（1）了解内存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。

（5）了解页面大小和内存实际容量对命中率的影响3. 实验内容（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；（2）实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟；（3）使用某种编程语言模拟页面置换算法。

二、实验环境C语言三、实验过程1. 设计思路和流程图选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换2. 算法实现（1）OPT基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。

数组next[mSIZE]记录物理块中对应页面的最后访问时间。

每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。

（2）FIFO基本思想：是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。

或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最小的页面。

(3)LRU基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。

数组flag[10]标记页面的访问时间。

每当使用页面时，刷新访问时间。

发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。

3.源程序并附上注释#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("┃学号：20111214034 ┃\n");printf("┃姓名：韩瑶┃\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);}6. 程序运行时的初值和运行结果1. 按任意键进行初始化：2. 载入数据：3. 进入置换算法选择界面：4.运算中延迟操作5.三种算法演示结果：四、实验体会掌握了一般的调度算法，了解了页面大小和内存实际容量对命中率的影响。

页面置换算法实验报告

二、实验内容：●虚拟内存页面总数为N，页号从0到N-1●物理内存由M个物理块组成●页面访问序列串是一个整数序列，整数的取值范围为0到N - 1。

页面访问序列串中的每个元素p表示对页面p的一次访问●页表用整数数组或结构数组来表示❑符合局部访问特性的随机生成算法1.确定虚拟内存的尺寸N，工作集的起始位置p，工作集中包含的页数e，工作集移动率m（每处理m个页面访问则将起始位置p +1），以及一个范围在0和1之间的值t；2.生成m个取值范围在p和p + e间的随机数，并记录到页面访问序列串中；3.生成一个随机数r，0 ≤r ≤1；4.如果r < t，则为p生成一个新值，否则p = (p + 1) mod N；5.如果想继续加大页面访问序列串的长度，请返回第2步，否则结束。

三、实验环境：操作系统：Windows 7软件：VC++6.0四、实验设计：本实验包含六种算法，基本内容相差不太，在实现方面并没有用统一的数据结构实现，而是根据不同算法的特点用不同的数据结构来实现：1、最佳置换和随机置换所需操作不多，用整数数组模拟内存实现；2、先进先出置换和最近最久未使用置换具有队列的特性，故用队列模拟内存来实现；3、CLOCK置换和改进的CLOCK置换具有循环队列的特性，故用循环队列模拟内存实现；4、所有算法都是采用整数数组来模拟页面访问序列。

五、数据结构设计：//页面访问序列数组：int ref[ref_size];//内存数组：int phy[phy_size];//队列数据结构定义：typedef struct QNode //定义队列数据结构{int data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front; //头指针QueuePtr rear; //尾指针}LinkQueue;//定义链表数据结构typedef struct LNode //定义循环链表数据结构{int data;int flag; //访问位int modify; //修改位struct LNode *next;}LNode,*LinkList;六、主要函数说明：1、void set_rand_num() //产生具有局部特性的随机数列；2、int Exchange_LNode(LinkList &L,int e,int i)//将链表L中序号为i的结点替换为内容为e的结点；3、bool Search_LinkList(LinkList &L,int e,int &i)//找到链表L中内容为e的结点，并用i返回其位置，i=1表示第一个非头结点，依次类推；4、void Search_LL_Flag(LinkList &L,int &i)//用i返回第一个flag为0的结点的位置,i=1表示第一个非头结点，以此类推；5、void Set_LL_Flag(LinkList &L,int i) //设置链表L中的序号为i的结点的flag标志为1；6、int Search_LL_ModifyClock(LinkList &L,int &modify_num)//找到改进的CLOCK算法所需要淘汰的页，用modify_num返回其位置；此函数根据书上给的思路，第一遍扫描A=0且M=0的页面予以淘汰，若失败，则进行第二轮扫描A=0且M=1的页面，第二轮扫描时将所有访问过的页面的访问位A置0；若失败则重复上述两部；7、void Set_LL_modify(LinkList &L,int i) //设置链表L中的序号为i的结点的modify标志为1；8、bool SearchQueue(LinkQueue &Q,int e,int &i) //寻找队列Q中结点data域等于e的结点，并用i返回其在Q中的位置；9、int getnum(int a,int b) //用b返回元素a在被引用数列中的下一个位置10、void ORA() //实现最佳置换算法，包括判断页面是否在内存中、页面进内存、输出内存状态等内容；11、void RAND() //随机置换算法12、void FIFO() //先进先出算法13、void LRU() //最近最久未使用算法实现最近最久未使用算法的思想是：判断待进入内存的页面，如果与内存中的第一个页面相同，则将它移到最后一个，即标志为最近使用的页；如果与内存中的第二个页面相同，则将它删除，并在队列尾部添加相同元素，即标志为最近使用的页；14、void CLOCK() //实现CLOCK算法15、void Modified_Clock() //实现改进的CLOCK算法16、int main() //主函数，调用实现各算法的6个主要函数，并输出各算法的缺页率。

实验六 请求分页系统页面置换算法

实验六页面置换

页面置换算法PPT课件

【精品】页面置换算法实验报告

页面置换算法实验(内含完整代码)

实验请求页式存储管理页面置换算法

请求页式管理的页面置换算法

操作系统请求分页式存储管理页面置换算法课程设计报告

实验六请求分页存储管理

操作系统实验报告6-页面置换算法模拟综述

页面置换算法的实验报告.

请求页式存储管理中常用页面置换算法模拟

操作系统页面置换算法实验报告

页面置换算法实验

页面置换算法实验报告

页面置换算法实验报告

实验六 请求分页系统页面置换算法

操作系统实验报告材料6-页面置换算法模拟

请求页式存储管理中常用页面置换算法

页面置换算法实验报告

实验六请求分页系统页面置换算法

实验六请求分页系统页面置换算法