页面置换算法作业
实验5页面置换算法
实验5页⾯置换算法实验5 页⾯置换算法⼀、实验题⽬：页⾯置换算法（请求分页）⼆、实验⽬的：进⼀步理解⽗⼦进程之间的关系。
1）理解内存页⾯调度的机理。
2）掌握页⾯置换算法的实现⽅法。
3）通过实验⽐较不同调度算法的优劣。
4）培养综合运⽤所学知识的能⼒。
页⾯置换算法是虚拟存储管理实现的关键，通过本次试验理解内存页⾯调度的机制，在模拟实现FIFO、LRU等经典页⾯置换算法的基础上，⽐较各种置换算法的效率及优缺点，从⽽了解虚拟存储实现的过程。
将不同的置换算法放在不同的⼦进程中加以模拟，培养综合运⽤所学知识的能⼒。
三、实验内容及要求这是⼀个综合型实验，要求在掌握⽗⼦进程并发执⾏机制和内存页⾯置换算法的基础上，能综合运⽤这两⽅⾯的知识，⾃⾏编制程序。
程序涉及⼀个⽗进程和两个⼦进程。
⽗进程使⽤rand()函数随机产⽣若⼲随机数，经过处理后，存于⼀数组Acess_Series[]中，作为内存页⾯访问的序列。
两个⼦进程根据这个访问序列，分别采⽤FIFO和LRU两种不同的页⾯置换算法对内存页⾯进⾏调度。
要求：1）每个⼦进程应能反映出页⾯置换的过程，并统计页⾯置换算法的命中或缺页情况。
设缺页的次数为diseffect。
总的页⾯访问次数为total_instruction。
缺页率= disaffect/total_instruction命中率= 1- disaffect/total_instruction2）将为进程分配的内存页⾯数mframe 作为程序的参数，通过多次运⾏程序，说明FIFO算法存在的Belady现象。
四、程序流程图开始创建⼦进程1创建⼦进程2结束⼦进程1命中？N内存页⾯满？Y 最先进⼊的进程退出内存页⾯N当前调⼊页⾯进⼊内存页⾯Y 命中次数+1N完？退出Y⼦进程2命中？N内存页⾯满？Y 被访问次数最少的进程退出内存页⾯N当前调⼊页⾯进⼊内存页⾯Y 命中次数+1，命中页⾯访问数+1N逻辑页⾯读完？退出Y五、运⾏结果及其说明FIFO:LRU:：六、回答以下问题：①⽗进程、⼦进程之间的并发执⾏的过程⽗进程与⼦进程之间的并发执⾏宏观并⾏，微观串⾏。
页面置换算法大题
页面置换算法大题
摘要：
一、页面置换算法概述
二、页面置换算法的分类
三、页面置换算法的优缺点分析
四、常见的页面置换算法及其应用
五、总结
正文：
一、页面置换算法概述
页面置换算法，是计算机操作系统中的一种内存管理技术。
它的主要作用是在内存有限的情况下，对内存中的页面进行有效管理，以便在需要时，能够迅速地调用所需的页面，提高系统的运行效率。
二、页面置换算法的分类
根据页面置换的原则，可以将页面置换算法分为以下几类：
1.最佳置换算法（OPT）：总是选择在将来最远的时间内不会被访问的页面进行置换。
2.最近最少使用（LRU）算法：选择距离现在最长时间内没有被访问过的页面进行置换。
3.时钟（Clock）算法：根据页面的访问频率，将其分为多个类别，选择访问次数最少的页面进行置换。
4.最不经常使用（LFU）算法：根据页面的访问次数，选择访问次数最少的页面进行置换。
三、页面置换算法的优缺点分析
各种页面置换算法都有其优点和缺点。
比如，最佳置换算法虽然理论上最优，但实际操作中难以实现，且可能导致内存碎片化。
最近最少使用算法虽然简单易行，但在应对突发访问需求时，可能会出现效率低下的问题。
四、常见的页面置换算法及其应用
在实际应用中，根据不同的系统需求和场景，可以选择不同的页面置换算法。
例如，对于需要频繁进行数据访问的系统，可以选择时钟算法或最近最少使用算法；对于需要保证页面顺序的系统，可以选择最佳置换算法或最不经常使用算法。
五、总结
页面置换算法是操作系统中重要的内存管理技术，其选择和应用直接影响到系统的运行效率和稳定性。
NUR页面置换算法
NRU页面置换算法1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。
2）用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。
在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。
如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。
如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。
在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。
3)置换算法：最近最不经常使用（NRU）算法。
#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define N 4#define size 320typedef struct Page{int page_num;int flag_A; //访问位int flag_M; //修改位int read_or_write; //0表示不被修改,1表示被修改}PAGE;typedef struct Block{int block_num; //块号PAGE page; //所装页的信息struct Block *next;}BLOCK,*BLOCKLIST;typedef struct instruct{ //指令数据结构int address; //指令地址PAGE page; //对应页的信息}INSTRUCTION,*INSTRUCTIONLIST;INSTRUCTION instructions[size];//定义320个指令BLOCKLIST block_head; //块的头指针int diseffect=0; //缺页次数int blockSize=0;void Init_Instructions(){for(int i=0;i<320;i++)instructions[i].address=rand()%320;for(int k=0;k<320;k++){instructions[k].page.page_num=(int)instructions[k].address/10;instructions[k].page.flag_A=0;instructions[k].page.read_or_write=rand()%2;if(instructions[k].page.read_or_write==0)instructions[k].page.flag_M=0;else instructions[k].page.flag_M=1;}}BLOCKLIST Init_block(){BLOCKLIST head=(BLOCKLIST)malloc(sizeof(BLOCK)) ;BLOCKLIST p;for(int i=1;i<=N;i++) {if(i==1) p=head;else {p->next=(BLOCKLIST)malloc(sizeof(BLOCK));p=p->next;}p->block_num=i;p->page.page_num=-1;p->page.flag_A=0;p->page.flag_M=0;}p->next=head;return head;}void display(INSTRUCTION instructions){BLOCKLIST p=block_head;printf("The new page: (page_num==%d), (flag_M==%d), (address==%d)\n", instructions.page.page_num,instructions.page.flag_M,instructions.address);printf("block_num,page_num,flag_A,flag_M\n");do{printf(" %2d %10d%9d%8d\n",p->block_num,p->page.page_num,p->page.flag_A,p->page.flag_M);p=p->next;}while(p!=block_head);}void show_physical_address(BLOCKLIST &p,INSTRUCTION instructions){int address;printf("physical address:");address=p->block_num*1024+instructions.address%10;//页面大小为1kprintf("%d\n\n",address);}//查找四个块中是否有此页面int Find_page_in_block(INSTRUCTION instructions,BLOCKLIST &p){p=block_head;do{if(p->page.page_num==instructions.page.page_num){p->page.flag_A=1;if(p->page.flag_M==0)p->page.flag_M=instructions.page.flag_M;return 1;}p=p->next;}while(p!=block_head);return 0;}//先将四个块中装满void loadpage(PAGE page){BLOCKLIST p;p=block_head;while(p->page.page_num!=-1)p=p->next;p->page.page_num=page.page_num;p->page.flag_A=1;p->page.flag_M=page.flag_M;blockSize++;}//第一次循环扫描A=0 M=0int cscanf1(BLOCKLIST &p){p=block_head;do{if(p->page.flag_A==0 && p->page.flag_M==0)return 1;p=p->next;}while(p!=block_head);return 0;}//第二次循环扫描A=0 M=1int cscanf2(BLOCKLIST &p){p=block_head;do{ //把扫面过后的A=1,M=0 或A=1,M=1中的A置0if(p->page.flag_A==1 && (p->page.flag_M==0 || p->page.flag_M==1)){p->page.flag_A=0;p=p->next;continue;}if(p->page.flag_A==0 && p->page.flag_M==1)return 1;p=p->next;}while(p!=block_head);return 0;}//第三次扫描将所有的A置为0int cscanf3(BLOCKLIST &p){p=block_head;do{p->page.flag_A=0;p=p->next;}while(p!=block_head);return 1;}//用于换进页面void assignment(BLOCKLIST &p,INSTRUCTION instructions) {p->page.page_num=instructions.page.page_num;p->page.flag_A=1;p->page.flag_M=instructions.page.flag_M;}//NRU页面替换算法void replace_page(INSTRUCTION instructions,BLOCKLIST &p) {if(cscanf1(p)){assignment(p,instructions);}else if(cscanf2(p)){assignment(p,instructions);}else if(cscanf3(p)){if(cscanf1(p))assignment(p,instructions);else {cscanf2(p);assignment(p,instructions);}}}void main(){BLOCKLIST p;Init_Instructions();block_head=Init_block();for(int i=0;i<size;i++) {if(Find_page_in_block(instructions[i],p)){display(instructions[i]);show_physical_address(p,instructions[i]);getchar();continue;}else if(blockSize<N) {diseffect++;loadpage(instructions[i].page);}else {diseffect++;replace_page(instructions[i],p);}display(instructions[i]);if(diseffect>4)show_physical_address(p,instructions[i]);getchar();}printf("NRU %f\n",(float)diseffect/size);getchar();getchar();getchar();}。
opt页面置换算法例题详解(一)
opt页面置换算法例题详解(一)OPT页面置换算法例题解析1. 引言页面置换算法是操作系统中用于管理虚拟内存的重要算法之一。
OPT（Optimal）算法是一种最佳的页面置换算法，它通过预测未来的访问情况，选择未来最长时间不会被访问的页面进行置换。
本文将通过一个例题来详细解释OPT算法的工作原理。
2. 例题描述假设一个进程的虚拟内存中有5个页面，分别编号为1、2、3、4、5。
设进程的页面访问序列为1、2、1、4、5、1、2、4、3、5。
物理内存中的页面数为3，初始时物理内存为空。
3. 解题步骤Step 1: 遍历页面访问序列，将每个页面的下一次访问时间记录下来。
•页面1的下一次访问时间是2•页面2的下一次访问时间是7•页面3的下一次访问时间是8•页面4的下一次访问时间是4•页面5的下一次访问时间是9Step 2: 依次访问页面，并进行页面置换。
•访问页面1，物理内存为空，将页面1放入物理内存。
•访问页面2，物理内存中只有页面1，将页面2放入物理内存。
•访问页面1，物理内存中已有页面1和页面2，无需置换。
•访问页面4，物理内存中已有页面1和页面2，将页面4放入物理内存，并移除最长时间不会被访问的页面。
•访问页面5，物理内存中已有页面1、2和4，将页面5放入物理内存，并移除最长时间不会被访问的页面。
•访问页面1，物理内存中已有页面2、4和5，无需置换。
•访问页面2，物理内存中已有页面2、4和5，无需置换。
•访问页面4，物理内存中已有页面2、4和5，无需置换。
•访问页面3，物理内存中已有页面2、4和5，将页面3放入物理内存，并移除最长时间不会被访问的页面。
•访问页面5，物理内存中已有页面4、3和5，无需置换。
4. 结果分析根据以上步骤，使用OPT算法得到的页面置换序列为：1、2、X、4、5、X、X、X、3、X，其中X表示发生页面置换。
经过计算，OPT算法的页面命中次数为6次，缺页次数为4次。
OPT（最佳）页面置换算法是一种理论上的最优算法，可以最大程度地减少缺页次数。
fifo页面置换算法例题详解
fifo页面置换算法例题详解FIFO（First In, First Out）页面置换算法是一种最简单的页面置换算法，它根据页面调入内存的顺序进行页面置换。
当发生页面缺失时，选择最早调入内存的页面进行置换。
下面是一个使用FIFO页面置换算法解决页面置换问题的例题：假设一个系统的物理内存容量为3个页面，而作业需要访问9个页面。
作业在以下指令序列中运行：1，2，3，4，1，2，5，1，2。
假设在开始时，物理内存中没有页面。
使用FIFO页面置换算法，计算缺页次数。
解题步骤如下：1. 创建一个长度为3的队列，用于保存当前在内存中的页面。
2. 从指令序列中取出第一个页面1。
由于物理内存中没有页面，将页面1调入物理内存，并将1加入队列中。
3. 继续从指令序列中取出页面2。
由于物理内存中只有页面1，将页面2调入物理内存，并将2加入队列中。
4. 继续从指令序列中取出页面3。
由于物理内存中有页面1和2，将页面3调入物理内存，并将3加入队列中。
5. 继续从指令序列中取出页面4。
由于物理内存中已满，需要进行页面置换。
由于页面1是最早调入内存的页面，所以选择页面1进行置换。
将页面4调入物理内存，并将4加入队列中。
6. 继续从指令序列中取出页面1。
由于物理内存中已满，需要进行页面置换。
由于页面2是最早调入内存的页面，所以选择页面2进行置换。
将页面1调入物理内存，并将1加入队列中。
7. 继续从指令序列中取出页面2。
由于物理内存中已满，需要进行页面置换。
由于页面3是最早调入内存的页面，所以选择页面3进行置换。
将页面2调入物理内存，并将2加入队列中。
8. 继续从指令序列中取出页面5。
由于物理内存中已满，需要进行页面置换。
由于页面4是最早调入内存的页面，所以选择页面4进行置换。
将页面5调入物理内存，并将5加入队列中。
9. 继续从指令序列中取出页面1。
由于物理内存中已满，需要进行页面置换。
由于页面1是最早调入内存的页面，所以选择页面1进行置换。
操作系统页面置换算法例题
（1）最佳置换算法（OPT) ：选择以后永不使用或在最长时间内不再被访问的
内存页面予以淘汰。
（2）先进先出置换算法（FIFO）：选择最先进入内存的页面
予以淘汰。
（3）最近最久未使用算法（LRU）：选择在最近一段时间内最久没
有使用过的页，把它淘汰。
（4）最少使用算法（LFU）：选择到当前时间为止
被访问次数最少的页转换。
【例4-8】在一个请求分页存储管理的系统中，一个程序的页面走向为
6,0,1,2,0,3,0,4,2,3,分别采用最佳置换算法、先进先出置换算法、最近最久未使用
算法，完成下列要求。
设分配给该程序的存储块数M=3,每调进一个新页就发生
一次缺页中断。
时刻12345678910
访问顺序6012030423
M=3
f
OPT
时刻12345678910访问顺序6012030423
M=36662222222
000000444
11133333 f123456
FIFO
时刻12345678910访问顺序6012030423 M=36662222444
000033322
11110003 f123456789 LRU
时刻12345678910访问顺序6012030423 M=312030423
001203042 6660122304 f12345678。
页面置换算法模拟实验 操作系统大作业(含源文件)
“计算机操作系统”课程设计大作业页面置换算法模拟实验(含完整资料，可直接提交)一、题目: 页面置换算法模拟实验二、目的分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法对用户输入的页面号请求序列进行淘汰和置换，从而加深对页面置换算法的理解。
三、内容和要求请用C/C++语言编一个页面置换算法模拟程序。
用户通过键盘输入分配的物理内存总块数，再输入用户逻辑页面号请求序列，然后分别采用最佳(Optimal)置换算法、先进先出(FIFO)页面置换算法和最近最少使用(LRU)置换算法三种算法对页面请求序列进行转换，最后按照课本P150页图4-26的置换图格式输出每次页面请求后各物理块内存放的虚页号，并算出总的缺页率（缺页次数/总的请求次数）。
最后三种页面置换算法的优缺点。
三种页面置换算法的思想可参考教材P149-P152页。
假设页面号请求序列为4、3、2、1、4、3、5、4、3、2、1、5，当分配给某进程的物理块数分别为3块和4块时，试用自己编写的模拟程序进行页面转换并输出置换图和缺页次数、缺页率。
四、提交内容本大作业每个人必须单独完成。
最后需提交的内容包括：源程序（关键代码需要注释说明）、可运行程序、运行结果、算法思路及流程图、心得体会。
大作业严禁抄袭。
发现抄袭一律以不及格论。
请大家严格按照大作业题目来编写程序，不要上交以前布置的大作业。
如果提交的大作业题目与本文档要求不符，成绩一律为及格。
目录摘要 (2)正文 (2)1、设计思路 (3)2、各模块的伪码算法 (6)3、函数的调用关系图 (8)4、测试 (13)设计总结 (15)参考文献 (16)致谢 (17)附录：部分源程序代码 (18)摘要UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
操作系统课设报告页面置换算法
武汉轻工大学数学与计算机学院《操作系统》课程设计说明书题目：页式虚拟存储管理页面置换算法专业：班级：学号：姓名：指导老师：2015年5月26日目录一、设计目的二、设计内容三、基本原理和解决方案四、实验内容五、流程图六、源代码七、运行结果八、实验总结（心得体会）一、设计目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二、设计内容阅读教材《计算机操作系统》第四章，掌握存储器管理相关概念和原理。
模拟实现页式虚拟存储管理的三种页面置换算法（OPT、FIFO和LRU），并通过比较性能得出结论。
前提：（1）页面分配采用固定分配局部置换。
（2）作业的页面走向和分得的物理块数预先指定。
可以从键盘输入也可以从文件读入。
（3）置换算法的置换过程输出可以在显示器上也可以存放在文件中，但必须清晰可读，便于检验。
三、基本原理和解决方案存储管理是操作系统进行资源管理的一个重要功能。
现代操作系统广泛采用虚拟存储的技术对内存进行扩充。
实现虚拟存储的一个主要技术手段就是将辅存和主存统一管理，在二者之间进行对换，从而形成物理上两级而逻辑上一级的存储管理系统。
一个置换算法的好坏对这个逻辑上的单级虚存的性能起着极其重要的作用，而且会影响处理机的调度性能。
对于本任务规定的前提：页面分配采用固定分配局部置换，则置换发生的时机是作业已经将操作系统分配的固定数目的物理块全部用完且发生缺页的时候。
此时必须要将已经装入内存的部分逻辑页面换出以便将所缺的页面调入内存。
置换算法就是一个决定将内存中“哪一个”页面换出的算法。
四、实验内容1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
fifo置换算法练习题
fifo置换算法练习题FIFO置换算法的练习题一直是操作系统学习中的重要部分，通过这些练习题可以帮助我们更好地理解和掌握FIFO置换算法的原理和应用。
本文将通过一些实例和案例，讨论并解答一些与FIFO置换算法相关的练习题。
首先，让我们来考虑一个简单的情境。
假设一个内存页框（Memory Page Frame）的容量为3，而进程（Process）需要执行的指令序列为：A, B, C, D, E, F, G。
按照FIFO置换算法的原则，如果没有缺页（Page Fault）,指令序列将依次装入内存页框中，直到内存页框满为止。
当指令序列A到G逐个执行时，内存页框的变化如下：1. 初始状态：空2. 执行A指令：A3. 执行B指令：A, B4. 执行C指令：A, B, C5. 执行D指令：B, C, D (此时A被替换出去)6. 执行E指令：C, D, E (此时B被替换出去)7. 执行F指令：D, E, F (此时C被替换出去)8. 执行G指令：E, F, G (此时D被替换出去)这个例子清晰地展示了FIFO置换算法的工作原理。
当页框满时，新的页必须将最早载入内存的页替换出去。
但需要注意的是，当一个页被替换出去时，它如果在将来还会被访问到，就会导致缺页中断和数据的重新加载，从而影响系统性能。
接下来，我们来解答一个稍微复杂一些的练习题。
假设一个进程的指令序列为：A, B, C, C, D, E, A, F, G, B。
内存页框的容量为4。
根据FIFO置换算法的原则，计算出指令序列执行过程中的缺页次数和缺页率。
根据上述序列的执行过程，我们可以得到以下结果：1. 初始状态：空2. 执行A指令：A3. 执行B指令：A, B4. 执行C指令：A, B, C5. 执行C指令：A, B, C (发生缺页，但页框中已存在相同页)6. 执行D指令：B, C, D (C被替换出去)7. 执行E指令：C, D, E (B被替换出去)8. 执行A指令：D, E, A (C被替换出去)9. 执行F指令：E, A, F (D被替换出去)10. 执行G指令：A, F, G (E被替换出去)11. 执行B指令：F, G, B (A被替换出去)通过对指令序列执行过程的跟踪，可以发现缺页次数为5。
实验三页面置换算法
操作系统实验报告班级：姓名：学号：实验三：页面置换算法一、实验目的1、熟悉内存分页管理策略。
2、编写OPT、FIFO、LRU，LFU四种置换算法并模拟实现。
3、锻炼知识的运用能力和实践能力。
二、实验内容设计主界面，输入一串系列模拟页面请求，实现以下算法：1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)三、代码及运行结果分析#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 read();void mDelay(unsigned int Delay);int main(){int i,k,code;printf("请输入物理块的个数(M<=10)：");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100)："); scanf("%d",&pSIZE);puts("请依次输入页面号引用串：");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);read();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");exit(0);default:printf("输入错误，请重新输入：");}printf("按任意键重新选择置换算法：>>>"); getchar();}while (code!=4);getchar();}void read(){int i;for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++) {mDelay((pSIZE+mSIZE)/2);printf(">"); }printf("获取成功，按任意键进入置换算法选择界面：");getchar(); }void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}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]);}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;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;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; /*记录该页的访问时间*/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;for(i=0;i<mSIZE;i++) {memery[i]=page[i];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;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);}四、实验心得。
页面置换算法的模拟-(1)
课程设计报告课程名称：操作系统实验题目：页面置换算法的模拟日期：2010.07.01目录一、课程设计分析 (3)二、相关知识 (3)三、功能设计分析 (4)四、程序设计 (4)五、运行截图 (5)六、参考程序 (7)七、结果分析 (15)八、心得体会 (15)一、课程设计分析编写程序实现页面置换算法中常用的FIFO、LRU。
FIFO页面置换算法：FIFO淘汰算法是最先使用的页面最先被淘汰。
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。
先进先出(FIFO)页面置换算法，是根据页面调入内存后的使用情况进行决策的。
该算法是选择在内存中驻留时间最久的页面予以淘汰。
该算法赋于请求调入页面一个空间（工作集），淘汰掉最先调入的页，取而代之的是紧随它进来的页，这样就基本上实现了对最先进入内存的页面的淘汰。
LRU页面置换算法：该算法淘汰的页面是在最近一段时间里较久未被访问的那一页，它是根据程序执行时的局部性原理而设计的。
二、相关知识1．虚拟存储器的引入局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
页面置换算法大题
页面置换算法大题摘要：1.页面置换算法简介2.页面置换算法分类a.最近最少使用(LRU)算法b.先进先出(FIFO)算法c.最近最不经常使用(LFU)算法d.时钟(Clock)算法3.页面置换算法性能评估4.页面置换算法在实际应用中的案例5.总结与展望正文：页面置换算法是在计算机内存管理中常用的一种算法，主要用于处理内存中页面不足的问题。
当内存中的空闲空间不足以容纳新的页面时，就需要选择一个或多个已存在的页面进行替换，以腾出空间来存放新页面。
页面置换算法就是用来决定哪些页面应该被替换的算法。
页面置换算法主要分为四类：最近最少使用(LRU)算法、先进先出(FIFO)算法、最近最不经常使用(LFU)算法和时钟(Clock)算法。
这四类算法各有优缺点，适用于不同的场景。
LRU算法是一种基于页面访问频率的替换策略，它会优先淘汰访问次数最少的页面。
这种算法的优点是简单易懂，容易实现，缺点是无法准确预测未来的访问频率，可能导致某些经常使用的页面被替换。
FIFO算法是一种基于页面进入内存时间的替换策略，它会优先淘汰最早进入内存的页面。
这种算法的优点是公平性较好，缺点是可能导致某些经常使用的页面被替换。
LFU算法是一种基于页面访问次数与访问时间的替换策略，它会优先淘汰访问次数最少且访问时间最长的页面。
这种算法的优点是能够较好地平衡页面使用频率与使用时间，缺点是实现复杂度较高。
Clock算法是一种基于页面访问时间的替换策略，它将内存中的页面分为若干个时间轮，根据页面在时间轮中的位置决定其优先级。
这种算法的优点是能够较好地平衡页面使用频率与使用时间，缺点是实现复杂度较高。
在评估页面置换算法的性能时，通常会使用命中率、页面置换次数、缺页率等指标。
命中率是指CPU从内存中直接读取指令和数据的次数与CPU从内存中读取指令和数据的总次数之比；页面置换次数是指在一段时间内，需要进行页面置换的次数；缺页率是指在一段时间内，发生缺页中断的次数与CPU执行指令的总次数之比。
页面置换算法(操作系统试验)
实验4 页面置换算法（2学时）一、实验目的通过实验加强对虚拟存储管理中页面置换算法的理解和掌握。
二、实验内容编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法。
三、实验要求1、任意给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。
2、分配给该作业一定的物理块（如3块、4块等）。
3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。
4、每访问一个页面均需给出内存中的内容（内存中的页面号），若有淘汰还需给出淘汰的页面号。
5、通过给出特殊的页面访问顺序，分配不同的物理块，利用FIFO 算法计算其缺页率，进一步理解Belady现象。
6、（附加）实现CLOCK置换算法，修改位可在确定页面号时直接任意给出。
代码部分：#include <stdlib.h>#include <iostream.h>#include <time.h>void rand(int n,int p[])//这函数是产生n个1~10的随机数放到p[]数组里面{int START=1;int END=10;int v;int i;int a;srand(time(NULL));for(i=0; i<n; i++){v=rand()%(END-START+1)+START;p[i]=v;cout<<v;}}struct Pro{int num,time;//num存放具体的内容，time在不同算法里面有不同的意义}; //它们是物理块和页面的数据结构int Input(int m,int N,Pro *p,Pro *page)//完成p[]数组和page[]的初始化工作{ //p[]数组是存放页面的空间，m是页面的长度//page[]是可以使用的物理块，N是物理块的大小cout<<endl<<"请输入各页面号"<<endl;int *p2=new int[m];rand(m,p2);for(int i=0;i<m;i++){p[i].num=p2[i];p[i].time=0;}for(i=0;i<N;i++)//初试化页面基本情况{page[i].num=0;page[i].time=N+2-i;}return m;}int Search(int e,Pro *page,int N)//算法里面都要用到它。
opt页面置换算法例题详解
opt页面置换算法例题详解Opt页面置换算法例题简介在操作系统中，页面置换算法是一种解决内存管理问题的重要方法。
其中，Opt（Optimal）页面置换算法是一种理想化的算法，通过预测页面未来的访问情况，选择最有可能被访问的页面进行置换。
本文将以一个例题为例，详细解释Opt页面置换算法的工作原理。
问题描述假设有一个内存页表，大小为3，初始状态为空。
现有一个页面访问序列：1，2，3，4，1，2，5，1，2，3，4，5。
要求根据这个页面访问序列，使用Opt页面置换算法来进行页面置换，并给出每一步的置换情况和最终的缺页率。
解题步骤1.首先将页面1放入内存中，此时内存的状态为[1, -, -]，缺页数为1。
2.页面2访问时，将页面2放入内存中，内存状态变为[1, 2, -]，缺页数变为2。
3.页面3访问时，将页面3放入内存中，内存状态变为[1, 2, 3]，缺页数变为3。
4.页面4访问时，发现内存中已经包含了页面1、2、3，因此不需要进行页面置换，内存状态保持不变，缺页数不变。
5.页面1再次访问时，发现内存中已经包含了页面1、2、3，因此不需要进行页面置换，内存状态保持不变，缺页数不变。
6.页面2再次访问时，发现内存中已经包含了页面1、2、3，因此不需要进行页面置换，内存状态保持不变，缺页数不变。
7.页面5访问时，发现内存中已经包含了页面1、2、3，因此需要进行页面置换。
根据页面5后续访问情况来看，最佳的置换页面是页面1，因为它是最晚才会被访问到的页面。
将页面5放入内存中，将页面1置换出去，内存状态变为[5, 2, 3]，缺页数变为4。
8.页面1再次访问时，发现内存中已经包含了页面1、2、3，因此不需要进行页面置换，内存状态保持不变，缺页数不变。
9.页面2再次访问时，发现内存中已经包含了页面1、2、3，因此不需要进行页面置换，内存状态保持不变，缺页数不变。
10.页面3再次访问时，发现内存中已经包含了页面1、2、3，因此不需要进行页面置换，内存状态保持不变，缺页数不变。
最佳页面置换算法例题
最佳页面置换算法例题
最佳页面置换算法是一种用于将一组页面按照某种规则进行页
边距和布局调整的算法。
下面是一个简单的例题,用于说明如何使用
最佳页面置换算法:
假设有一组文档,共10页,每页有4个页面。
每个页面的大小和
位置都已知,现在需要将这些文档按最佳页面置换算法进行调整,使
得每页的页面数量最少,页面距离最合理。
1. 确定每页需要的页面数量
每页需要的页面数量可以通过以下公式计算:
每页需要的页面数量 = (页数× 2 + 1) / 2
例如,第5页需要的页面数量为(5 × 2 + 1) / 2 = 8/2 = 4页。
2. 确定页面的位置和大小
接下来,需要确定每页应该包含哪些页面。
一种方法是从左到右,从上到下遍历每个页面,并在每个页面上标记出需要保留的页面数量。
例如,在第5页上,需要保留4个页面,所以标记为4个红色矩形。
另一种方法是使用布局算法来确定页面的位置和大小。
例如,可
以使用仿宋字体来设计一个布局,使得每页包含以下页面:第一页、第二页、第三页、第四页和第五页。
3. 调整文档布局
根据标记的数量和位置,使用最佳页面置换算法将文档进行布局
调整。
例如,对于上述例子,第5页应该包含以下页面:第一页、第二页、第三页、第四页和第五页。
4. 检查布局是否合理
最后,需要检查调整后的文档布局是否合理。
例如,如果在某个页面上使用了过多的页面,就需要重新调整页面数量或调整页面的位置。
最佳页面置换算法是一种常用的文档布局算法,可以帮助设计师
和开发人员高效地设计文档布局,提高文档的可读性和可用性。
页面置换算法大题
页面置换算法大题摘要：一、页面置换算法简介1.页面置换算法的概念2.页面置换算法的重要性二、页面置换算法分类1.最近最少使用（LRU）算法2.先进先出（FIFO）算法3.时钟（Clock）算法4.最近最不经常使用（LFU）算法三、各类页面置换算法的优缺点分析1.LRU 算法2.FIFO 算法3.Clock 算法4.LFU 算法四、实际应用中页面置换算法的选择1.根据应用场景选择2.结合系统需求选择3.考虑性能与成本的平衡正文：页面置换算法是在计算机内存管理中的一种技术，用于在内存中分配有限资源以满足不断变化的程序需求。
本文将介绍页面置换算法的相关知识，包括页面置换算法的概念、分类、优缺点分析以及在实际应用中的选择。
一、页面置换算法简介页面置换算法是一种在内存中进行页面调度的方式，用于在有限的内存空间中合理地存放不同程序的页面。
通过页面置换算法，可以有效地提高内存利用率，降低缺页中断次数，从而提高系统性能。
二、页面置换算法分类目前常用的页面置换算法主要有四种：最近最少使用（LRU）算法、先进先出（FIFO）算法、时钟（Clock）算法和最近最不经常使用（LFU）算法。
1.LRU 算法：根据页面最近一段时间内被访问的次数来选择需要替换的页面。
当需要为新页面腾出空间时，选择访问次数最少的页面进行替换。
2.FIFO 算法：按照页面进入内存的顺序进行置换，先进入内存的页面先被替换。
3.Clock 算法：模拟时钟指针，将页面分为几个相等的时间片，每次选择距离当前时间片最近的页面进行替换。
4.LFU 算法：根据页面访问次数来选择需要替换的页面，访问次数最多的页面优先被替换。
三、各类页面置换算法的优缺点分析不同类型的页面置换算法各有优缺点，具体选择需要根据实际应用场景和系统需求进行权衡。
1.LRU 算法：优点是可以有效地减小页面中断率，缺点是对页面访问历史记录的维护成本较高。
2.FIFO 算法：优点是实现简单，缺点是可能导致经常使用的页面被替换，降低系统性能。
opt,fifo,lru算法例题置换次数
opt,fifo,lru算法例题置换次数以下是一个使用OPT、FIFO和LRU算法进行页面置换的例子：假设某程序的页面访问序列为1、2、3、4、5、2、3、1、2、3、4、5、1、2、3、4，并且开始执行时主存中没有页面，分配给该程序的物理块数是3。
1. 使用OPT（最佳置换算法）进行页面置换：第一次访问1，缺页，进入内存。
第二次访问2，缺页，进入内存。
第三次访问3，缺页，进入内存。
第四次访问4，缺页，进入内存。
第五次访问5，缺页，需要淘汰一个页面。
根据OPT算法，选择最长时间不会被访问的页面进行淘汰，即选择页面3进行淘汰。
第六次访问2，页面2在内存中，无需置换。
第七次访问3，页面3在内存中，无需置换。
第八次访问1，缺页，进入内存。
第九次访问2，页面2在内存中，无需置换。
第十次访问3，页面3在内存中，无需置换。
第十一次访问4，缺页，需要淘汰一个页面。
根据OPT算法，选择最长时间不会被访问的页面进行淘汰，即选择页面1进行淘汰。
第十二次访问5，缺页，需要淘汰一个页面。
根据OPT算法，选择最长时间不会被访问的页面进行淘汰，即选择页面4进行淘汰。
第十三次访问1，页面1在内存中，无需置换。
第十四次访问2，页面2在内存中，无需置换。
第十五次访问3，页面3在内存中，无需置换。
第十六次访问4，缺页，需要淘汰一个页面。
根据OPT算法，选择最长时间不会被访问的页面进行淘汰，即选择页面5进行淘汰。
总共进行了5次页面置换。
2. 使用FIFO（先进先出置换算法）进行页面置换：第一次访问1，缺页，进入内存。
第二次访问2，缺页，进入内存。
第三次访问3，缺页，进入内存。
第四次访问4，缺页，进入内存。
第五次访问5，缺页，需要淘汰一个页面。
根据FIFO算法，选择最早进入内存的页面进行淘汰，即选择页面3进行淘汰。
第六次访问2，页面2在内存中，无需置换。
第七次访问3，页面3在内存中，无需置换。
第八次访问1，缺页，进入内存。
第九次访问2，页面2在内存中，无需置换。
操作系统之页面置换算法（最佳置换OPT，先进先出FIFO，最近最久未使用LRU）
操作系统之页⾯置换算法（最佳置换OPT，先进先出FIFO，最近最久未使⽤LRU）最近学习操作系统时，实验要求实现常见的三种页⾯置换算法，博主按照书上要求试着编写，实现了案例，并记录在博客随记中，以便后续⾃⼰复习并也给需要的同学分享参考⼀下!⽔平有限，若有错，请悄悄告诉博主！博主好⽴即改正。
最佳置换算法（optimal replacement，OPT）是从内存中选择今后不再访问的页⾯或者在最长⼀段时间后才需要访问的页⾯进⾏淘汰。
如下例⼦：根据页⾯⾛向依次处理，得到最终的置换结果如下图表，整个页⾯缺页次数为7，缺页率为7/12=58%。
1 #include <iostream>2 #include <stdio.h>3 #include <stdlib.h>4#define N 125#define B 36using namespace std;78int pageArr[N]={1,2,3,4,1,2,5,1,2,3,4,5};//页⾯⾛向9int block[B]={0};//物理块3个，其数值是页号10 typedef struct FLAG {11int flags[B];12int counts;13 } FLAG;1415void opt(int pageArr[],int block[]);16int inBlock(int which);17int findFar(int next);18void Replace(int index,int value);19void disPlay();2021int main(void){22 cout << "begin:" <<endl;23 opt(pageArr,block);24 cout << "end!" <<endl;25return0;26 }2728void opt(int pageArr[],int block[]){29int getIndex;30for(int i=0;i<N;i++){31if(i<3){//前3页号#短缺#进队列32 block[i]=pageArr[i];33 printf("缺页：(null)-->%d\n",pageArr[i]);34 }35else {36if(i==3){37 disPlay();3839 }40if(inBlock(pageArr[i])!=-1){//下⼀个页⾯if在物理块中返回index并跳过,反-141 disPlay();4243continue;44 }45 getIndex=findFar(i+1);//从下⼀个页号，找到最远出现的页⾯,替换的下标46if(getIndex==-1){47 cout<<"error,not replace obj!"<<'\t';48 }49else{50 Replace(getIndex,pageArr[i]);//由下标找到上⼀组替换⽬标，⽤第⼆参数替换51 disPlay();5253 }54 }55 }56return;57 }5859//替换block中的物理块60void Replace(int index,int value){61 printf("缺页：%d--被替换为-->%d\n",block[index],value);62 block[index]=value;63return;64 }656667//找到最远出现的页⾯68int findFar(int next){69int index=-1;//error，默认返回不存在的索引70 FLAG myflag;71 myflag.flags[0]=0;72 myflag.flags[1]=0;73 myflag.flags[2]=0;74 myflag.counts=0;75int stop = N-next;76while(stop--){77 index=inBlock(pageArr[next++]);78if(index!=-1){79 myflag.flags[index]=1;80 myflag.counts++;83break;84 }85 }86for(index=0;index<B;index++){87if(myflag.flags[index]==0)88break;89 }90return index;91 }929394//下⼀个页⾯if在物理块中返回index,反-195int inBlock(int which){96//int i=0;97//while(i<B)98// if(block[i++]==which)99// return i-1;100for(int i=0;i<B;i++){101if(block[i]==which)102return i;103 }104return -1;105 }106107//打印⼀元组108void disPlay(){109int i=0;110while(i<B){111 printf("%d\t",block[i++]);112 }113 printf("\n");114return;115 }上⾯是博主使⽤C++（基本是C语法）编写的代码，运⾏结果如下：//////////////////////////////////////////////////////////////////////////begin:缺页：(null)-->1缺页：(null)-->2缺页：(null)-->31 2 3缺页：3--被替换为-->41 2 41 2 41 2 4缺页：4--被替换为-->51 2 51 2 51 2 5缺页：1--被替换为-->33 2 5缺页：3--被替换为-->44 2 54 2 5end!//////////////////////////////////////////////////////////////////////////先进先出算法：先进先出置换算法（first in first out,FIFO）是淘汰最先进⼊内存的页⾯，即选择在内存中驻留时间最长的页⾯进⾏淘汰的算法。
实验四 页面置换算法代码(一)
实验四页面置换算法模拟（2）一．题目要求：设计一个虚拟存储区和存工作区，编程序演示下述算法的具体实现过程，并计算访问命中率：要求设计主界面以灵活选择某算法，且以下算法都要实现1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间不再被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入存的页面，即选择在存中驻留时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)二．实验目的：1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。
2、熟悉存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三．相关知识：1．虚拟存储器的引入：局部性原理：程序在执行时在一较短时间仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义：虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式：分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配：平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
5．页面置换算法：常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
四．设计思想：选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换：OPT基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
页面置换算法的演示
一．实验要求：
设计一个虚拟存储区和内存工作区，编程序演示下述算法的具体实现过程，并计算访问命中率：
要求设计主界面以灵活选择某算法，且以下算法都要实现
1) 最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再
被访问的页面换出。
2) 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留
时间最久的页面予以淘汰。
3) 最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。
4) 最不经常使用算法(LFU)
二．实验目的：
1、用C语言编写OPT、FIFO、LRU，LFU四种置换算法。
2、熟悉内存分页管理策略。
3、了解页面置换的算法。
4、掌握一般常用的调度算法。
5、根据方案使算法得以模拟实现。
6、锻炼知识的运用能力和实践能力。
三．相关知识：
1．虚拟存储器的引入：
局部性原理：程序在执行时在一较短时间内仅限于某个部分；相应的，它所访问的存储空间也局限于某个区域，它主要表现在以下两个方面：时间局限性和空间局限性。
2．虚拟存储器的定义：
虚拟存储器是只具有请求调入功能和置换功能，能从逻辑上对内存容量进行扩充的一种存储器系统。
3．虚拟存储器的实现方式：
分页请求系统，它是在分页系统的基础上，增加了请求调页功能、页面置换功能所形成的页面形式虚拟存储系统。
请求分段系统，它是在分段系统的基础上，增加了请求调段及分段置换功能后，所形成的段式虚拟存储系统。
4．页面分配：
平均分配算法，是将系统中所有可供分配的物理块，平均分配给各个进程。
按比例分配算法，根据进程的大小按比例分配物理块。
考虑优先的分配算法，把内存中可供分配的所有物理块分成两部分：一部分按比例地分配给各进程；另一部分则根据个进程的优先权，适当的增加其相应份额后，分配给各进程。
5．页面置换算法：
常用的页面置换算法有OPT、FIFO、LRU、Clock、LFU、PBA等。
四．实验原理：
选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换：OPT基本思想：
是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组next[mSIZE]记录物理块中对应页面的最后访问时间。
每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。
【特别声明】
若物理块中的页面都不再使用，则每次都置换物理块中第一个位置的页面。
FIFO基本思想：
是用队列存储内存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。
或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最长的页面。
LRU基本思想：
是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组flag[10]标记页面的访问时间。
每当使用页面时，刷新访问时间。
发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。
五．流程图：
如下页所示
开始
载入页号序列，从第0个得到页号
将页号放入物理块中，编号加1
否
引用串编号大
于物理块数?
是
否
页号在物理块中?
是
根据选择的置换算法完成置换
否
页号序列载完?
是
结束
六．运行结果：
【运行环境——Visual C++ 6.0】
1. 按任意键进行初始化：
1
2. 载入数据：
1
3. 进入置换算法选择界面：
4.运算中延迟操作：
5.三种算法演示结果：。