请求页式管理缺页中断模拟设计--FIFO、OPT
大作业用先进先出(FIFO)页面调度算法处理缺页中断
实验四 用先进先出（FIFO ）页面调度算法处理缺页中断1．实验目的深入了解页式存储管理如何实现地址转换；进一步认识页式虚拟存储管理中如何处理缺页中断。
2．实验预备知识页式存储管理中的地址转换的方法；页式虚拟存储的缺页中断处理方法。
3．实验内容编写程序完成页式虚拟存储管理中地址转换过程和模拟缺页中断的处理。
实验具体包括：首先对给定的地址进行地址转换工作，若发生缺页则先进行缺页中断处理，然后再进行地址转换；最后编写主函数对所作工作进程测试。
假定主存64KB ，每个主存块1024字节，作业最大支持到64KB ，系统中每个作业分得主存块4块。
4．提示与讲解页式存储管理中地址转换过程很简单，假定主存块的大小为2n 字节，主存大小为2m'字节和逻辑地址m 位，则进行地址转换时，首先从逻辑地址中的高m-n 位中取得页号，然后根据页号查页表，得到块号，并将块号放入物理地址的高m'-n 位，最后从逻辑地址中取得低n 位放入物理地址的低n 位就得到了物理地址，过程如图1所示。
图1 页式存储管理系统地址转换示意图地址转换是由硬件完成的，实验中使用软件程序模拟地址转换过程，模拟地址转换的流程图如图2所示（实验中假定主存64KB ，每个主存块1024字节，逻辑地址即n=10,m'=16，物理地址中块号6位、块内地址10位；作业最大64KB，即m=16，逻辑地址中页号6位、页内地址10位）。
在页式虚拟存储管理方式中，作业信息作为副本放在磁盘上，作业执行时仅把作业信息的部分页面装入主存储器，作业执行时若访问的页面在主存中，则按上述方式进行地址转换，若访问的页面不在主存中，则产生一个“缺页中断”，由操作系统把当前所需的页面装入主存储器后，再次执行时才可以按上述方法进行地址转换。
页式虚拟存储管理方式中页表除页号和该页对应的主存块号外，至少还要包括存在标志（该页是否在主存），磁盘位置（该页的副本在磁盘上的位置）和修改标志（该页是否修改过）。
详解页式管理置换算法FIFO_LRU_OPT
页式管理OPT、LRU、FIFO置换算法详解指令：1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6若内存最多容纳4个页面，则……一、OPT（理想型淘汰）算法该算法无法实现。
置换规则：（1）淘汰内存中以后不再访问的页面；（2）如果没有（1），则淘汰将要访问指令之后的将来最迟被访问的指令的页面。
分析：（1）当访问5时，内存1,2,3,4,发生第5次中断，淘汰不再访问的4，换入5，内存1,2,3,5；（2）当访问6时，内存1,2,3,5,发生第6次中断，淘汰不再访问的5，换入6，内存1,2,3,6；（3）当访问7时，内存1,2,3,6,发生第7次中断，由于之后的指令（1、2、3、6）都是现在内存页面都存在的指令，无法淘汰，但可以根据指令访问顺序，先淘汰将来最迟被访问的1，换入7，置换后的内存7,2,3,6；（4）当访问1时，内存7,2,3,6,发生第8次中断，淘汰不再访问的7，换入1，内存1,2,3,6；即OPT算法一共会出现8次缺页中断。
二、LRU（最近最久未使用）算法该算法利用堆栈实现，每次访问都调整堆栈中页面顺序。
把被访问页面从栈移出再压入栈顶。
置换规则：（1）栈顶始终为最新访问过的页面；（2）栈底始终为最近最久未被访问的页面；（3）访问存在的页面要调到栈顶。
分析：（1）访问第5个指令2时，由于内存页面中已经存在2，所以不置换，但调整2在栈中顺序，即将2调到栈顶，其它页面依次后置。
调整前内存4,3,2,1,调整后内存2,4,3,1；（2）访问第7个指令5时，发生第5次中断，原内存1,2,4,3,淘汰栈底3，栈顶调入5，调整后内存5,1,2,4；（3）访问第8个指令6时，发生第6次中断，原内存5,1,2,4,，淘汰栈底4，栈顶调入6，调整后内存6,5,1,2；……即LRU算法一共会出现10次缺页中断。
三、FIFO（先进先出）算法该算法利用队列实现。
FIFO与LRU的区别是FIFO遇到内存中存在的页面不需要调换页面顺序。
操作系统(第三版)孙钟秀主编 课后习题4应用题参考答案
CH4 应用题参考答案1 在一个请求分页虚拟存储管理系统中，一个程序运行的页面走向是：1、2、3、4、2、1、5、6、2、1、2、3、7、6、3、2、1、2、3、6。
分别用FIFO、OPT和LRU算法，对分配给程序3个页框、4个页框、5个页框和6个页框的情况下，分别求出缺页中断次数和缺页中断率。
答：只要把表中缺页中断次数除以20，便得到缺页中断率。
2 在一个请求分页虚拟存储管理系统中，一个作业共有5页，执行时其访问页面次序为：(1) 1、4、3、1、2、5、1、4、2、1、4、5。
(2) 3、2、1、4、4、5、5、3、4、3、2、1、5。
若分配给该作业三个页框，分别采用FIFO和LRU面替换算法，求出各自的缺页中断次数和缺页中断率。
答：(1) 采用FIFO为9次，9/12=75%。
采用LRU为8次，8/12=67%。
(2) 采用FIFO和LRU均为9次，9/13=69%。
3 一个页式存储管理系统使用FIFO、OPT和LRU页面替换算法，如果一个作业的页面走向为：(1) 2、3、2、1、5、2、4、5、3、2、5、2。
(2) 4、3、2、1、4、3、5、4、3、2、1、5。
(3 )1、2、3、4、1、2、5、1、2、3、4、5。
当分配给该作业的物理块数分别为3和4时，试计算访问过程中发生的缺页中断次数和缺页中断率。
答：(1) 作业的物理块数为3块，使用FIFO为9次，9/12=75%。
使用LRU为7次，7/12=58%。
使用OPT为6次，6/12=50%。
作业的物理块数为4块，使用FIFO为6次，6/12=50%。
使用LRU为6次，6/12=50%。
使用OPT为5次，5/12=42%。
(2) 作业的物理块数为3块，使用FIFO为9次，9/12=75%。
使用LRU为10次，10/12=83%。
使用OPT为7次，7/12=58%。
作业的物理块数为4块，使用FIFO为10次，10/12=83%。
使用LRU为8次，8/12=66%。
OPT、FIFO、LRU算法的实现
OPT、FIFO、LRU算法的实现⼀、实验⽬的1. 了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中⼏种基本页⾯置换算法的基本思想和实现过程，并⽐较它们的效率。
2. 了解程序设计技术和内存泄露的原因⼆、实验内容模拟实现请求页式存储管理的⼏种基本页⾯置换算法最佳淘汰算法（OPT）先进先出的算法（FIFO）最近最久未使⽤算法（LRU）三、实验原理1. 虚拟存储系统UNIX中，为了提⾼内存利⽤率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进⾏；⼀个进程只需将其⼀部分（段或页）调⼊内存便可运⾏；还⽀持请求调页的存储管理⽅式。
当进程在运⾏中需要访问某部分程序和数据时，发现其所在页⾯不在内存，就⽴即提出请求（向CPU发出缺中断），由系统将其所需页⾯调⼊内存。
这种页⾯调⼊⽅式叫请求调页。
为实现请求调页，核⼼配置了四种数据结构：页表、页框号、访问位、修改位、有效位、保护位等。
2. 页⾯置换算法当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转⼊缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调⼊内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出⼀页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调⼊，修改页表。
利⽤修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页⾯的调⼊过程对⽤户是透明的。
最佳淘汰算法（OPT）：选择永不使⽤或在未来最长时间内不再被访问的页⾯予以替换。
先进先出的算法（FIFO）：选择在内存中驻留时间最久的页⾯予以替换。
最近最久未使⽤算法（LRU）：选择过去最长时间未被访问的页⾯予以替换。
3. ⾸先⽤srand( )和rand( )函数定义和产⽣指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
（1）通过随机数产⽣⼀个指令序列，共320条指令。
操作系统页面置换算法（opt,lru,fifo,clock）实现
操作系统页⾯置换算法（opt,lru,fifo,clock ）实现选择调出页⾯的算法就称为页⾯置换算法。
好的页⾯置换算法应有较低的页⾯更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页⾯先调出。
常见的置换算法有以下四种（以下来⾃操作系统课本）。
1. 最佳置换算法(OPT)最佳(Optimal, OPT)置换算法所选择的被淘汰页⾯将是以后永不使⽤的，或者是在最长时间内不再被访问的页⾯,这样可以保证获得最低的缺页率。
但由于⼈们⽬前⽆法预知进程在内存下的若千页⾯中哪个是未来最长时间内不再被访问的，因⽽该算法⽆法实现。
最佳置换算法可以⽤来评价其他算法。
假定系统为某进程分配了三个物理块，并考虑有以下页⾯号引⽤串： 7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1进程运⾏时，先将7, 0, 1三个页⾯依次装⼊内存。
进程要访问页⾯2时，产⽣缺页中断，根据最佳置换算法，选择第18次访问才需调⼊的页⾯7予以淘汰。
然后，访问页⾯0时，因为已在内存中所以不必产⽣缺页中断。
访问页⾯3时⼜会根据最佳置换算法将页⾯1淘汰……依此类推，如图3-26所⽰。
从图中可以看出⾤⽤最佳置换算法时的情况。
可以看到，发⽣缺页中断的次数为9，页⾯置换的次数为6。
图3-26 利⽤最佳置换算法时的置换图2. 先进先出(FIFO)页⾯置换算法优先淘汰最早进⼊内存的页⾯，亦即在内存中驻留时间最久的页⾯。
该算法实现简单，只需把调⼊内存的页⾯根据先后次序链接成队列，设置⼀个指针总指向最早的页⾯。
但该算法与进程实际运⾏时的规律不适应，因为在进程中，有的页⾯经常被访问。
图3-27 利⽤FIFO 置换算法时的置换图这⾥仍⽤上⾯的实例，⾤⽤FIFO 算法进⾏页⾯置换。
进程访问页⾯2时，把最早进⼊内存的页⾯7换出。
然后访问页⾯3时，再把2, 0, 1中最先进⼊内存的页换出。
页式虚拟存储管理FIFO、LRU和OPT页面置换算法
目录1 需求分析 (2)1.1 目的和要求 (2)1.2 研究内容 (2)2 概要设计 (2)2．1 FIFO算法 (3)2．2 LRU算法 (3)2．3 OPT算法 (3)2．4 输入新的页面引用串 (3)3 详细设计 (4)3．1 FIFO（先进先出）页面置换算法： (4)3．2 LRU（最近最久未使用）置换算法： (4)3．3 OPT（最优页）置换算法 (4)4 测试 (5)5 运行结果 (5)6 课程设计总结 (9)7 参考文献 (10)8 附录：源程序清单 (10)1 需求分析1.1 目的和要求在熟练掌握计算机虚拟存储技术的原理的基础上，利用一种程序设计语言模拟实现几种置换算法，一方面加深对原理的理解，另一方面提高学生通过编程根据已有原理解决实际问题的能力，为学生将来进行系统软件开发和针对实际问题提出高效的软件解决方案打下基础。
1.2 研究内容模拟实现页式虚拟存储管理的三种页面置换算法（FIFO(先进先出)、LRU （最近最久未使用）和OPT（最长时间不使用）），并通过比较性能得出结论。
前提：（1）页面分配采用固定分配局部置换。
（2）作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。
2 概要设计本程序主要划分为4个功能模块，分别是应用FIFO算法、应用LRU算法、应用OPT算法和页面引用串的插入。
1.1各模块之间的结构图2．1 FIFO 算法该模块的主要功能是对相应页面引用串进行处理，输出经过FIFO 算法处理之后的结果。
2．2 LRU 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过LRU 算法处理之后的结果。
2．3 OPT 算法该模块的主要功功能是对相应的页面引用串进行处理，输出经过OPT 算法处理之后的结果。
2．4 输入新的页面引用串该模块的主要功能是用户自己输入新的页面引用串，系统默认的字符串是0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0，用户可以自定义全新的20个数字页面引用串。
C语言 页面淘汰算法 OPT FIFO LRU CLOCK
《操作系统原理》上机作业（报告）作业：页面淘汰算法作业编号 6 题目页面淘汰/置换算法作业要求【题目要求】通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
针对一个页框，根据实验数据，以OPT算法为参考，研究FIFO页面淘汰算法、LRU页面淘汰以及CLOCK算法针对同一批实验数据的缺页率，以及研究在不同页框设置下的各算法缺页率表现情况。
页面引用序列为：4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5（1）固定分配局部置换情况下，驻留集大小为3，针对该内存页面引用序列模拟各算法的运行过程，并计算缺页率。
（2）模拟驻留集大小为4和5的情况下各算法的运行过程和缺页率。
其菜单如下：*************内存分配和回收***********=================================0. 退出1. OPT算法实现2. LRU算法实现3. FIFO算法实现4. CLOCK算法5. 显示缺页率对比表=================================【实习要求】可选编程语言：C/C++/Java/C#/Python；实现在同一个程序文件中（C/C++）；请适当注释；【实现提示】所需变量N：程序执行需要访问的页面数Msize：内存中可容纳的页数lack：在一次页面走向序列中用来统计缺页次数rate：缺页次数/总页数变量声明如下图所示：队列结构页面引用序列pages[N]和内存容量Memory[m]均用简单的数据结构线性表实现，其声明如图所示：【选做内容】改进型CLOCK算法实现。
构造一个页面引用序列，并出现Belady现象。
报告正文（运行屏幕截图及源代码）一．截图。
二．附录。
#include"stdio.h"#define N 30 //最大页数static int Msize; //内存容页数static int lacknum; //缺页数static int pages[N] = {4,3,2,1,4,3,5,4,3,2,1,5};static int memery[10];void Initial(){int i;for(i = 0; i < 10; i++){memery[i] = 0;}lacknum = 0;}int To_left(int index, int page) //计算之前的本页到现在已经多久了{int i = index - 1;while(i>=0){if(pages[i] == page)。
概述fifo,opt,lru算法
概述fifo,opt,lru算法一、算法简介FIFO（FirstInFirstOut，先进先出）、OPT（OptimalPageReplacement）和LRU（LeastRecentlyUsed）算法是三种常见的页面替换算法，用于计算机中的虚拟内存管理。
这些算法在处理内存中数据块的替换时，需要考虑内存的容量、程序的需求以及数据的历史访问情况等因素。
二、算法原理1.FIFO算法：此算法将页面按照进入的顺序依次存放在内存中。
当有新的页面需要被加载时，如果内存中没有该页面，就需要从磁盘上加载。
当所有的页面都按照进入的顺序被加载完毕后，再按照同样的顺序将页面从内存中逐出，以腾出空间存放新的页面。
这种算法简单易行，但过于依赖页面的进入顺序，如果页面进入的顺序不合理，可能会导致频繁的页面替换。
2.OPT算法：此算法在每次需要加载新页面时，会根据一些准则（如最大错误率、最小错误率、最坏情况等）选择一个最优的页面进行替换。
相比于FIFO算法，OPT算法能更好地适应不同的页面访问情况，从而减少页面的替换频率。
然而，由于需要考虑到各种复杂的因素，OPT算法的实现难度相对较高。
3.LRU算法：此算法将最近最少使用的页面替换出内存，以腾出空间存放新的页面。
当有新的页面需要被加载时，如果内存中没有该页面，就需要从磁盘上加载。
而在加载完成后，会将该页面标记为最近最少使用的状态。
这种算法能够有效地提高内存的使用效率，减少页面的替换次数。
三、应用场景这三种算法在许多实际应用场景中都有应用，如操作系统中的虚拟内存管理、缓存系统等。
不同的应用场景可能需要不同的算法来满足特定的需求，如对于需要频繁访问的页面，可能更适合使用LRU算法；而对于访问模式较为固定的场景，可能更适合使用OPT算法。
四、总结FIFO、OPT和LRU算法是虚拟内存管理中常用的页面替换算法，它们各自具有不同的原理和应用场景。
在实际应用中，需要根据具体的需求和场景选择合适的算法，以实现最优的内存管理效果。
页式虚拟存储管理缺页中断的模拟系统的设计
燕山大学课程设计说明书课程设计名称：操作系统OS题目：页式存储管理中页面置换（淘汰）的模拟程序班级：计算机应用二班开发小组名称：CAMPUS课题负责人：课题组成员：姓名学号班级自评成绩课题开发日期：2011-1-10至2011-1-14一．概述1目的通过分析、设计和实现页式虚拟存储管理缺页中断的模拟系统，熟悉和掌握请求分页式存储管理的实现过程，重点掌握当请求页面不在内存而内存块已经全部被占用时的替换算法，熟悉常见替换算法的原理和实现过程，并利用替换算法的评价指标——缺页次数和缺页率，来对各种替换算法进行评价比较。
2.主要完成的任务自行输入实际页数、内存可用页面数、存取内存时间、存取快表时间及缺页中断时间，然后由用户随机输入各页面号，模拟系统自动运行出FIFO、LRU、OPT、LFU四种算法的缺页次数、缺页率、命中率、总存取时间、存取平均时间等结果。
3 使用的开发工具（1）使用系统：Windows7（2）使用语言：C++（3）开发工具：Visual C++ 6.04 解决的主要问题设计的结果程序能实现FIFO、OPT、LRU、LFU算法模拟页式存储管理缺页中断，主要能够处理以下的问题：(1) 用户能够输入给作业分配的内存块数；(2) 用户能够输入给定的页面，并计算发生缺页的次数以及缺页率；(3) 程序可由用户输入页面序列；(4)系统自动计算总存取时间及平均存取时间。
二使用的基本概念和原理1.概念FIFO即先进先出页面置换算法，该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
LRU 即最近最久未使用页面置换算法，该算法选择最近最久未使用的页面予以淘汰。
OPT 即最佳值换算法，其选择淘汰的页面是在最长时间内不再被访问的页面。
LFU 即最近使用最少页面置换算法，其淘汰的页面是最近一段时间内使用最少的页面。
缺页中断存取页面时页面不在内存中需从外存调入的现象。
缺页次数即在存取页面过程中发生缺页中断的次数。
实验--编程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法
for(int i=0;i<fS;i++){
if(((Couple)(i)).time<temp){
temp=((Couple)(i)).time;
index=i;
}
}
for(int i=0;i<fS;i++){
if(i!=index){
((Couple)(i)).time--;
for(int i=0;i<;i++){
"Frame size: "+frameSize[i]+"\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
(frameSize[i]);
(frameSize[i]);
"Total errors found: "+errorCount);
"\n************************************\n");
errorCount=0;
}
"----------------Using LRU----------------");
(new Couple(0));
}
}
public void LRUReplace(int fS){
boolean findThesame=false;
int pre=-1;alue==digitalArray[j]){
请求页式管理缺页中断模拟设计--FIFO、OPT
课程设计题目请求页式管理缺页中断模拟设计--FIFO、OPT学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名：指导教师：吴利军_ 工作单位：计算机科学与技术学院题目: 请求页式管理缺页中断模拟设计--FIFO、OPT初始条件：1．预备内容：阅读操作系统的内存管理章节内容，了解有关虚拟存储器、页式存储管理等概念，并体会和了解缺页和页面置换的具体实施方法。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．实现指定淘汰算法。
能够处理以下的情形：⑴能够输入给作业分配的内存块数；⑵能够输入给定的页面，并计算发生缺页的次数以及缺页率；⑶缺页时，如果发生页面置换，输出淘汰的页号。
2．设计报告内容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日请求页式管理缺页中断模拟设计——FIFO、OPT1课程设计目的与功能1.1设计目的结合《操作系统》所学内存页式管理章节，掌握虚拟内存设计的重要性，熟悉和掌握请求分页式存储管理的实现原理，通过分析、设计和实现页式虚拟存储管理缺页中断的模拟系统，重点掌握当请求页面不在内存而内存块已经全部被占用时的替换算法（主要通过FIFO和OPT实现），并考察替换算法的评价指标——缺页次数和缺页率，得到淘汰的页面次序。
模拟分页式虚拟存储管理中硬件的地址转换和缺页中断--选择页面调度算法处理缺页中断
操作系统实验二〔第一题〕一．实验内容模拟分页式虚拟存储管理中硬件的地址转换和缺页中断，以及选择页面调度算法处理缺页中断。
二．实验目的在电脑系统总，为了提高主存利用率，往往把辅助存储器作为主存储器的扩充，使多道运行的作业的全部逻辑地址空间综合可以超出主存的绝对地址空间。
用这种方法扩充的主存储区成为虚拟存储器。
三．实验题目模拟分页式存储管理中硬件的地址转换和产生缺页中断。
四．程序清单//// 操作实验二.cpp : 定义控制台应用程序的入口点。
//#include "stdafx.h"#include<iostream>#include<string>#include<fstream>using namespace std;class ins{private:string ope;long int page;long int unit;public:ins(){ }ins(string o,long int p,long int u):ope(o),page(p),unit(u){}void setope(string o){ ope=o;}void setpage(long int p){ page=p;}void setunit(long int u){ unit=u;}string getope(){return ope;}long int getpage(){return page;}long int getunit(){return unit;}};class work{private:long int Page;int sym;long int inum;long int onum;public:work(){}work(long int P, int s,long int i,long int o):Page(P),sym(s),inum(i),onum(o){} void setPage(long int P){ Page=P;}void setsym( int s){ sym=s;}void setinum(long int i){ inum=i;}void setonum(long int o){ onum=o;}long int getPage(){return Page;}int getsym(){return sym;}long int getinum(){return inum;}long int getonum(){return onum;}};void diaodu(work *w,ins * i,int numofins){ for(int j=0;j<numofins;j++){long int tempofk;long int a =i[j].getpage();for(int k=0;k<7;k++) //7是页表的页数if(w[k].getPage()!=a)continue;else{tempofk=k;break;}if(w[tempofk].getsym()==1)cout<<"绝对地址："<<w[tempofk].getinum()*128+i[j].getunit()<<" "<<"磁盘地址为："<<w[tempofk].getonum()<<" "<<"操作为："<<i[j].getope()<<endl;else cout<<"*"<<"发生缺页中断"<<endl;}}int main(){ins*INS=new ins[12];INS[0].setope ("+");INS[0].setpage(0);INS[0].setunit(70);INS[1].setope ("+");INS[1].setpage(1);INS[1].setunit(50);INS[2].setope ("×");INS[2].setpage(2);INS[2].setunit(15);INS[3].setope ("存"); INS[3].setpage(3);INS[3].setunit(21);INS[4].setope ("取"); INS[4].setpage(0);INS[4].setunit(56);INS[5].setope ("-");INS[5].setpage(6);INS[5].setunit(40);INS[6].setope ("移位"); INS[6].setpage(4);INS[6].setunit(53);INS[7].setope ("+");INS[7].setpage(5);INS[7].setunit(23);INS[8].setope ("存"); INS[8].setpage(1);INS[8].setunit(37);INS[9].setope ("取"); INS[9].setpage(2);INS[9].setunit(78);INS[10].setope ("+"); INS[10].setpage(4);INS[10].setunit(1);INS[11].setope ("存"); INS[11].setpage(6);INS[11].setunit(84);work*W =new work[7]; ifstream in("g://operate1.txt");long int p;int s;long int i;long int o;for(int jj=0;jj<7 ;jj++){in>>p;in>>s;in>>i;in>>o ;W[jj].setPage(p);W[jj].setsym(s);W[jj].setinum(i);W[jj].setonum(o);}diaodu(W,INS,12);}五．结果显示操作系统实验二〔第二题〕一．用先进先出〔FIFO〕九．程序清单/ 操作系统实验二.cpp : 定义控制台应用程序的入口点。
对用LRU和FIFO算法计算“缺页中断”的理解
对⽤LRU和FIFO算法计算“缺页中断”的理解输⼊缺页次数页⾯流：0 1 2 3 2 1 3 2 5 2 3 6 2 1 4 2 FIFO分析：012發別調⼊內存，則內存：012(3次缺⾴)調⼊3逃汰最先進⼊的0,則內存：123(4次缺⾴)調⼊2來命中,則內存：123(內存中有2不缺⾴)調⼊1來命中,則內存：123(內存中有1不缺⾴)調⼊3來命中,則內存：123(內存中有3不缺⾴)調⼊5逃汰最先進⼊的1,則內存：235(5次缺⾴)2，3別別命中，則內存：235調⼊6逃汰最先進⼊的,則內存：356(6次缺⾴)調⼊2逃汰最先進⼊的,則內存：562(7次缺⾴)調⼊1逃汰最先進⼊的,則內存：621(8次缺⾴)最后2命中，所以缺页8次=============================在LRU算法中，最近最少使⽤的页⾯被先换出输⼊:7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0写出LRU算法实现页⾯更换，并给出缺页次数.(设在内存中占四个页架）分析：1题⽬给了访问串7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 02题⽬给了内存中占四个页架3题⽬给了⽤LRU算法来实现。
要求：画出算法实现。
LRU给出⾏ 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0头-----> 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 01 2 0 3 0 4 2 3 0 3 2 1 2 0 1 70 1 2 2 3 0 4 2 2 0 3 3 1 2 0 1底-----> 7 7 1 1 2 3 0 4 4 4 0 0 3 3 2 2淘汰出内存的页⾯： 7 1 4 3整个的表格是怎么来的呢？请注意：题⽬给了7, 写7；题⽬给了0，写0, 7下⼀格；题⽬给了1, 写1，0下⼀格；题⽬给了2, 写2，1下⼀格；注意：已经四个了从上到下是：2107达到了2的要求：内存中占四个页架。
用先进先出（FIFO）页面调度算法处理缺页中断
//页面调度算法（FIFO）#include<stdio.h>#define TRUE 1#define FALSE 0#define MAX 7 // 页的最大数#define IN 4 // 在主存中的页数#define count 13 // 指令数量int P[IN]; // 表示已在主存中的页面int k; // 表示P数组中最先进入内存的页的位置typedef struct{int num; // 页号bool pre; // 标志int random; // 主存块号bool revise; // 修改标志int location; // 在磁盘上的位置}Page_Item;Page_Item Page_Record[MAX];// 指令数据结构typedef struct{char oper; // 操作符int Page_Num; // 页号int Unit_Num; // 单元号}Instruction;Instruction IC[count];// 初始化指令和页表void Init(){k=0; // 指向最先进入内存的页// 初始化页表Page_Record[0].num=0;Page_Record[0].pre=TRUE;Page_Record[0].random=5;Page_Record[0].revise=FALSE;Page_Record[0].location=011;Page_Record[1].num=1;Page_Record[1].pre=TRUE;Page_Record[1].random=8;Page_Record[1].revise=FALSE;Page_Record[1].location=012; Page_Record[2].num=2;Page_Record[2].pre=TRUE; Page_Record[2].random=9; Page_Record[2].revise=FALSE; Page_Record[2].location=013;Page_Record[3].num=3;Page_Record[3].pre=TRUE; Page_Record[3].random=1; Page_Record[3].revise=FALSE; Page_Record[3].location=021;Page_Record[4].num=4;Page_Record[4].pre=FALSE; Page_Record[4].random=0; Page_Record[4].revise=FALSE; Page_Record[4].location=022;Page_Record[5].num=5;Page_Record[5].pre=FALSE; Page_Record[5].random=0; Page_Record[5].revise=FALSE; Page_Record[5].location=023;Page_Record[6].num=6;Page_Record[6].pre=FALSE; Page_Record[6].random=0; Page_Record[6].revise=FALSE; Page_Record[6].location=121;// 初始化指令序列IC[0].oper='+';IC[0].Page_Num=0;IC[0].Unit_Num=70;IC[1].oper='+';IC[1].Page_Num=1;IC[1].Unit_Num=50;IC[2].oper='*';IC[2].Page_Num=2;IC[2].Unit_Num=15;IC[3].oper='w';IC[3].Page_Num=3;IC[3].Unit_Num=21;IC[4].oper='r';IC[4].Page_Num=0;IC[4].Unit_Num=56;IC[5].oper='-';IC[5].Page_Num=6;IC[5].Unit_Num=40;IC[6].oper='>';IC[6].Page_Num=4;IC[6].Unit_Num=53;IC[7].oper='+';IC[7].Page_Num=5;IC[7].Unit_Num=23;IC[8].oper='w';IC[8].Page_Num=1;IC[8].Unit_Num=37;IC[9].oper='r';IC[9].Page_Num=2;IC[9].Unit_Num=78;IC[10].oper='+';IC[10].Page_Num=4;IC[10].Unit_Num=1;IC[11].oper='r';IC[11].Page_Num=6;IC[11].Unit_Num=84;IC[12].oper='#';IC[12].Page_Num=0;IC[12].Unit_Num=0;}// 根据FIFO算法替换页,所需要的参数是被调入页的页结构体void replace(Page_Item page){// 被替换的页已经修改了if(TRUE==Page_Record[P[k]].revise){// 修改被调出页的存在标志Page_Record[P[k]].pre=FALSE;// 修改被调出页的修改标志Page_Record[P[k]].revise=FALSE;printf("调出%d页\n",P[k]);}// 将调入页的存在标志修改为TRUEpage.pre=TRUE;// 将被调出页的主存块号赋给调入页的主存块号page.random=Page_Record[P[k]].random;// 将调入页的页号赋给P[k]P[k]=page.num;printf("调入%d页\n",page.num);// 修改k指针k=(k+1)%IN;}// 指令执行过程void excute(){int i=0; // 指向当前正在执行的指令while('#'!=IC[i].oper){printf("执行%c指令,需%d页\n",IC[i].oper,IC[i].Page_Num);// 若正在执行的指令所需的页不在内存中if(FALSE==Page_Record[IC[i].Page_Num].pre){printf("该页不在内存中,请求调入.........\n");// 调用替换函数，调入所需的页replace(Page_Record[IC[i].Page_Num]);}// 修改指令对该页的操作if('+'==IC[i].oper||'*'==IC[i].oper||'-'==IC[i].oper||'>'==IC[i].oper){printf("%c指令修改了%d页\n",IC[i].oper,IC[i].Page_Num);// 修改该页的修改标志Page_Record[IC[i].Page_Num].revise=TRUE;}i++; // 指向下一条指令}for(i=0;i<IN;i++){if(TRUE==Page_Record[P[i]].revise){printf("%d页写回外存!\n",P[i]);}}}void main(){Init();excute();}。
FIFO缺页中断
cin>>page[i].pnumber;
page[i].flag=1; //存在标志置1
}
}
//初始化FIFO的队列
head=0;
for(i=0; i=M-1; i++)
cout<<"此指令执行是否修改所在页面lnumber="<<lnumber<<"(y/n?)";
char change;
cin>>change;
if(tolower(change)=='y')
{
page[lnumber].write=1; //若页面要已修改，则将此页面修改位置1
main()
{
int laddress, paddress; //逻辑地址，物理地址
int lnumber, ad, pnumber; //页号，页内地址和物理块号
initial(); //手工初始化页表
print_page_and_fifoqueue(); //输出页表和FIFO队列
if(tolower(change)=='y')
{
//若指令执行完时修改了页面，则置write标志位位1
page[lnumber].write=1;
print_page_and_fifoqueue();
}
cout<<"********第一条指令执行完成(地址为0x0000)***********"<<endl;
操作系统：Java实现页面置换算法（OPT,FIFO,LRU）
操作系统：Java实现页⾯置换算法（OPT,FIFO,LRU）前⾔代码有很多冗余，因为是写作业时写的，不过代码简单易懂，看看就可以改了。
置换算法介绍页⾯置换算法（也称为页⾯淘汰算法）是⽤来选择换出页⾯的算法。
在请求页式存储管理⽅式中，由于⼀个进程运⾏的时候不是所有的页⾯都在内存中，所以会出现缺页中断。
当缺页的时候内存没有空闲的物理块时就需要换出内存中的⼀页，具体换出哪⼀页⾯是由页⾯置换算法决定的，页⾯置换算法的优劣直接影响到系统的效率要注意把页⾯置换和连续分配⽅式中的交换区别开来，页⾯置换的单位是页⾯⽽不是整个进程，交换的单位是整个进程当发⽣缺页中断后，系统不⼀定会执⾏页⾯置换算法。
因为发⽣缺页中断仅仅说明需要执⾏的页⾯没有在内存中，如果内存空间中还有空闲块的话，只需要⽤缺页中断处理程序把需要的页⾯从外存调⼊内存即可。
不需要页⾯置换算法：只有内存中没有空闲块的时候才需要页⾯置换算法。
所以，缺页中断不⼀定导致执⾏页⾯置换算法。
1. 最佳置换算法（OPT）在预知⼀个进程的页⾯号引⽤串的情况下，每次都淘汰以后不再使⽤的或以后最迟再被使⽤的页⾯，这种算法就是最佳置换算法显然，最佳置换算法是最优的，具有最低的缺页率。
但由于实际操作中往往⽆法事先知道以后会引⽤到所有页⾯的信息，所以最佳置换算法⽆法实现，只能作为⼀个标准来衡量其他置换算法的优劣2. 先进先出算法（FIFO）FIFO算法是最简单的页⾯置换算法，每次总是淘汰最先进⼊内存的页⾯，也就是将在内存存驻留时间最长的页⾯淘汰掉该算法实现简单，⽤⼀个队列的数据结构就可以实现，将页⾯按照次序排成⼀个队列，并设置指针指向最先进⼊的页⾯，每次需要淘汰页⾯时，将指针所指的页⾯淘汰即可，不过FIFO算法可能会产⽣Belady⼀场（缺页次数随着分配的物理块号的增加⽽增加），⽽且由于FIFO算法与进程实际运⾏规律不符，可能会选择淘汰程序经常使⽤的界⾯，实际效果不好3. 最近最少使⽤算法（LRU）选择最近最久没有被使⽤的页⾯予以淘汰，其思想是⽤以前的页⾯引⽤情况来预测将来会出现页⾯引⽤情况，也就是假设⼀个页⾯刚被访问，那么不久该页⾯还会被访问。
操作系统_页面置换算法FIFO,OPT,LRU实现
cout <<frame[k].num <<' ';
cout <<endl;
}
}
cout <<“LRU:”<<endl;
cout <<“Error次数:”<<error <<endl;
cout <<“Frame Error:”<<(error / 12.0)<<endl <<endl;
}
intmain()
{
FIFO();
OPT();
LRU();
}
（以上为实现页面置换算法FIFO,OPT,LRU的代码）
frame[0].num = input[i];
elseif(frame[1].mark>frame[0].mark&&frame[1].mark>frame[2].mark)
frame[1].num = input[i];
else
frame[2].num = input[i];
cout <<input[i] <<“ | “;
3.FIFO算法实现。
4.在OPT实现中,mark属性设置,以及向后遍历的参数设置。
代码如下:
#include
usingnamespacestd;
intinput[12] = { 2,3,2,1,5,2,4,5,3,2,3,1 };
classpage
{
public:
intnum;
intmark;
FIFO页面调度算法处理缺页中断.
计算机科学与技术系实验报告专业名称网络工程课程名称操作系统原理项目名称FIFO页面调度算法处理缺页中断班级 12网络工程（1）班学号 1204031030姓名方彬同组人员朱佳宝、王卫、凌含涛、胡星瑞实验日期 2014.12.02一、实验目的与要求：（1）熟悉、掌握先进先出FIFO算法，并实现用先进先出FIFO算法页面调度算法处理缺页中断.（2）理解基于先进先出FIFO的内存管理调度算法，更好的掌握算法的思想，结合实验理解算法更直观，深刻具体。
通过对先进先出FIFO的调度算法的模拟实验可以清楚的了解内存管理是如何调度的，以及加深对内存管理的了解。
二、实验内容1）任务分析：以无歧义的陈述说明实验任务，并明确规定：(a)输入的形式和输入值的范围；在输入文本框中输入，输入值的范围在0~6之间(b) 输出的形式；输出为缺页序列的表格(c) 程序所能达到的功能；输入页号，输出缺页序列，实现先进先出算法的模拟(d) 测试数据：包括正确的输入及其输出结果和错误的输入及其输出结果。
①输入值为空：②输入值越界：③正确的输入值：2）概要设计：说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。
本程序中定义了一个数组int[] mainstore = {3,2,1,0 };用于模拟主存存放页；此外还定义了一个数组int[] flag = {0,0,0,0,0,0,0 };用于表明页号的修改标志位，便于之后的操作。
该程序的只要流程如下：3）详细设计：实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法；对主程序和其他模块也都需要写出伪码算法(伪码算法达到的详细程度建议为：按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序)；画出函数和过程的调用关系图。
using System;using System.Collections.Generic;using ponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using lru;using change;namespace 操作系统{public partial class Form1 : Form{public Form1(){InitializeComponent();}//定义一个窗口类，在类里面定义一个窗口int[] mainstore = {3,2,1,0 };//定义数组用于存放页int[] flag = {0,0,0,0,0,0,0 };//定义修改标志位的数组int blo = 0;//用来控制在表格的哪一列输出页号序列private void button1_Click(object sender, EventArgs e)//定义一个事件响应，即对输入进行操作{if (string.IsNullOrEmpty(txt.Text))MessageBox.Show("请输入页号！");else if (int.Parse(txt.Text) > 6 || int.Parse(txt.Text) < 0)MessageBox.Show("输入页号不合法，请重新输入！");//判断输入是否合法else{int page = int.Parse(txt.Text);int i=0;if (page != mainstore[0] && page != mainstore[1] && page != mainstore[2] && page != mainstore[3])//插入页内存中不存在，进行FIFO算法{int lll;lll = mainstore[0];if (flag[mainstore[0]] == 0)//修改标志位为0，直接覆盖{mainstore[0] = page;flag[lll] = 1;}Else//修改标志位为1，数组执行FIFO{for (i = 0; i < 3; i++)mainstore[i] = mainstore[i + 1];mainstore[3] = page;}MessageBox.Show("当前调走页号"+lll.ToString ()+"\n存入页号为"+page.ToString ());l0.Text = "0";l1.Text = "0";l2.Text = "0";l3.Text = "0";l4.Text = "0";l5.Text = "0";l6.Text = "0";//标志位初始化；for (int j = 0; j < 4; j++){if (mainstore[j] == 0)l0.Text = "1";if (mainstore[j] == 1)l1.Text = "1";if (mainstore[j] == 2)l2.Text = "1";if (mainstore[j] == 3)l3.Text = "1";if (mainstore[j] == 4)l4.Text = "1";if (mainstore[j] == 5)l5.Text = "1";if (mainstore[j] == 6)l6.Text = "1";}//根据插入页号，将标志位置1for (int k = 0;k < 7; k++){if (lll == 0)ll0.Text = "1";if (lll == 1)ll1.Text = "1";if (lll == 2)ll2.Text = "1";if (lll == 3)ll3.Text = "1";if (lll == 4)ll4.Text = "1";if (lll == 5)ll5.Text = "1";if (lll == 6)ll6.Text = "1";}//根据情况，将修改标志位置1}else{MessageBox.Show("该页已在主存中！" );}blo++;if(blo==1){txt10.Text = mainstore[0].ToString();txt11.Text = mainstore[1].ToString();txt12.Text = mainstore[2].ToString();txt13.Text = mainstore[3].ToString();}else if(blo==2){txt20.Text = mainstore[0].ToString();txt21.Text = mainstore[1].ToString();txt22.Text = mainstore[2].ToString();txt23.Text = mainstore[3].ToString();}else if(blo==3){txt30.Text = mainstore[0].ToString();txt31.Text = mainstore[1].ToString();txt32.Text = mainstore[2].ToString();txt33.Text = mainstore[3].ToString();}else if(blo==4){txt40.Text = mainstore[0].ToString();txt41.Text = mainstore[1].ToString();txt42.Text = mainstore[2].ToString();txt43.Text = mainstore[3].ToString();}else if(blo==5){txt50.Text = mainstore[0].ToString();txt51.Text = mainstore[1].ToString();txt52.Text = mainstore[2].ToString();txt53.Text = mainstore[3].ToString();}else if(blo==6){txt60.Text = mainstore[0].ToString();txt61.Text = mainstore[1].ToString();txt62.Text = mainstore[2].ToString();txt63.Text = mainstore[3].ToString();}else if(blo==7){txt70.Text = mainstore[0].ToString();txt71.Text = mainstore[1].ToString();txt72.Text = mainstore[2].ToString();txt73.Text = mainstore[3].ToString();}else if(blo==8){txt80.Text = mainstore[0].ToString();txt81.Text = mainstore[1].ToString();txt82.Text = mainstore[2].ToString();txt83.Text = mainstore[3].ToString();}//根据插入数量，决定在输出表的指定列输出}}private void 刷新ToolStripMenuItem_Click(object sender, EventArgs e){Form1 the_new = new Form1();the_new.Show();}private void 退出ToolStripMenuItem_Click(object sender, EventArgs e){this.Close();}4）调试分析：(a)调试过程中遇到哪些问题，是如何解决的；Q1：一开始的程序只能输入9个页号序列，超过之后就不能够再显示新的页号序列；（定义了一个变量BLO，用于记录输入页号数量，做求模运算mod 9,这样当超过九个之后又会从第一列开始覆盖）Q2：考虑到程序的用户友好性，增加了序列刷新功能，刷新输出区域；（定义了一个button，点击后将输出区域初始化）Q3：开始没有理解修改标志位的作用，所以功能没有实现；（经过与同学的讨论，定义了一个数组flag[]，将页号作为flag[]的下标选择置1或置0）(b) 算法的时空分析：算法的时间复杂度和空间复杂度分析；5）测试结果：包括输入和输出，测试数据应该完整和严格。
请求分页系统OPT-LRU-FIFO-CLOCK示例
在一个请求分页系统中，假如系统分配一个作业的物理块数为3，且此作业的页面走向为2 ,3 , 2 ,1 ,5 ,2 ,4 ,5 , 3 2 5 2则OPT,LRU,FIFO,CLOCK算法的页面置换次数为？1.首先是OPT算法的求解过程：2 3 2 1 5 2 4 5 3 2 5 2页面走向2 2 2 2 2 2 4 4 4 2 2 2物理块13 3 3 3 3 3 3 3 3 3 3物理块21 5 5 5 5 5 5 5 5物理块3是是否是是否是否否是否否是否缺页是否否否否否是否是否否是否否置换由表中可知缺页次数为6，置换次数为3.OPT通常可保证获得的最低的缺页率，可以利用此算法去评价其他的页面置换算法。
OPT置换算法是一种理想算法，因为人们还无法预知哪一个页面在未来最长时间不再被访问。
2.下面是LRU 页面置换算法求解过程：2 3 2 1 5 2 4 5 3 2 5 2页面走向2 2 2 2 2 2 2 23 3 3 3物理块13 3 3 5 5 5 5 5 5 5 5物理块21 1 1 4 4 42 2 2物理块3是是否是是否是否是是否否是否缺页是否否否否否是否是否是是否否置换由表中可知缺页次数为7，置换次数为4.LRU置换算法是选择最近最久未使用的页面予以淘汰。
LRU需要寄存器或栈的硬件支持。
3.下面是FIFO 页面置换算法求解过程： 页面走向 2 3 2 1 5 2 4 5 3 2 5 2 物理块1 2 2 2 2 5 5 5 5 3 3 3 3 物理块2 3 3 3 3 2 2 2 2 2 5 5 物理块31 1 1 4 4 4 4 42 是否缺页 是 是 否 是 是 是 是 否 是 否 是 是 是否置换否 否否否是是是否是否是是由上表可知：缺页次数为9次，页面置换次数为6次。
FIFO 总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
4.下面是CLOCK 页面置换算法求解过程：（括号内的0,1表示访问标记。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
课程设计题目请求页式管理缺页中断模拟设计--FIFO、OPT学院计算机科学与技术专业计算机科学与技术班级0806班姓名张军指导教师孙玉芬2011 年 1 月20 日课程设计任务书学生姓名：张军专业班级：计算机0806指导教师：孙玉芬工作单位：计算机科学与技术学院题目: 请求页式管理缺页中断模拟设计--FIFO、OPT初始条件：1．预备内容：阅读操作系统的内存管理章节内容，了解有关虚拟存储器、页式存储管理等概念，并体会和了解缺页和页面置换的具体实施方法。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．实现指定淘汰算法。
能够处理以下的情形：⑴能够输入给作业分配的内存块数；⑵能够输入给定的页面，并计算发生缺页的次数以及缺页率；⑶缺页时，如果发生页面置换，输出淘汰的页号。
2．设计报告内容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名： 2011年 1月20日系主任（或责任教师）签名： 2011年 1月20日请求页式管理缺页中断模拟设计——FIFO、OPT1课程设计目的与功能1.1设计目的结合《操作系统》所学内存页式管理章节，掌握虚拟内存设计的重要性，熟悉和掌握请求分页式存储管理的实现原理，通过分析、设计和实现页式虚拟存储管理缺页中断的模拟系统，重点掌握当请求页面不在内存而内存块已经全部被占用时的替换算法（主要通过FIFO和OPT实现），并考察替换算法的评价指标——缺页次数和缺页率，得到淘汰的页面次序。
高级语言设计并实现出的结果程序要能够很好地显示页面调入和替换详细信息。
1.2初始条件及可发环境1.2.1初始条件1．预备内容：阅读操作系统的内存管理章节内容，了解有关虚拟存储器、页式存储管理等概念，并体会和了解缺页和页面置换的具体实施方法。
2．实践准备：掌握一种计算机高级语言的使用。
1.2.2开发环境（1）使用系统：Windows XP（2）使用语言：C++（3）开发工具：Visual C++ 6.01.3功能实现设计的结果程序能实现FIFO、OPT算法模拟页式存储管理缺页中断，主要能够处理以下的情形：(1) 用户能够输入给定分配的内存块数；(2) 用户输入给定的页面，并计算发生缺页的次数、缺页率及淘汰页面次序；(3) 程序可随机生成页面序列，或用户输入；2需求分析及设计说明2.1需求分析由于纯页式存储管理提高了内存的利用效率，但并不为用户提供虚存，并且会产生磁盘碎片问题。
用户程序将受到物理内存大小的限制。
而虚存的存储管理技术——请求分页存储管理技术和请求分段技术，则很好的解决了这个问题。
该设计虚拟实现请求分页管理（只实现FIFO和OPT）。
请求分页系统是在分页系统的基础上，增加了请求调页功能和页面置换功能所形成的页式虚拟存储系统。
它允许只装入部分页面的程序和数据，便启动运行。
以后，再通过调页功能和页面置换功能，陆续把即将要运行的页面调入内存，同时把暂时不运行的页面换出到外存上，置换时以页面为单位。
实现将程序正在运行时所需的但尚未在内存的页面调入内存，再将内存中暂时不用的页面从内存置换到外存磁盘上。
为了实现请求分页技术，页表应增加相应的内容，反映该页是否在内存，在外存的位置，和在内存的时间的长短。
请求分页中的页表如表1：表1各字段说明如下：状态位：指示该页是否已调入内存。
访问字段：记录本页在被访问的次数，或记录最近已有多长时间未被访问。
修改位：表示该页面在调入内存后是否被修改过。
若未被修改，在替换该页时就不需要再将该页写回到外存上，以减少系统的开销和启动磁盘的次数；若已被修改，则必须将该页重写到外存上，以保证外存中所保留的始终是最新副本。
外存地址：指出该页在外存上的地址，通常是物理块号。
在本设计中模拟FIFO、OPT系统的实现中，只需要用到虚拟页号，物理块号和中断位。
页表可用一个结构体的数组实现。
请求分页的具体实现过程如图1图1请求分页流程图2.2设计说明2.2.1算法分析在进程运行过程中，若其所要访问的页面不在内存，需要把它们调入内存，但内存已无空闲已空闲空间时，为了保证该进程能正常运行，系统必须从内存中调出一页程序或数据，送磁盘的对换区。
但应将哪个页面调出，必须根据替换算法来确定。
该设计采用的是常见置换算法中的先进先出(FIFO)、理想型淘汰算法OPT(Optimal Replacement Algorithm）。
详细算法原理如下：FIFO(先进先出算法)基本思想：总是选择在内存驻留时间最长的一页将其淘汰，因为最早调入内存的页，不再被使用的可能性比近期调入内存的大。
该算法实现简单，只需要把一个进程调入内存的页面，按先后次序连结成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
但是该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如有全局变量、常用函数，例程等的页面，FIFO算法并不能保证这些页面不被淘汰。
使用FIFO替换算法效率比较低，可能会比理想型算法要多出一倍。
低的原因是：基于处理器按线性顺序访问地址空间这一假设。
事实上，许多时候，处理器不是按线性顺序访问地址空间的。
例如，执行循环结构的程序段。
使用FIFO算法时，在未给进程或作业分配足够它所需要的页面数时，有时会出现分配的页面数增，缺页次数反而增加的现象（Belady现象）。
例如针对请求序列：1 2 3 4 1 2 5 1 2 3 4 5，若分配3个可用内存块，使用FIFO算法，一共会缺页9次，缺页率：75%；而如果分配4个可用内存块，则一共会缺页10次，缺页率：83.3%。
OPT(理想型淘汰算法)基本思想：当要调入一新页而必须淘汰一旧页时，所淘汰的页是以后不再使用的，或者是以后相当长的时间内不会使用的。
采用理想型替换算法，通常可保证获得最低的缺页率。
但是由于人们目前无法预知一个进程在内存的若干个页面中，哪个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但是在模拟设计中，由于是事先给定一个页面序列，即知道各个时刻以前和以后的页面出现情况，所以可实现该算法。
在实际系统中，虽无法实现理想型淘汰算法，但是可用它来评价其他替换算法。
2.2.2数据结构模拟设计时，页表没项记录的数据类型用结构体定义。
整该页表用数组模拟。
结构体有三个成员：int page_num 表示页面号；int memory_num表示页面所对应的内存块号；int is_in_memory是存在状态位标志，表示页面是否在内存，0表示不在内存，1表示在内存。
在每一个算法函数中都要初始化页表，否则，后面的算法会受前面算法结果的影响。
struct page{int page_num; //表示页面号int memory_num; //表示页面所对应的内存块号int is_in_memory;//是存在状态位标志，表示页面是否在内存，0 表示不在内存，1表示在内存};page page_table[初始值];for(int i=0;i<10;i++) //初始化页表：{page-table[i].page_num=i;page_table[i].memory_num=-1; //初始化，内存块号为-1，即没在内存块中。
page_table[i].is_in_memory =0; //初始化时，各页面均不在内存}页面请求序列：int *page_array= new int[inputSize]。
内存在程序中模拟内存存放页面号：int *memory=new int[memorySize]2.2.3函数实现Control()函数是class control的构造函数，用来初始化页表、内存(调用initial()函数)。
提示并接受用户输入等待调入页面数page_size，可用物理块数memory_size，并随机生成请求页面，或用户自己输入。
然后调用FIFO()、OPT()函数实现按不同替换算法调入页面进内存。
void FIFO()函数实现先进先出的替换算法调入页面。
void OPT()函数实现理想型替换算法。
3程序的主要模块说明3.1 control类封装内存管理3.1.1 FIFO替换算法实现伪函数void control::FIFO(){control::init(); 初始化页表等do{if(当前页在内存)else（当前页不在内存，直接加载进入物理块）{缺页累积；加载当前页进入内存；修改页表置当前页在页表的是否在内存标志为1。
将该页在内存的位置对应。
}}while(内存物理块没有加载满);//内存物理块已经加载满了；for(剩下的页面循环){if(当前页在内存)else(当前页不在内存){缺页累积。
替换页面；修改页表置当前页在页表的是否在内存标志为1。
将该页在内存的位置对应。
利用算法得到下次替换的物理块号。
}}输出缺页次，缺页率，淘汰页面次序。
}3.1.2 OPT替换算法实现伪函数void control::OPT(){control::init();//初始化页表等for(对每个页表循环处理){for(检查每个物理块){if (如果该页在内存物理块中)置判别标志为1}if(如果该页不在内存，并且物理快放满){缺页累加并权值数组每个记录元素清零for(物理块每个元素检查){for(从该页后面的那个页开始计算权值)权值累加;}得到最大权值所在的物理块，即是下次需要替换的页替换该页，加入内存}if(该页不在内存，并且内存物理块没有满){缺页累加直接加载进内存}}输出缺页次、缺页率和淘汰页号次序。
}3.2 main函数利用页式管理control类建立一个对象，来实现FIFO、OPT。
4使用说明及运行分析4.1使用说明及运行运行程序根据提示输入调入页面数和可使用的物理块数，再选择是用户输入还是计算机随机产生页面号。
观察页面调度过程，处理完各页面后，统计并显示缺页次数、缺页率和淘汰页面号次序。
4.2测试实例和运行结果4.2.1 FIFO算法输入给定的页面数：10输入给作业分配内存的物理块数：3随机生成页面请求序列，如图2：5 7 3 8 8 0 5 4 5 2图2运行结果如图3 图34.2.2 OPT算法输入给定的页面数：10输入给作业分配内存的物理块数：3随机生成页面请求序列，如图4：7 8 2 6 7 8 1 5 6 5图4运行结果如图5 图54.3结论与分析从运行结果看出程序能满足模型设计的要求，提示用户对请求序列的大小和可用内存数量进行限制，并提示用户输入请求序列号，或系统随机生成序列，按照不同的替换算法处理并且显示请求页面的调入和替换情况。