页面置换算法模拟程序-附代码
页面置换算法实验(内含完整代码)
实验二存储管理一、实验目的通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验内容基于一个虚拟存储区和内存工作区，设计下述算法并计算访问命中率。
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。
页面置换算法模拟程序-附代码
页⾯置换算法模拟程序-附代码⽬录1．问题的提出 (2)1.1关于页⾯置换算法模拟程序问题的产⽣ (2)1.2任务分析 (2)2．需求分析 (2)3．⽅案设计 (3)4．总体设计 (4)4.1程序N-S图 (4)4.2主要的函数 (4)4.3主要流程图及代码 (5)4.3.1 FIFO（先进先出） (5)4.3.2 LRU（最近最久未使⽤） (6)4.3.3 OPT（最佳置换算法） (8)4.4实现结果 (11)5．程序测试 (14)5.1设计测试数据 (14)5.2测试结果及分析 (15)摘要随着计算机的普及⼈们的物质⽣活得到了极⼤的满⾜，⼈们在精神⽣活⽅⾯同样也需要提⾼，所以越来越多的⼈进⾏着各种各样的学习。
操作系统是计算机教学中最重要的环节之⼀，也是计算机专业学⽣的⼀门重要的专业课程。
操作系统质量的好坏，直接影响整个计算机系统的性能和⽤户对计算机的使⽤。
⼀个精⼼设计的操作系统能极⼤地扩充计算机系统的功能，充分发挥系统中各种设备的使⽤效率，提⾼系统⼯作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理，内容⽐较繁琐，具有很强的实践性。
要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果.本课程设计是学⽣学习完《操作系统教程》课程后，进⾏的⼀次全⾯的综合训练，通过课程设计，让学⽣更好地掌握操作系统的原理及实现⽅法,加深对操作系统基础理论和重要算法的理解，加强学⽣的动⼿能⼒。
熟悉页⾯置换算法及其实现，引⼊计算机系统性能评价⽅法的概念。
关键词：编制页⾯置换算法模拟程序、打印页⾯、FIFO页⾯算法、LRU页⾯置换算法、OPT页⾯置换算法。
引⾔1．问题的提出1.1关于页⾯置换算法模拟程序问题的产⽣在各种存储器管理⽅式中，有⼀个共同的特点，即它们都要求将⼀个作业全部装⼊内存⽅能运⾏，但是有两种情况：（1）有的作业很⼤，不能全部装⼊内存，致使作业⽆法运⾏；（2）有⼤量作业要求运⾏，但内存容量不⾜以容纳所有这些作业。
《操作系统》实验五：页面置换算法模拟
实验五. 请求页式存储管理的模拟[实验内容]:熟悉虚拟存储管理的各种页面置换算法，并编写模拟程序实现请求页式存储管理的页面置换算法----最近最久未使用算法（LRU），要求在每次产生置换时显示页面分配状态和缺页率。
[实验要求]：1、运行给出的实验程序，查看执行情况，进而分析算法的执行过程，在理解FIFO页面置换算法和最近最久未使用算法（LRU）置换算法后，给出最佳置换算法的模拟程序实现，并集成到参考程序中。
2、执行2个页面置换模拟程序，分析缺页率的情况。
最好页框数和访问序列长度可调节，在使用同一组访问序列数据的情况下，改变页框数并执行2个页面置换模拟程序，查看缺页率的变化。
3、在每次产生置换时要求显示分配状态和缺页率。
程序的地址访问序列通过随机数产生，要求具有足够的长度。
最好页框数和访问序列长度可调节。
实验的执行结果如下图所示（左下图为FIFO执行结果，右下图为LRU执行结果）：程序源代码： #include <libio.h> #include "windows.h" #include <conio.h>#include <stdlib.h>#include <fstream.h>#include <io.h>#include <string.h>#include <stdio.h>void initialize(); //初始化相关数据结构void createps(); //随机生成访问序列void displayinfo(); //显示当前状态及缺页情况void fifo(); //先进先出算法int findpage(); //查找页面是否在内存void lru(); //最近最久未使用算法int invalidcount = 0; // 缺页次数int vpoint; //页面访问指针int pageframe[10]; // 分配的页框int pagehistory[10]; //记录页框中数据的访问历史int rpoint; //页面替换指针int inpflag; //缺页标志，0为不缺页，1为缺页struct PageInfo //页面信息结构{int serial[100]; // 模拟的最大访问页面数，实际控制在20以上int flag; // 标志位，0表示无页面访问数据int diseffect; // 缺页次数int total_pf; // 分配的页框数int total_pn; // 访问页面序列长度} pf_info;//////////////////////////////////////////////////////////////////////// //初始化相关数据结构void initialize(){int i,pf;inpflag=0; //缺页标志，0为不缺页，1为缺页pf_info.diseffect =0; // 缺页次数pf_info.flag =0; // 标志位，0表示无页面访问数据printf("\n请输入要分配的页框数："); // 自定义分配的页框数scanf("%d",&pf);pf_info.total_pf =pf;for(i=0;i<100;i++) // 清空页面序列{pf_info.serial[i]=-1;}}///////////////////////////////////////////////////////////////////// 随机生成访问序列void createps(void ){int s,i,pn;initialize(); //初始化相关数据结构printf("\n请输入要随机生成访问序列的长度："); //自定义随机生成访问序列的长度scanf("%d",&pn);srand(rand()); //初始化随机数队列的"种子"s=((float) rand() / 32767) * 50 + pn; // 随机产生页面序列长度pf_info.total_pn = s;for(i=0;i<s;i++) //产生随机访问序列{pf_info.serial[i]=((float) rand() / 32767) * 16 ; //随机数的大小在0-15之间}}////////////////////////////////////////////////////////////////////////// 显示当前状态及缺页情况void displayinfo(void){int i,n;if(vpoint==0){printf("\n=============页面访问序列=============\n");for(i=0; i<pf_info.total_pn; i++){printf("%4d",pf_info.serial[i]);if ((i+1) % 10 ==0) printf("\n"); //每行显示10个}printf("\n======================================\n"); }printf("访问%3d : 内存<",pf_info.serial[vpoint]);for(n=0;n<pf_info.total_pf;n++) // 页框信息{if (pageframe[n] >=0)printf("%3d",pageframe[n]);elseprintf(" ");}printf(" >");if(inpflag==1) //缺页标志，0为不缺页，1为缺页{printf(" ==>缺页");printf("缺页率%3.1f",(float)(pf_info.diseffect)*100.00/vpoint);}printf("\n");}//////////////////////////////////////////////////////////////////////// // 查找页面是否在内存，1为在内存，0为不在即缺页int findpage(int page){int n;for(n=0;n<pf_info.total_pf;n++){pagehistory[n] ++; // 访问历史加1}for(n=0;n<pf_info.total_pf;n++){if (pageframe[n]==page ){inpflag=0 ; //inpflag缺页标志，0为不缺页，1为缺页pagehistory[n]=0; //置访问历史为0return 1;}}inpflag=1; //页面不存在，缺页return 0;}//////////////////////////////////////////////////////////////////////// // FIFO页面置换算法void fifo(void){int n,count,pstate;rpoint=0; // 页面替换指针初始化为0invalidcount = 0; // 缺页数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满是所有的页框for(n=0;n<pf_info.total_pf;n++) // 清除页框信息{pageframe[n]=-1;}inpflag=0; //缺页标志，0为不缺页，1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0) // 页不存在则置换页面{pageframe[rpoint]=pf_info.serial[vpoint];rpoint=(rpoint+1) % pf_info.total_pf;pf_info.diseffect++; // 缺页次数加1 }}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束getch();return;}/////////////////////////////////////////////////////////////////// // LRU页面置换算法void lru(void){int n,count,pstate,max;rpoint=0; // 页面替换指针invalidcount = 0; // 缺页次数初始化为0createps(); // 随机生成访问序列count=0; // 是否装满所有的页框for(n=0;n<pf_info.total_pf;n++){pageframe[n]=-1; // 清除页框信息pagehistory[n]=0; // 清除页框历史}inpflag=0; //缺页标志，0为不缺页，1为缺页for(vpoint=0;vpoint<pf_info.total_pn;vpoint++) // 执行算法{pstate=findpage(pf_info.serial[vpoint]); //查找页面是否在内存if(count<pf_info.total_pf) // 开始时不计算缺页{if(pstate==0) // 页不存在则装入页面{pageframe[rpoint]=pf_info.serial[vpoint]; //把要调入的页面放入一个空的页框里rpoint=(rpoint+1) % pf_info.total_pf;count++;}}else // 正常缺页置换{if(pstate==0)// 页不存在则置换页面{max=0;for(n=1;n<pf_info.total_pf;n++){if(pagehistory[n]>pagehistory[max]){max=n;}}rpoint=max;pageframe[rpoint]=pf_info.serial[vpoint];pagehistory[rpoint]=0;pf_info.diseffect++; // 缺页次数加1 }}Sleep(10);displayinfo(); // 显示当前状态} // 置换算法循环结束_getch();return;}/////////////////////最佳置换算法自己完成/////////////////////////////////////////////////////////////////// // 主函数int main(){char ch;system("cls") ;while ( true ){printf("*******************************************\n");printf(" 若要执行FIFO页面置算法请按1\n");printf(" 若要执行LRU 页面置算法请按2\n");printf(" 若要退出请按3\n") ;printf("*******************************************\n");printf( "Enter your choice (1 or 2 or 3): ");do{ //如果输入信息不正确，继续输入ch = (char)getch() ;}while(ch != '1' && ch != '2'&& ch != '3');printf("\n\n你按的是：%c ,现在为你执行对应操作。
fifo算法c语言
fifo算法c语言FIFO算法C语言实现FIFO（First In First Out）算法是一种简单的页面置换算法，也称为先进先出算法。
该算法的核心思想是将最先进入内存的页面最先淘汰，即将页表中最早调入内存的页面移出内存。
本文将介绍如何使用C语言实现FIFO算法。
一、FIFO算法原理1.1 页面置换在操作系统中，为了提高程序运行效率，会将程序需要用到的数据和指令从硬盘上加载到内存中。
但是内存有限，无法容纳所有程序需要用到的数据和指令。
当内存不足时，就需要进行页面置换。
页面置换就是将当前正在使用但又不常用的页面从内存中移出，并将新的页面调入内存。
在进行页面置换时，需要选择一个合适的页面置换算法。
1.2 FIFO算法FIFO算法是一种简单而常用的页面置换算法。
它以队列为基础，将最早进入队列的页面作为被淘汰的对象。
具体来说，在FIFO算法中，操作系统会维护一个队列来记录当前正在使用的所有页面。
当需要进行页面置换时，操作系统会选择队头元素对应的页面进行淘汰，并将新调入内存中的页面插入队尾。
二、FIFO算法C语言实现2.1 算法流程FIFO算法的实现流程如下：1. 初始化页面队列，将所有页面按照调入内存的时间顺序依次插入队列；2. 当需要进行页面置换时，将队头元素对应的页面移出内存，并将新调入内存中的页面插入队尾；3. 重复执行步骤2。
2.2 代码实现下面是使用C语言实现FIFO算法的示例代码：```c#include <stdio.h>#include <stdlib.h>#define MAX_PAGE_NUM 100 // 最大页面数#define MAX_MEM_SIZE 10 // 最大内存容量int page_queue[MAX_PAGE_NUM]; // 页面队列int mem[MAX_MEM_SIZE]; // 内存int queue_head = 0; // 队头指针int queue_tail = -1; // 队尾指针// 初始化页面队列void init_page_queue(int page_num) {for (int i = 0; i < page_num; i++) {page_queue[i] = i % MAX_MEM_SIZE;}}// 页面置换函数void page_replace(int new_page) {int old_page = page_queue[queue_head]; // 获取被淘汰的页面mem[old_page] = new_page; // 将新页面调入内存中queue_tail = (queue_tail + 1) % MAX_PAGE_NUM; // 更新队尾指针queue_head = (queue_head + 1) % MAX_PAGE_NUM; // 更新队头指针}int main() {int page_num = 20; // 页面数int miss_count = 0; // 缺页次数init_page_queue(page_num);for (int i = 0; i < page_num; i++) {int page = page_queue[i];if (mem[page] == 0) { // 页面不在内存中miss_count++;page_replace(page);}}printf("缺页次数：%d\n", miss_count);return 0;}```2.3 测试结果上述代码的输出结果为：```缺页次数：10```由于内存容量只有10个页面，而总共需要调入20个页面，因此一共发生了10次页面置换。
操作系统实验 页面置换算法模拟
实验四页面置换算法模拟一、实验内容简要描述开发语言及实现平台或实验环境C++/JA V ATurbo C / Microsoft Visual Studio 6.0 / Microsoft Visual Studio .NET 2010实验目的（1）了解内存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。
（5）了解页面大小和内存实际容量对命中率的影响。
【实验内容】编程实现页面置换算法，最少实现两种算法，比较算法的优劣，并将调试结果显示在计算机屏幕上，并检测机算和笔算的一致性。
【实验要求】（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及内存实际容量对命中率的影响；（2）实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟；（3）使用某种编程语言模拟页面置换算法。
二、报告主要内容1．设计思路A、设计页面走向、物理块数等初值。
B、编制程序，使用多种算法实现页面置换。
C、计算和比较缺页率。
最佳置换算法OPT(Optimal)它是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰页面，将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法，通常可保证获得最低的缺页率。
但由于人目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因而该算法是无法实现的，但是可以利用此算法来评价其它算法。
如果编写程序模拟该算法，可以提前设定页面访问次序，获知某个页面是否在未来不再被访问。
2．画流程图3.实验结果（输入、输出截图）程序运行结果4.主要代码#include "stdio.h"#include "stdlib.h"#include "math.h"#include "conio.h"#include "time.h"#define TRUE 1#define FALSE 0#define NULL 0#define total_instruction 20#define total_vp 10typedef struct{ int pn,pfn;}pv_type;pv_type pv[10];typedef struct pf_struct{ int pn,pfn;struct pf_struct *next;}pf_type;pf_type pf[20],*free_head,*busy_head,*busy_tail,*q; int page[total_instruction];int total_pf;int count;void initialiaze(){ int i;count=0;for(i=0;i<total_vp;i++){ pv[i].pn=i;pv[i].pfn=-1;}printf("请输入实页数目:");scanf("%d",&total_pf);for(i=0;i<=total_pf-1;i++){ pf[i].next=&pf[i+1];pf[i].pfn=i+1;pf[i].pn=-1;}pf[total_pf-1].next=NULL;free_head=&pf[0];printf("随机产生的页地址流为：\n");for(i=0;i<total_instruction;i++){ page[i]=rand()%10;printf("%2d",page[i]);}}void FIFO(){ int i,j;pf_type *p;q=busy_head=busy_tail=NULL;for(i=0;i<=total_instruction-1;i++){ printf("\n第%d次执行:",i+1);if(pv[page[i]].pfn==-1){ count+=1;printf("缺页，缺页次数count=%d,",count);if(free_head==NULL){printf("实页%d中的页面%d将被置换出去",busy_head->pfn,busy_head->pn);p=busy_head->next;pv[busy_head->pn].pfn=-1;free_head=busy_head;free_head->next=NULL;busy_head=p;}p=free_head->next;free_head->next=NULL;free_head->pn=page[i];pv[page[i]].pfn=free_head->pn;if(busy_tail==NULL)busy_head=busy_tail=free_head;else{ busy_tail->next=free_head;busy_tail=free_head;}free_head=p;}else printf("命中，缺页次数不变，仍为count=%d",count);printf("\npfn pn");for(j=0;j<=total_pf-1;j++){if(pf[j].pn!=-1)printf("\n%d%8d",pf[j].pfn,pf[j].pn);}}printf("\n先进先出算法的命中率为:%6.4f\n缺页总次数为%d\n",1-(float)count/20,count);}void main(){srand((unsigned)time(NULL));initialiaze();FIFO();三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。
页面置换算法模拟
#include <iostream>#include <deque> //deque容器头文件#include <ctime>using namespace std;typedef struct{int id;//页面IDint stayTime;//内存中驻留时间int unUseTime; //已经多久未被使用}CPage;deque<int> RunQueue;deque<CPage> interPage; //内存中的四个页面deque<CPage> exterPage; //外存中的N个页面int presentSeat; //目前运行到了队列的第几个？int lackNum[3] ={0};int getRandNum(int range) //返回[0,range)范围内的整数{return static_cast<int>(rand()%range);}int findPageIdByCmdId(int cmdId) //判断指令属于哪个页面{return static_cast<int>(cmdId/10);}void InitDevice() //初始化运行队列按照25% 50% 25%的标准生成{srand(static_cast<int>(time(NULL)));int t_cmdNum = getRandNum(320); //随机选择第一条指令RunQueue.push_back(t_cmdNum);if(t_cmdNum < 319)RunQueue.push_back(t_cmdNum+1); //顺序执行下一条指令while(RunQueue.size() <= 320){t_cmdNum=getRandNum(t_cmdNum); //跳转到m1属于[0,m-1] RunQueue.push_back(t_cmdNum); //将m1插入队列if(t_cmdNum < 319)RunQueue.push_back(t_cmdNum+1); //将m1+1插入队列int temp = 320 - (t_cmdNum + 2);t_cmdNum = t_cmdNum+2+getRandNum(temp);//跳转到m2属于[m+2,319]RunQueue.push_back(t_cmdNum); //插入队列if(t_cmdNum < 319)RunQueue.push_back(t_cmdNum+1); //将m2+1插入队列}while(RunQueue.size() > 320)RunQueue.pop_back();}stayTime = 0;temp. void InitMemoryQueue()//初始化运行标志、内存外存页面队列{presentSeat = 0;exterPage.clear();interPage.clear();for(int i=0;i<32;i++){CPage temp;temp.id = i;temp.unUseTime = 0;exterPage.push_back(temp);}}int searchStatusOfPage(int t_PageId,bool sign)//分别在内存中查找页面存在返回位置不存在返回-1 {if(sign)for(unsigned i=0;i<interPage.size();i++){if(t_PageId == interPage[i].id)return i;}elsefor(unsigned j=0;j<exterPage.size();j++)if(t_PageId == exterPage[j].id)return j;return -1;}int searchNextStatusOfInterPage(int start, int id) //OPT算法中查找内存页面中的页面下次需要用到它的时候的队列下标{for(int i=start;i < 320;i++)if(static_cast<int>(RunQueue[i]/10) == id)return i;return -1;}int findLongestStayTimePage()//FIFO算法中查找在内存中呆了最久的页面{int max = 0;for(unsigned i=1;i<interPage.size();i++)if(interPage[i].stayTime>interPage[max].stayTime)max = i;return max;}int findLongestUnUseTimePage()//LRU算法中查找最久未使用的页面{int max = 0;for(unsigned j=0;j<interPage.size();j++)if(interPage[j].unUseTime>interPage[max].unUseTime)max = j;return max;}int findNeedLongestTimePage() //OPT算法中查找最长时间不会用到的页面{deque<int> temp;for(unsigned i=0;i < interPage.size();i++){ Int it =searchNextStatusOfInterPage(presentSeat,interPage[i].id);if(it == -1)return i;temp.push_back(it);}int max = -1,status = 0;for(unsigned j=1;j < temp.size();j++){ if(max < temp[j]) {max = temp[j];status = j; }}return status; }//返回需要最长时间才执行的页面在内存的位置void directFlod(int t_PageId) //当内存有剩余时直接调入{ int status = searchStatusOfPage(t_PageId,false);if(status == -1) return;interPage.push_back(exterPage[status]); //插入节点到内存exterPage.erase(exterPage.begin()+status); }bool Manage(int count,int t_PageId) //内存满需按三种算法调度{ int status = searchStatusOfPage(t_PageId,false);//获取执行页面在外存中的索引地址if(status == -1) return false;int targetStatus = 0;if(count == 0)targetStatus = findNeedLongestTimePage();else if(count == 1)targetStatus = findLongestStayTimePage();else if(count == 2)targetStatus = findLongestUnUseTimePage(); interPage[targetStatus].stayTime = 0;interPage[targetStatus].unUseTime = 0;swap(exterPage[status],interPage[targetStatus]); return true; }void Run(int count) //通过count来决定使用什么算法{ while(presentSeat < 320){ for(unsigned i=0;i<interPage.size();i++){ interPage[i].stayTime++;interPage[i].unUseTime++;}int t_PageId =findPageIdByCmdId(RunQueue[presentSeat++]),stat us = -1;//找到当前将要执行的指令的页面号if((status =searchStatusOfPage(t_PageId,true)) != -1) { interPage[status].unUseTime = 0;continue;}lackNum[count]++;if(interPage.size()<4)directFlod(t_PageId);elseManage(count,t_PageId);} }void main(void){InitDevice();int count = 0;while(count<3){InitMemoryQueue();Run(count);cout<<(double)lackNum[count++]/320*100<<"%"<< endl; } }。
操作系统课程设计--页面置换算法的模拟实现_
操作系统课程设计--页面置换算法的模拟实现_ 题目: 页面置换算法的模拟实现_专业计算机科学与技术学生姓名班级学号指导教师发放日期信息工程学院目录1 概述 ..................................................................... .........................................................................12 设计原理 ..................................................................... .. (1)2.1 先进先出(FIFO)算法 ..................................................................... ...................................... 1 2.2 最近最久未使用(LRU)算法 ..................................................................... .......................... 1 3 详细设计与编码 ..................................................................... ..................................................... 2 3.1 模块设计 ..................................................................... .. (2)3.2 系统详细设计 ..................................................................... ...................................................... 2 4 结果与分析 ..................................................................... . (4)4.1 测试方案 ..................................................................... .. (4)4.2 测试结果 ..................................................................... .. (5)4.3测试结果分析 ..................................................................... . (8)5 设计小结 ..................................................................... .. (8)6 参考文献 ..................................................................... .. (9)附录程序代码 ..................................................................... (10)操作系统课程设计(2015)页面置换算法的模拟实现1 概述在进程运行过程中，若其所要访问的页面不在内存所需把他们调入内存，但内存已无空闲时，为了保证进程能够正常运行，系统必须从内存中调入一页程序或数据送磁盘的对换区中。
实验四页面置换算法代码（一）
实验四页面置换算法代码（一）预览说明:预览图片所展示的格式为文档的源格式展示,下载源文件没有水印,内容可编辑和复制实验四页面置换算法模拟（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等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1．问题的提出 (2)1.1关于页面置换算法模拟程序问题的产生 (2)1.2任务分析 (2)2．需求分析 (2)3．方案设计 (3)4．总体设计 (4)4.1程序N-S图 (4)4.2主要的函数 (4)4.3主要流程图及代码 (5)4.3.1 FIFO（先进先出） (5)4.3.2 LRU（最近最久未使用） (6)4.3.3 OPT（最佳置换算法） (8)4.4实现结果 (11)5．程序测试 (14)5.1设计测试数据 (14)5.2测试结果及分析 (15)摘要随着计算机的普及人们的物质生活得到了极大的满足，人们在精神生活方面同样也需要提高，所以越来越多的人进行着各种各样的学习。
操作系统是计算机教学中最重要的环节之一，也是计算机专业学生的一门重要的专业课程。
操作系统质量的好坏，直接影响整个计算机系统的性能和用户对计算机的使用。
一个精心设计的操作系统能极大地扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。
由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。
要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果.本课程设计是学生学习完《操作系统教程》课程后，进行的一次全面的综合训练，通过课程设计，让学生更好地掌握操作系统的原理及实现方法,加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
熟悉页面置换算法及其实现，引入计算机系统性能评价方法的概念。
关键词：编制页面置换算法模拟程序、打印页面、FIFO页面算法、LRU页面置换算法、OPT页面置换算法。
引言1．问题的提出1.1关于页面置换算法模拟程序问题的产生在各种存储器管理方式中，有一个共同的特点，即它们都要求将一个作业全部装入内存方能运行，但是有两种情况：（1）有的作业很大，不能全部装入内存，致使作业无法运行；（2）有大量作业要求运行，但内存容量不足以容纳所有这些作业。
而虚拟内存技术正式从逻辑上扩充内存容量，将会解决以上两个问题。
从内存中调出一页程序或数据送磁盘的对换区中，通常，把选择换出的页面的算法称为页面置换算法（Page-Replacement Algorithms）。
进而页面置换算法模拟程序能客观的将其工作原理展现在我们面前。
1.2 任务分析首先，定义宏变量，设置所占最大内存长度。
编辑以时间为种子，初始化随即发生器。
进行相关页面输入程序的编写以及页面的打印。
尔后，寻找最近最近最久未使用的页面、记录当前内存块中页面离下次使用间隔长度等相关程序的代码编写。
最后，进行)FIFO 、LRU、 OPT三种算法的编写。
2．需求分析1.用随机数方法产生页面走向，页面走向长度为L。
2.根据页面走向，分别采用FIFO和LRU算法进行页面置换，统计缺页率；为简化操作，在淘汰一页时，只将该页在页表中抹去,而不再判断它是否被改写过，也不将它写回到辅存。
3.假定可用内存块和页表长度 (作业的页面数)分别为m和k，初始时，作业页面都不在内存。
随机数产生程序：int i,j;j=time(NULL);//取时钟时间srand(j);//以时钟时间x为种子，初始化随机数发生器cout<<"输出随机数: ";for(i=0;i<m;i++){p[i].num=rand( )%10+1;//产生1到10之间的随即数放到数组p中p[i].time=0;cout<<p[i].num<<" ";}上述随机数发生函数产生的随机数为0.0～1.0，稍另变化就可得到0～n 1之间的随机数。
程序开始时，应对变量Seed (实型)赋初值。
根据页面置换算法的理论操作及要求，首先要进行页面长度的确定，定义结构体用以储存数据，进行主界面代码及FIFO、LRU、OPT页面置换算法代码的编写。
3．方案设计首先，定义宏变量，设置所占最大内存长度。
编辑以时间为种子，初始化随即发生器。
进行相关页面输入程序的编写以及页面的打印。
其次，寻找最近最近最久未使用的页面、记录当前内存块中页面离下次使用间隔长度等相关程序的代码编写。
最后，进行FIFO 、LRU、 OPT三种算法的编写。
．程序运行平台VC++6.0具体操作如下：在VC++6.0的环境下准备用时钟函数调用库函数（#include <time.h>）、取时钟时间并存入t调用库函数（t=time(NULL)）、用时间t初始化随机数发生器调用库函数（srand(t)返回一个1~10之间的随机数（x=rand( )%10+1）。
编写三种算法。
4．总体设计4.1 程序N-S图4.2 主要的函数Input(int m,Pro p[L])（打印页面走向状态）；void print(Pro *page1)（打印当前的页面）；int Search(int e,Pro *page1 )（寻找内存块中与e相同的块号）；int Max(Pro *page1)（寻找最近最长未使用的页面）；int Count(Pro *page1,int i,int t,Pro p[L])（记录当前内存块中页面离下次使用间隔长度）；int main()（主函数）；.随机数发生器#include <stdlib.h>#include <time.h> //准备用时钟函数调用库函数t=time(NULL);//取时钟时间并存入t调用库函数srand(t);//用时间t初始化随机数发生器调用库函数x=rand( )%10+1;//返回一个1~10之间的随机数4.3 主要流程图及代码4.3.1 FIFO（先进先出）设计原理：需要进行页面置换，即把内存中装入最早的那个页面淘汰，换入当前的页面。
算法流程图图4-1FIFO算法流程图代码：if(c==1)//FIFO页面置换{n=0;cout<<" ****************************************** "<<endl;cout<<endl;cout<<" FIFO算法页面置换情况如下: "<<endl;cout<<endl;cout<<" ******************************************"<<endl;while(i<m){if(Search(p[i].num,page)>=0)//当前页面在内存中{ cout<<p[i].num<<" ";//输出当前页p[i].numcout<<"不缺页"<<endl;i++;//i加1}else //当前页不在内存中{if(t==M)t=0;else{n++;//缺页次数加1page[t].num=p[i].num; //把当前页面放入内存中cout<<p[i].num<<" ";print(page); //打印当前页面t++; //下一个内存块i++; //指向下一个页面}}}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}4.3.2 LRU（最近最久未使用）设计原理：当需要淘汰某一页时，选择离当前时间最近的一段时间内最久没有使用过的页先淘汰该算法的主要出发点是，如果某页被访问了，则它可能马上还要被访问。
或者反过来说如果某页很长时间未被访问，则它在最近一段时间也不会被访问。
算法流程图：图4-2 LRU算法流程图代码：if(c==2)//LRU页面置换{n=0;cout<<" ******************************************"<<endl;cout<<endl;cout<<" LRU算法页面置换情况如下: "<<endl;cout<<endl;cout<<" ******************************************"<<endl;while(i<m){int a;t=Search(p[i].num,page);if(t>=0) //如果已在内存块中{page[t].time=0; //把与它相同的内存块的时间置0for(a=0;a<M;a++)if(a!=t)page[a].time++; //其它的时间加1cout<<p[i].num<<" ";cout<<"不缺页"<<endl;}else //如果不在内存块中{n++; //缺页次数加1t=Max(page); //返回最近最久未使用的块号赋值给tpage[t].num=p[i].num; //进行替换page[t].time=0; //替换后时间置为0cout<<p[i].num<<" ";print(page);for(a=0;a<M;a++)if(a!=t)page[a].time++; //其它的时间加1}i++;}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}4.3.3 OPT（最佳置换算法）设计原理：需要进行页面置换，把内存中以后一段时间都不使用或是使用时间离现在最远的页面换出。
流程图：图4-3 OPT 流程图代码： if(c==3) //OPT页面置换{n=0;cout<<" ****************************************** "<<endl;cout<<endl;cout<<" OPT算法置换情况如下:"<<endl;cout<<endl;cout<<" ****************************************** "<<endl;while(i<m){if(Search(p[i].num,page)>=0) //如果已在内存块中{cout<<p[i].num<<" ";cout<<"不缺页"<<endl;i++;}else //如果不在内存块中{int a=0;for(t=0;t<M;t++)if(page[t].num==0)a++; //记录空的内存块数if(a!=0) //有空内存块{int q=M;for(t=0;t<M;t++)if(page[t].num==0&&q>t)q=t; //把空内存块中块号最小的找出来page[q].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}else{int temp=0,s;for(t=0;t<M;t++) //寻找内存块中下次使用离现在最久的页面if(temp<Count(page,i,t,p)){temp=Count(page,i,t,p);s=t;} //把找到的块号赋给spage[s].num=p[i].num;n++;cout<<p[i].num<<" ";print(page);i++;}}}cout<<"缺页次数："<<n<<" 缺页率："<<n/m<<endl;}4.4 实现结果程序在运行的情况下，进入主界面输入菜单，如图3-3所示：输入14：图4-5 输入14后的输出图输入25：图5-6输入数据25后输出图输入数据18：图5-7 输入数据18后的输出图输入数据：图5-8输出图选1，进入FIFO页面置换：图5-9 FIFO的输出图选2，进入LRU页面置换：图5-10 LRU的输出图输入3，进入OPT页面置换：图5-11 OPT的输出图5．程序测试5.1 设计测试数据A 14 25 18 ；2 6 4 ；B 1C 2D 35.2 测试结果及分析1）测试A结果及分析进入主菜单后输入14、25，显示输入不满足要求。