页面置换算法模拟实验操作系统大作业(含源文件)

合集下载

页面置换算法模拟实验报告材料

实验编号４名称页面置换算法模拟实验目的通过请求页式存储管理中页面置换算法模拟设计，以便：1、了解虚拟存储技术的特点2、掌握请求页式存储管理中页面置换算法实验内容与步骤设计一个虚拟存储区和内存工作区，并使用FIFO和LRU算法计算访问命中率。

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

<程序1>#include <windows.h> //Windows版，随机函数需要，GetCurrentProcessId()需要//#include <stdlib.h>//Linux版，随机函数srand和rand需要#include <stdio.h> //printf()需要#define TRUE 1#define FALSE 0#define INV ALID -1#define NULL 0#define total_instruction 320 //共320条指令#define total_vp 32 //虚存页共32页#define clear_period 50 //访问次数清零周期typedef struct{//定义页表结构类型〔页面映射表PMT〕int pn, pfn, counter, time;//页号、页框号(块号)、一个周期内访问该页面的次数、访问时间}PMT;PMT pmt[32];typedef struct pfc_struct{//页面控制结构int pn, pfn;struct pfc_struct *next;}pfc_type;pfc_type pfc[32];pfc_type *freepf_head,*busypf_head,*busypf_tail;//空闲页头指针，忙页头指针，忙页尾指针int NoPageCount; //缺页次数int a[total_instruction];//指令流数组int page[total_instruction], offset[total_instruction];//每条指令的页和页内偏移void initialize( int );void FIFO( int );//先进先出void LRU( int );//最近最久未使用void NRU( int );//最近最不经常使用/****************************************************************************main()*****************************************************************************/ void main(){int i,s;//srand(10*getpid());//用进程号作为初始化随机数队列的种子//Linux版srand(10*GetCurrentProcessId());//用进程号作为初始化随机数的种子//Windows版s=rand()%320;//在[0，319]的指令地址之间随机选取一起点mfor(i=0;i<total_instruction;i+=4){//产生指令队列if(s<0||s>319){printf("when i==%d,error,s==%d\n",i,s);exit(0);}a[i]=s;//任意选一指令访问点m。

操作系统实验三(页面置换算法)实验报告材料

实验三实验报告实验源码：#include "stdio.h"#include <iostream.h>#include <stdlib.h>#define DataMax 100 // 常量DataMax#define BlockNum 10 // 常量BlockNumint 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 FIFO(); // FIFO 函数void Optimal(); // Optimal函数void LRU(); // LRU函数int main(int argc, char* argv[]){DataInput();int menu;while(true){printf("\n* 菜单选择 *\n");printf("*******************************************************\n");printf("* 1-Optimal *\n");printf("* 2-FIFO *\n");printf("* 3-LRU *\n");printf("* 4-返回上一级 *\n");printf("* 0-EXIT *\n");printf("*******************************************************\n");scanf("%d",&menu);switch(menu){case 1:Optimal();break;case 2:FIFO();break;case 3:LRU();break;case 0:exit(0);break;case 4:system("cls");DataInput();break;}if(menu != 1 && menu != 2 && menu != 3 && menu != 0 && menu !=4) { system("cls");printf("\n请输入0 - 4之间的整数！\n");continue;}}return 0;}void DataInput(){int i,choice;printf("请输入最小物理块数：");scanf("%d",&M);// 输入最小物理块数大于数据个数while(M > BlockNum){printf("物理块数超过预定值，请重新输入：");scanf("%d",&M);}printf("请输入页面的个数：");scanf("%d",&N);// 输入页面的个数大于数据个数while(N > DataMax){printf("页面个数超过预定值，请重新输入：");scanf("%d",&N);}printf("请选择产生页面访问序列的方式(1.随机 2.输入)：");scanf("%d",&choice);switch(choice){case 1:// 产生随机访问序列for(i = 0;i < N;i++){Data[i] = (int)(((float) rand() / 32767) * 10); // 随机数大小在0 - 9之间}system("cls");// 显示随机产生的访问序列printf("\n随机产生的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;case 2:// 输入访问序列printf("请输入页面访问序列：\n");for(i = 0;i < N;i++)scanf("%d",&Data[i]);system("cls");// 显示输入的访问序列printf("\n输入的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;default:while(choice != 1 && choice != 2){printf("请输入1或2选择相应方式:");scanf("%d",&choice);}break;}}void DataOutput(){int i,j;// 对所有数据操作for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");for(j = 0;j < M;j++){// 对所有数据操作for(i = 0;i < N;i++){if( DataShowEnable[j][i] )printf("%d ",DataShow[j][i]);elseprintf(" ");}printf("\n");}printf("缺页次数: %d\n",ChangeTimes);printf("缺页率: %d %%\n",ChangeTimes * 100 / N); }// 最佳置换算法void Optimal(){int i,j,k;bool find;int point;int temp; // 临时变量，比较离的最远的时候用int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i=0;i < N;i++)DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////////////////////////////////////////// ////////Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////////////////////////////////////////// ///////// 对所有数据进行操作for(i=0;i < N;i++){// 表示块中有没有该数据find = false;for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}if( find ) continue; // 块中有该数据，判断下一个数据// 块中没有该数据，最优算法ChangeTimes++; // 缺页次数++for(j = 0;j < M;j++)// 找到下一个值的位置find = false;for( k = i;k < N;k++){if( Block[j] == Data[k] ){find = true;count[j] = k;break;}}if( !find ) count[j] = N;}// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nOptimal => \n");DataOutput();// 先进先出置换算法void FIFO(){int i,j;bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0; // 大于等于BlockNum，表示块中没有数据，或需被替换掉// 所以经这样初始化（3 2 1），每次替换>=3的块，替换后计数值置1，// 同时其它的块计数值加1 ，成了（1 3 2 ），见下面先进先出程序段}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////////////////////////////////////////// ////////Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////////////////////////////////////////// ///////// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;}find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++; // 缺页次数++// 因为i是从0开始记，而M指的是个数，从1开始，所以i+1 if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0; // 更新计数值// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nFIFO => \n");DataOutput();}// 最近最久未使用置换算法void LRU(){int i,j;bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////////////////////////////////////////// ////////Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////////////////////////////////////////// ///////// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;}find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){count[j] = 0;find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++;// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0;// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ?(j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nLRU => \n");DataOutput();}实验结果截图：程序运行：输入相应数据：选择相应算法：最佳置换算法：先进先出算法：最近最久未使用算法：。

实验六页面置换算法模拟实验

实验六页面置换算法模拟实验一、实验目的1. 掌握虚拟存储器的实现方法。

2. 掌握各种页面置换算法。

3. 比较各种页面置换算法的优缺点。

二、实验内容模拟实现各种页面置换算法。

具体步骤为：1. 使用产生随机数函数得到一个随机的数列，作为将要载入的页面序列。

2. 可以选择使用先进先出（FIFO）算法、最近最久未使用（LRU）置换算法和最佳（OPT）置换算法，给出所需淘汰的页面号序列。

3. 列出缺页中断次数。

三、实验源程序/* 程序说明：本程序假设内存为程序分配的内存块数为4。

*//* 进入程序后可以根据菜单项进入不同的模块 *//* 1.使用首次适应算法分配空间 *//* 2.最近最久未使用的页面 *//* 3.使用最佳适应算法分配空间 *//* 4.显示有多少个缺页中断 *//* 5.推出系统 */#include<stdio.h>#include<stdlib.h>#include<time.h>#define N 39 /* 随机数序列的长度*/#define B 4 /* 内存的页面数 *//函数名：IsInBuf//功能：返回某个数x有没有在缓冲Buf[]中，若在，返回其位置；若不在，则返回-1/ int IsInBuf(int buf[],int x){ int i,j=-1;for(i=0;i<B;i++){ if(buf[i]==x) {j=i;break;}else if(buf[i]==-1){buf[i]=x;j=i;break;}}return j;}/函数名：oldest()//功能：返回最近最久未使用的页面的位置/int oldest(int f[]){ int i,j=0,max=-1;for(i=0;i<B;i++){ if(f[i]>max) {max=f[i];j=i;}f[i]++;}return j;}/函数名：oldest2()//功能：返回未来最长时间不使用的页面的位置/int oldest2(int list[],int buf[],int f[],int start) { int i,j;for(i=0;i<B;i++){ for(j=start;j<N;j++){ if(buf[i]==list[j]) break;}f[i]=j;}return oldest(f);}/函数名：main（）/main(){ int list[N];int buf[B],f[B],i,j,k,max,min;int old=0;int change=0;/生成一系列随机数并初始化环境/srand((int)time(NULL));for(i=0;i<B;i++) buf[i]=f[i]=-1;printf(“\nThe Random List:\n”);for(i=0;i<N;i++){ list[i]=(int) rand()%10;printf(“%2d”,list[i]);}/显示FIFO淘汰页面的序列/printf(“\nFIFO:\n”);change=0;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){ printf(“%2d”,buf[old]);buf[old]=list[i];old=(old+1)%(int)B;change++;}elseprintf(“”);}/显示有多少个缺页中断/printf(“\nchanges:%d\n”,change);/显示LRU淘汰页面的序列/printf(“LRU :\n”);change=0;for(i=0;i<B;i++) buf[i]=f[i]=-1;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);old=oldest(f);if(j==-1){ printf(“%2d”,buf[old]);buf[old]=list[i];f[old]=0;change++;}else{ f[j]=0;printf(“”);}}/显示有多少个缺页中断/printf(“\nchanges:%d\n”,change);/显示OPT淘汰页面的序列/printf(“OPT :\n”);change=0;for(i=0;i<B;i++) buf[i]=f[i]=-1;for(i=0;i<N;i++){j=IsInBuf(buf,list[i]);if(j==-1){ old=oldest2(list,buf,f,i);printf(“%2d”,buf[old]);buf[old]=list[i];f[old]=0;change++;}else{ printf(“”);}}/显示有多少个缺页中断/printf(“\nchanges:%d\n”,change);}说明：多次运行结果并不相同，分析一下原因。

操作系统实验页面置换算法模拟

实验四页面置换算法模拟一、实验内容简要描述开发语言及实现平台或实验环境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();三、实验心得(实验中遇到的问题及解决过程、实验中产生的错误及原因分析、实验的体会及收获、对做好今后实验提出建设性建议等。

页面置换算法源程序+实验报告

课程名称：操作系统F实验项目：操作系统实验实验地点：博学楼学院502机房专业班级：物联网1102学生姓名：陶志骞学号：2011001585 指导教师：郭昊2013年11 月20 日一．目的和要求（一）目的存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

本实验的目的是通过请求页式管理中页面置换算法的模拟设计，来了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。

（二）要求模拟页式虚拟存储管理中硬件的地址转换和缺页中断，并用先进先出调度算法（FIFO）处理缺页中断。

二．实验内容（1）为了装入一个页面而必须调出一页时，如果被选中调出的页面在执行中没有修改过，则不必把该页写到磁盘上。

因此，在页表中可以增加是否修改过的标志，当执行“存”指令“写”指令是把对应页的修改标志置“1”表示该页修改过，为“0”表示该页没有修改过。

（2）设计一个地址转换程序来模拟硬件的地址转换和缺页中断。

当访问的页在主存时则形成绝对地址，但不去模拟指令的执行，可用输出转换后的绝对地址来表示一条指令已完成。

当访问的页不在主存时则输出“*该页页号”来表示硬件产生了一次缺页中断。

调用模拟地址转换程序。

（3）编制一个FIFO页面调试程序。

FIFO页面调试算法总是先调出作业中最先进入主存的那一页，因此，可以用一个数组来构成页号队列。

数组中每个元素是该作业已在主存的页面好，假定分配给作业的主存块数为m，且该作业开始的m页已装入主存，则数组可有m个元素组成：P[0]，P[1],…,P[m-1] 她们的初值为：P[0]:=0,P[1]:=1,…,P[m-1]:=m-1用一指针k指示当要装入新页时应调出的页在数组的位置,k的初值为0。

当产生缺页中断后,操作系统总是选择P[k]所指出的页面调出,然后执行:P[k]:=要装入的新页页号K:=(k+1)mod m（4）假定主存的每块长度为1024个字节,现有一个共7页的作业,其副本也已在磁盘上.系统为该作业分配了4块主存块,且该作业的第0页至第3页已经装入主存,其余3页尚未装入主存,该作业的页表如下:假设该作业依次执行的指令如下:三．实验流程图四．实验程序#include <iostream>#include <iostream.h>#include <iomanip.h>#include <ctype.h>#define N 6//实验中假定的页表长度#define M 4 //主存物理块数struct{int lnumber; //页号int flag; //表示该页是否在主存，"1"表示在主存，"0"表示不在主存 int pnumber; //该页所在主存块的块号int write; //该页是否被修改过，"1"表示修改过，"0"表示没有修改过 int dnumber; //该页存放在磁盘上的位置，即磁盘块号}page[N]; //页表定义int p[M]; //用数组模拟]FIFO算法中的队列(使用循环队列)int head;void initial(void);int do_mmap(int); //模拟地址转换void do_page_fault(int); //缺页中断处理程序void run_first_instructon(int); //执行进程的第一条指令void run_a_instruction(int); //CPU执行一条指令void print_page_and_fifoqueue(void); //输出页表和FIFO队列main(){int laddress, paddress; //逻辑地址，物理地址int lnumber, ad, pnumber; //页号，页内地址和物理块号initial();print_page_and_fifoqueue(); //输出页表和FIFO队列run_first_instructon(0x0000); //运行进程的第一条指令的地址cout<<"输入下一条指令的逻辑地址(0~32767)(-1 to end)"<<endl;cin>>laddress;while(laddress>32767){cout<<"输入错误! 请重新输入下一条指令的逻辑地址(0~32767)(-1 to end)"<<endl;cin>>laddress;}while(laddress!=-1){lnumber=laddress>>10; //取逻辑地址的页号lnumberif(page[lnumber].flag==1){ //指令所在的页面已装入在内存中paddress=do_mmap(laddress); //形成物理地址cout<<paddress<<"输出转换后的物理地址"<<endl;run_a_instruction(paddress);cout<<"此指令执行是否修改所在页lnumber="<<lnumber<<"(y/n?) ";char change;cin>>change;if(tolower(change)=='y'){page[lnumber].write=1;print_page_and_fifoqueue();}}else{ //缺页中断cout<<lnumber<<"输出该页的页号－－表示硬件产生缺页中断"<<endl;do_page_fault(lnumber); //直接转去缺页中断处理continue; //本循环结束，重新执行指令}cout<<"输入下一条指令的逻辑地址((0~32767)，-1 to end)\n";cin>>laddress;while(laddress>32767){ //输入正确性检测cout<<"输入错误! 请重新输入下一条指令的逻辑地址(0~32767)(-1 to end)"<<endl;cin>>laddress;}}cout<<"进程运行结束!"<<endl;system("PAUSE");return 0;}//手工初始化页表和p[M]队列void initial(void){int i;for(i=0; i<=5; i++){page[i].lnumber=i;if(i<=M-1){ //预装入算法初始化页表的前四项cout<<"输入页号为 "<<i<<" 所在内存的物理块号(预装入前四个页面)：";cin>>page[i].pnumber;page[i].flag=1; //存在标志置1}}//初始化FIFO的队列head=0;for(i=0; i<=M-1; i++)p[i]=i;}//输出页表和FIFO队列void print_page_and_fifoqueue(void){int i;cout<<"输出页表！\n";cout<<setw(10)<<"lnumber"<<setw(9)<<"flag"<<setw(10)<<"pnumber"<<setw(10)<<"write"<<setw(10)<<"dnumber"<<endl;for(i=0; i<=N-1; i++)cout<<setw(7)<<page[i].lnumber<<setw(10)<<page[i].flag<<setw(10)< <page[i].pnumber<<setw(10)<<page[i].write<<setw(10)<<page[i].dnumber<<endl;cout<<"输出FIFO对列:\n";cout<<setw(10)<<"NO"<<setw(40)<<"page(已在主存的页号lnumber)\n";cout<<"head="<<head<<endl;for(i=0; i<=M-1;i++)cout<<setw(10)<<i<<setw(15)<<p[i]<<endl;}//模拟地址转换int do_mmap(int laddress){int lnumber, ad, pnumber, paddress;lnumber=laddress>>10; //取逻辑地址的页号lnumberad=laddress&0x3ff; //页内地址pnumber=page[lnumber].pnumber; //从页表中取得块号pnumberpaddress=pnumber<<10|ad;return paddress;}//CPU执行一条指令，输出物理地址表示指令执行完成void run_a_instruction(int paddress){cout<<paddress<<" 输出物理地址－－表示指令执行完成"<<endl;}//执行进程的第一条指令void run_first_instructon(int laddress){int lnumber, ad, pnumber, paddress;lnumber=laddress>>10; //取逻辑地址的页号if(page[lnumber].flag==1)paddress=do_mmap(laddress); //形成物理地址cout<<paddress<<"输出转换后的物理地址"<<endl;run_a_instruction(paddress);cout<<"此指令执行(0x0000)是否修改所在页面lnumber="<<lnumber<<"(y/n?) ";char change;cin>>change;if(tolower(change)=='y'){ //若指令执行完时修改了页面，则置write 标志位位1page[lnumber].write=1;print_page_and_fifoqueue();}cout<<"********第一条指令执行完成(地址为0x0000)***********"<<endl;}//页面写回磁盘void write_to_harddisk(int j){cout<<j<<"输出已修改的淘汰的页号－－表示该页写回了磁盘"<<endl;}//缺页中断处理程序void do_page_fault(int lnumber){int j; //j是选择淘汰的页j=p[head];p[head]=lnumber; //lnumber是新装入的页号head=(head+1)%M;//若淘汰出主存的页j已修改，则写会磁盘if(page[j].write==1)write_to_harddisk(j); //页j写回磁盘//修改页表page[j].flag=0; //页表中第j页的存在标志为0page[lnumber].flag=1; //页表第lnumber的存在标志为1page[lnumber].write=0; //页表第lnumber的修改标志为0page[lnumber].pnumber=page[j].pnumber; //第拉怒目布尔页的主存块号为第j页原主存块号cout<<lnumber<<"输出该页－－表示该页调入了主存"<<endl;cout<<"按任意键将查看“页面置换”之后的页表page[N]和FIFO队列信息"<<endl;system("PAUSE");print_page_and_fifoqueue();}五．实验结果。

北邮-操作系统试验-页面置换算法

北邮-操作系统试验-页面置换算法-CAL-FENGHAI.-(YICAI)-Company One1课本第九章21题实验ytinrete1．实验目的：学习页面置换算法2．实验内容Write a program that implements the FIFO and LRU page-replacement algorithms presented in this chapter. First, generate a random page reference string where page numbers range from 0..9. Apply the random page-reference string to each algorithm and record the number of page faults incurred by each algorithm. Implement the replacement algorithms such that the number of page frames can vary from 1..7. Assume that demand paging is used.写一个程序来实现本章中介绍的FIFO和LRU页置换算法。

首先产生一个随机的页面引用序列，页面数从0~9。

将这个序列应用到每个算法并记录发生的页错误的次数。

实现这个算法时，要将页帧的数量设为可变（从1~7）。

假设使用请求调页。

3．设计说明FIFO算法：每次请求先查找是否有空块，有则替换，并标记为最晚到达，若没有则从标记中寻找最新到达的块，替换，并更新标记表。

标记数字越小，到达时间最早。

LRU算法：每次请求先查找是否有空块，有则替换，并标记为最近使用时间最短者，若没有则从标记中寻找最近使用时间最长者，替换，并更新标记表。

标记数字越小，最近使用频率越低。

4．实验环境windows7 ultimate x64 with sp15．程序源码#include<stdlib.h>#include<cstdlib>#include<time.h>#include <iostream>#include <vector>#include <windows.h>using namespace std;typedef struct block//页帧块结构{int num;int lable;}block;int page_size, frame_size;//序列数，页帧大小vector <int> order;//存放序列vector <block> frame;//页帧void page_replacement (int kind)//kind=1为FIFO,kind=2为LRU {//初始化frame.clear();block init;init.num=-1;ble=-1;for(int i=0; i<frame_size; i++){frame.push_back(init);}int error=0;//错误次数int seq=0;//标记数字int position=-1;//匹配位置for(int i=0; i<order.size(); i++)position=-1;cout<<i<<":"<<"引用请求为 "<<order.at(i)<<" :"<<endl;cout<<"引用前页帧情况（-1为空）:";for(int j=0; j<frame.size(); j++){cout<<(frame.at(j)).num<<", ";if(order.at(i)==(frame.at(j)).num)position=j;}cout<<endl;if(-1!=position){cout<<"匹配成功！"<<endl;//更新标记这也是LRU算法比FIFO唯一多出来的地方if(kind==2){int temp=(frame.at(position)).lable;(frame.at(position)).lable=seq+1;for(int j=0; j<frame.size(); j++){if(-1!=(frame.at(j)).num)//不是空块{if((frame.at(j)).lable>temp){(frame.at(j)).lable--;}}}}//多余部分结束}else{cout<<"匹配失败！"<<endl;error++;//开始置换//先查找空页for(int j=0; j<frame.size(); j++){if(-1==(frame.at(j)).num){position=j;break;}}if(-1!=position)//有空页{(frame.at(position)).num=order.at(i);//置换seq++;(frame.at(position)).lable=seq;//标记数字}else//没有空页{for(int j=0; j<frame.size(); j++)//找相应的置换项{if(1==(frame.at(j)).lable){position=j;break;}}(frame.at(position)).num=order.at(i);//置换(frame.at(position)).lable=seq+1;//标记进入顺序for(int j=0; j<frame.size(); j++)//更新标记{(frame.at(j)).lable--;}}}cout<<"引用后页帧情况（-1为空）:";for(int j=0; j<frame.size(); j++){cout<<(frame.at(j)).num<<", ";}cout<<endl<<endl;}cout<<endl<<"算法结束，总页错误的次数为："<<error<<endl<<endl; }int main(){cout<<"请输入测试的页面序列数：" ;cin>>page_size;if(page_size<=0){cout<<"序列数有误";return 0;}cout<<"请输入页帧数量(1~7):";cin>>frame_size;if(frame_size<=0||frame_size>7){cout<<"页帧数有误";return 0;}int number;srand(unsigned(time(NULL)));//设置随机数种子for(int i=0; i<page_size; i++){number=rand()%10;//页面数从0到9order.push_back(number);}/* 课本例子，使用这个时将上面的随机数注释掉order.push_back(7);order.push_back(0);order.push_back(1);order.push_back(2);order.push_back(0);order.push_back(3);order.push_back(0);order.push_back(4);order.push_back(2);order.push_back(3);order.push_back(0);order.push_back(3);order.push_back(2);order.push_back(1);order.push_back(2);order.push_back(0);order.push_back(1);order.push_back(7);order.push_back(0);order.push_back(1);*/cout<<endl<<"随机生成的页面引用序列为："<<endl;for(int i=0; i<order.size(); i++){cout<<order.at(i);if(order.size()-1!=i)cout<<", ";}cout<<endl<<endl;page_replacement (1);cout<<endl<<endl;page_replacement (2);system("pause");return 0;}6．结果测试首先以课本上为例：20个序列：7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1 帧序列为3FIFO错误数15，置换顺序课件与课本完全相符。

计算机操作系统页面置换算法模拟(DOC)

《计算机操作系统》课外实践报告题目：页面置换算法模拟班级： 13级物联网工程一班姓名：王铎学号： 130911044指导老师: 王蕾设计时间: 2014.6一、实验目标：通过设计请求页面存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页面存储管理的页面置换算法。

二、实验要求1通过随机数产生一个指令序列320条指令。

指令的地址按下述原则生成50%的指令是顺序执行的25%的指令是均匀分布在前地址部分25%的指令是均匀分布在地址部分。

2将指令序列换成为页地址流。

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

1）先进先出的算法FIFO2）最近最少使用算法LRU3）最近最不经常使用算法NUR三．实践内容简要描述1、实践环境windows XP/7，visual C++ 6.02、算法思路与算法原理2.1、先进先出算法（FIFO）：该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

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

2.2、最近最久未使用页面置换算法（LRU）：算法的基本思想：当需要淘汰某一页时，选择离当前时间最近一段时间内最久没有使用过的页先淘汰。

该算法的出发点是，如果某页被访问了，则它可能马上还被访问。

或者反过来说，如果某页长时间未被访问，则它在最近一段时间不会被访问。

3概要设计3.1 总体设计框图4系统流程图图4.1详细设计框图图4.2为置换方法的流程图5代码分析结果5.1 数据结构int m, int need[],int n, result[10][20],int state[],int count1[];5.2 FIFO具体函数及设计实现FIFO流程图FIFO函数实现void FIFO(int m, int need[],int n) //m分配物理页面大小，n需要页面数组的最大值{int p=0; //当前请求的页面int del=0; //步数int count1[20];double count=0; //缺页数double que=0; //缺页率int result[10][20]; //结果表for(int i =0;i<=m;i++)for(int j=0;j<=n;j++){result[i][j]=-1;count1[j]=-1;}while(n>=p){int k=need[p];if(p>0){for(int i=0;i<=m;i++){result[i][p]=result[i][p-1];}}int f1=0;//首先看是否有空位置或者已经存在请求的页面for(int i =0;i<=m;i++){if(result[i][p]==-1){result[i][p]=k;f1=1;i=m+1;count1[p]=k;count=count+1;p=p+1;}else if(result[i][p]==k){f1=1;p=p+1;i=m+1;}}if(f1==1) continue;//这里发生替换result[del][p]=k;count1[p]=k;count=count+1;p=p+1;del=(del+1)%(m+1);}cout<<"*******************FIFO过程如下表************************"<<endl; for(int t3=0;t3<=n;t3++)//输出原来的页面cout<<need[t3]<<" ";cout<<endl;for(int t0 =0;t0<=m;t0++)//判断页表是否填满{for(int t1=0;t1<=n;t1++){if(result[t0][t1]!=-1)cout<<result[t0][t1]<<" ";else cout<<" "<<" ";}cout<<endl;}for(int j1=0;j1<=n;j1++)//对于缺页的打×，否则打√{if(count1[j1]!=-1)cout<<"×";else cout<<"√";}cout<<endl;que=count/(n+1);//统计缺页次数和缺页率cout<<"缺页次数为:"<<count<<endl;cout<<"缺页率"<<count<<"/"<<n+1<<"="<<que<<endl;cout<<"**************************************************"<<endl;}5.3LRU具体函数及设计实现LRU流程图LRU函数实现void LRU(int m, int need[],int n){m++;n++;int i, j, min, num = 1, k, flag;int state[10], count[20], hsive[10];int result[10][20];memset(state, 0, sizeof(state));//初始化内存空间，给三个数组分配内存memset(count, -1, sizeof(count));memset(hsive, -1, sizeof(hsive));memset(result, -1, sizeof(result));for(i = 0; i < n; i++)//将need数组值赋给resultresult[0][i] = need[i];cout<<"*****************LRU过程如下表*********************"<<endl;for(i = 0; i < n; i++){flag = 0;//标志位，如果页面和页表内的熄灯则赋值for(j = 1; j < num; j++){if(result[0][i] == hsive[j]){flag = 1;state[j] = -1;break;}}if(flag == 0)//替换{if(num <= m)hsive[num] = result[0][i];else{min = -1;for(j = 1; j <= m; j++){if(state[j] > min){k = j;min = state[j];}}hsive[k] = result[0][i];state[k] = -1;}count[i] = 1;num++;}for(j = 1; j <= m; j++){result[j][i] = hsive[j];state[j]++;}}for(j = 0; j <= m; j++)//输入个页面替换情况{for(i = 0; i < n; i++){if(result[j][i] == -1)cout << " ";elsecout << result[j][i] << " ";}cout << endl;}for(i = 0; i < n; i++){if(count[i] != -1)cout<<"×";elsecout<<"√";}cout << endl;//统计各页面缺页次数和缺页率cout << "缺页次数为:" << num - 1 << endl;cout << "缺页率" << num - 1 << "/"<<n << "=" << double(num - 1) / n <<endl;cout<<"**************************************************"<<endl; }主方法int main(){cout<<" *********************************************"<<endl;cout<<" * 页式存储管理*"<<endl;cout<<" ********************************************* "<<endl;int m;int n=0;int choose=2;int need[20];char flag;while(1){cout<<"指定内存分配页面数:";while (flag<'0'||flag>'9'){cin>>flag;}m=flag-'0'-1;flag=' ';cout<<"请选择页面序列产生方式:"<<endl;cout<<" (0)手动输入"<<endl;cout<<" (1)随机产生"<<endl;while (flag<'0'||flag>'1'){cin>>flag;}choose =flag-'0';flag=' ';if(choose==0){cout<<"输入页面走向！以s结尾"<<endl;while(1){while ((flag<'0'||flag>'9')&&flag!='s'){cin>>flag;}if(flag=='s') break;need[n]=flag-'0';flag=' ';n=n+1;}flag=' ';n=n-1;}else {cout<<"随机产生的页面个数:";cin>>n;n=n-1;for(int i=0;i<=n;i++){need[i]=rand()%10;}}system("cls");cout<<"选择页面置换算法:"<<endl;cout<<"0-FIFO 1-LRU"<<endl;while (flag<'0'||flag>'1'){cin>>flag;}choose =flag-'0';flag=' ';if(choose==0){FIFO(m, need,n);}else {LRU(m, need,n);}cout<<"输入Y/y可以看另外一种置换算法的执行过程"<<endl;cin>>flag;if(flag=='Y'||flag=='y'){system("cls");if(choose==0) LRU(m, need,n);else FIFO(m, need,n);}else flag=' ';cout<<"输入N/n退出否则输入任意键继续"<<endl;cin>>flag;if(flag=='N'||flag=='n') break;else{system("cls");flag=' ';}}return 0;}5.4调用关系图6测试6.1进入界面及产生页面走向运行结果如下图6.1 进入管理界面图6.2产生页面走向6.2FIFO算法及查看结果图6.3选择FIFO算法结果6.3LRU算法及查看结果图6.4选择LRU结果6.4继续进入主界面及产生页面走向图6.5按y继续回到主界面设置页面为46.5调度算法及结果图6.6选择LRU算法结果图6.7选择FIFO算法结果7 总结与体会通过这次实验，我基本了解了页面置换算法的基本设置与要求，懂得了先进先出算法（FIFO）、最近最久未使用页面置换算法（LRU）的基本编程及算法原理。

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

操作系统实验报告_页面置换算法模拟学生实验报告姓名: 年级专业班级学号成绩验证设计实验3 请求分页系统的页面实验类型课程名称实验名称操作系统综合创新置换算法【实验目的、要求】1.通过编程实现请求分页存储管理系统的Optimal、FIFO、LRU调度算法，使学生掌握计算机虚拟存储管理中有关缺页处理方法等内容，巩固有关虚拟存储管理的知识。

2.了解Windows2000/XP中内存管理机制，掌握页式虚拟存储技术。

3.理解内存分配原理，特别是以页面为单位的虚拟内存分配方法。

【实验内容】在Windows XP或Windows 2000等操作系统环境下，使用VC、VB、Delphi、java或C等编程语言，实现请求分页存储管理系统的Optimal、FIFO、LRU调度算法。

【实验环境】(含主要设计设备、器材、软件等)计算机 C语言编程软件【实验步骤、过程】(含原理图、流程图、关键代码，或实验过程中的记录、数据等)1.启动计算机，运行C语言编程软件。

2.分析理解页面的几种基本算法的特点和原理，在纸上画出原理图。

3.编辑源程序，关键代码如下。

(1)先进先出页面置换算法。

#include<stdio.h>void main(){int i,n,t,k=3,a[100];scanf("%d",&n);for(i=0;i<n;i++)scanf("%d",&a[i]);for(i=3;i<n;i++)if(a[i]!=a[0]&&a[i]!=a[1]&&a[i]!=a[2]) //该页面在内存中，不需要置换。

{t=a[i];a[i]=a[k%3]; //通过对k值对3取余的值来确定需要置换的当前页面。

a[k%3]=t;k++; //仅当发生了页面置换时，k的值才发生改变。

printf("%d %d %d\n",a[0],a[1],a[2]);}else{printf("%d %d %d\n",a[0],a[1],a[2]);}}(2)最佳置换算法#include<stdio.h>void main(){int i,j,,n,a[100];int c1,c2,c3; // 标志该页面再次被访问时在引用串中的位置int p,k,r;printf("请输入页面数:\n");scanf("%d",&n);printf("请输入页面号引用串:\n");for(i=0;i<n;i++)scanf("%d",&a[i]);for(j=3;j<n;j++){if((a[j]!=a[0])&&(a[j]!=a[1])&&(a[j]!=a[2])) //页面在内存不发生置换～{for(p=j;p<n;p++)if(a[0]==a[p]){ c1=p;break; //跳出循环，直接置c1=n!} else c1=n; //标志该页面再次被访问时在引用串中的位置～若该页面不会再次被访问，则将c1置为最大n!for(k=j;k<n;k++)if(a[1]==a[k]){ c2=k;break; }elsec2=n;for(r=j;r<n;r++)if(a[2]==a[r]){ c3=r;break;}else c3=n; //通过比较c1,c2,c3的大小确定最长时间内不再访问的页面～if((c1>c2)&&(c1>c3)||(c1==c3)||(c1==c2)) //当前a[0]页面未来最长时间不再访问!{t=a[j];a[j]=a[0];a[0]=t; //把当前访问页面和最佳页面交换～printf("%d %d %d\n",a[0],a[1],a[2]);}if((c2>c1)&&(c2>c3)||(c2==c3)) //当前a[1]页面未来最长时间不再访问!{t=a[j];a[j]=a[1];a[1]=t;printf("%d %d %d\n",a[0],a[1],a[2]);}if((c3>c1)&&(c3>c2)) //当前a[2]页面未来最长时间不再访问!{t=a[j];a[j]=a[2];a[2]=t;printf("%d %d %d\n",a[0],a[1],a[2]); //输出置换后页框中的物理块组成～}}elseprintf("%d %d %d\n",a[0],a[1],a[2]);}}(3)LRU算法。

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

操作系统实验三(页面置换算法)实验报告int N; // 页面个数int M; // 最小物理块数int ChangeTimes; // 缺页次数void DataInput(); // 输入数据的函数void DataOutput(); // 输出数据的函数void FIFO(); // FIFO 函数void Optimal(); // Optimal函数void LRU(); // LRU函数int main(int argc, char* argv[]){DataInput();int menu;while(true){printf("\n* 菜单选择 *\n");printf("*******************************************************\n");printf("*1-Optimal *\n");printf("* 2-FIFO *\n");printf("* 3-LRU *\n");printf("* 4-返回上一级 *\n");printf("* 0-EXIT *\n");printf("*******************************************************\n");scanf("%d",&menu);switch(menu){case 1:Optimal();break;case 2:FIFO();break;case 3:LRU();break;case 0:exit(0);break;case 4:system("cls");DataInput();break;}if(menu != 1 && menu != 2 && menu != 3 && menu != 0 && menu !=4) {system("cls");printf("\n请输入0 - 4之间的整数！\n");continue;}}return 0;}void DataInput(){int i,choice;printf("请输入最小物理块数：");scanf("%d",&M);// 输入最小物理块数大于数据个数while(M > BlockNum){printf("物理块数超过预定值，请重新输入：");scanf("%d",&M);}printf("请输入页面的个数：");scanf("%d",&N);// 输入页面的个数大于数据个数while(N > DataMax){printf("页面个数超过预定值，请重新输入：");scanf("%d",&N);}printf("请选择产生页面访问序列的方式(1.随机 2.输入)：");scanf("%d",&choice);switch(choice){case 1:// 产生随机访问序列for(i = 0;i < N;i++){Data[i] = (int)(((float) rand() / 32767) * 10); // 随机数大小在0 - 9之间}system("cls");// 显示随机产生的访问序列printf("\n随机产生的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;case 2:// 输入访问序列printf("请输入页面访问序列：\n");for(i = 0;i < N;i++)scanf("%d",&Data[i]);system("cls");// 显示输入的访问序列printf("\n输入的访问序列为：");for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");break;default:while(choice != 1 && choice != 2){printf("请输入1或2选择相应方式:");scanf("%d",&choice);}break;}}void DataOutput(){int i,j;// 对所有数据操作for(i = 0;i < N;i++){printf("%d ",Data[i]);}printf("\n");for(j = 0;j < M;j++){// 对所有数据操作for(i = 0;i < N;i++){if( DataShowEnable[j][i] )printf("%d ",DataShow[j][i]);elseprintf(" ");}printf("\n");}printf("缺页次数: %d\n",ChangeTimes);printf("缺页率: %d %%\n",ChangeTimes * 100 / N);}// 最佳置换算法void Optimal(){int i,j,k;bool find;int point;int temp; // 临时变量，比较离的最远的时候用int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i=0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////// ///////////////////////////////////////// ///Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////// ///////////////////////////////////////// //// 对所有数据进行操作for(i=0;i < N;i++){// 表示块中有没有该数据find = false;for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}if( find ) continue; // 块中有该数据，判断下一个数据// 块中没有该数据，最优算法ChangeTimes++; // 缺页次数++for(j = 0;j < M;j++){// 找到下一个值的位置find = false;for( k = i;k < N;k++){if( Block[j] == Data[k] ){find = true;count[j] = k;break;}}if( !find ) count[j] = N;}// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nOptimal => \n");DataOutput();}// 先进先出置换算法void FIFO(){int i,j;bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++){DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0; // 大于等于BlockNum，表示块中没有数据，或需被替换掉// 所以经这样初始化（3 2 1），每次替换>=3的块，替换后计数值置1，// 同时其它的块计数值加 1 ，成了（1 3 2 ），见下面先进先出程序段}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////// ///////////////////////////////////////// ///Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;}if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////// ///////////////////////////////////////// //// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;}find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++; // 缺页次数++ // 因为i是从0开始记，而M指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0; // 更新计数值// 保存要显示的数据for(j = 0;j < M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ? (j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nFIFO => \n");DataOutput();}// 最近最久未使用置换算法void LRU(){int i,j;bool find;int point;int temp; // 临时变量int m = 1,n;ChangeTimes = 0;for(j = 0;j < M;j++){for(i = 0;i < N;i++)DataShowEnable[j][i] = false; // 初始化为false，表示没有要显示的数据}}for(i = 0;i < M;i++){count[i] = 0 ; // 初始化计数器}// 确定当前页面是否在物理块中，在继续，不在置换/////////////////////////////////////// ///////////////////////////////////////// ///Block[0] = Data[0];for(i = 1;m < M;i++){int flag = 1;for(n = 0; n < m;n++){if(Data[i] == Block[n]) flag = 0;if(flag == 0) continue;Block[m] = Data[i];m++;}/////////////////////////////////////// ///////////////////////////////////////// //// 对有所数据操作for(i = 0;i < N;i++){// 增加countfor(j = 0;j < M;j++){count[j]++;}find = false; // 表示块中有没有该数据for(j = 0;j < M;j++){if( Block[j] == Data[i] ){count[j] = 0;find = true;}}// 块中有该数据，判断下一个数据if( find ) continue;// 块中没有该数据ChangeTimes++;// 因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1if( (i + 1) > M ){//获得要替换的块指针temp = 0;for(j = 0;j < M;j++){if( temp < count[j] ){temp = count[j];point = j; // 获得离的最远的指针}}}else point = i;// 替换Block[point] = Data[i];count[point] = 0;// 保存要显示的数据for(j=0;j<M;j++){DataShow[j][i] = Block[j];DataShowEnable[i < M ?(j <= i ? j : i) : j][i] = true; // 设置显示数据}}// 输出信息printf("\nLRU => \n");DataOutput();}实验结果截图：程序运行：输入相应数据：选择相应算法：最佳置换算法：先进先出算法：最近最久未使用算法：。

操作系统实验报告材料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;}截图。

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

操作系统—页面置换算法实验报告本报告旨在介绍操作系统中的页面置换算法，包括实验的目的和背景以及页面置换算法的概念和作用。

本实验旨在描述实验环境以及所使用的页面置换算法，包括FIFO、LRU、OPT等。

同时，还会详细介绍实验步骤和设置的参数。

实验环境操作系统：Windows 10编程语言：C++开发环境：Visual。

2019页面置换算法FIFO（First-In-First-Out）算法：按照先进先出的原则置换页面，最早进入内存的页面会被置换出去。

LRU（Least Recently Used）算法：根据页面的使用情况，置换最长时间没有被访问过的页面。

OPT（Optimal）算法：理论上最优的页面置换算法，根据未来一段时间内页面的访问情况，选择最少使用的页面进行置换。

实验步骤创建一个模拟操作系统的C++程序。

设定内存大小、页面大小和页面数等参数。

实现FIFO算法，将其应用于模拟操作系统中的页面置换过程。

实现LRU算法，将其应用于页面置换过程。

实现OPT算法，将其应用于页面置换过程。

运行模拟程序，观察不同页面置换算法的效果。

分析比较不同算法的页面置换结果，评估其优缺点。

参数设置内存大小：512MB页面大小：4KB页面数：128以上是本次实验的实验设计，将通过创建模拟操作系统程序，实现FIFO、LRU和OPT等页面置换算法，并对其结果进行比较和评估。

本实验展示了页面置换算法的不同性能，并分析了各种算法的优缺点。

实验结果表明，不同的页面置换算法对系统性能有显著影响。

以下是对各种算法的性能分析：先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。

优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。

先进先出(FIFO)算法：该算法将最早进入内存的页面置换出去。

优点是简单易实现，缺点是无法适应程序的访问模式变化，容易产生"Belady异常"。

操作系统课程实验报告编程模拟页面置换算法

湖南师范大学树达学院操作系统课程实验报告题目编程模拟页面置换算法理工系09级电子商务专业姓名学号指导教师张楚才2011年5月 5 日实验题目：编程模拟页面置换算法实验要求：利用C语言分别实现先进先出置换算法FIFO、最佳置换算法OPT、最近最久未使用置换算法LRU。

要求在任意给定的页面访问序列和内存的物理块数下，输出每种算法下的缺页率。

例如，假定系统为某进程分配了3个物理块，进程运行时的页面走向为7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1，开始时3个物理块均为空，分别求出每种算法下的缺页率。

#include<stdio.h>void Print(int bc[],int blockCount){for(int i=0;i<blockCount;i++){printf("%d ",bc[i]);}printf("\n");}bool Travel(int bc[],int blockCount,int x){bool is_found=false;int i;for(i=0;i<blockCount;i++){if(bc[i]==x){is_found=true;break;}}return is_found;}void FIFO(int pc[],int bc[],int pageCount,int blockCount)printf("0：FIFO置换算法\n");int i;if(pageCount<=blockCount){printf("缺页次数为0\n");printf("缺页率为0\n");}else{int noPage=0;int p=0;for(i=0;i<pageCount;i++){//printf("引用页：%d\n",pc[i]);if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}else{if(p==blockCount){p=0;}bc[p]=pc[i];p++;}noPage++;//printf("物理块情况：\n");//Print(bc,blockCount);}//printf("\n");}printf("FIFO缺页次数为:%d\n",noPage);printf("FIFO缺页率为:%.2f%%\n",(float)noPage/pageCount*100);}}int FoundMaxNum(int a[],int n){int k,j;k=a[0];j=0;for (int i=0;i<n;i++){if(a[i]>=k){k=a[i];j=i;}}return j;}void LRU(int pc[],int bc[],int pageCount,int blockCount) {printf("1：LRU置换算法\n");if(pageCount<=blockCount){printf("缺页次数为0\n");printf("缺页率为0\n");}else{int noPage=0;int i,j,m;int bc1[100];for(i=0;i<blockCount;i++){bc1[i]=0;}for(i=0;i<pageCount;i++){// printf("引用页：%d\n",pc[i]);if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];for(int p=0;p<=i;p++){bc1[p]++;}}else{for(j=0;j<blockCount;j++){bc1[j]++;}int k=FoundMaxNum(bc1,blockCount);bc[k]=pc[i];bc1[k]=1;}noPage++;//printf("物理快情况：\n");//Print(bc,blockCount);}else if(Travel(bc,blockCount,pc[i])){if(i<blockCount){for(j=0;j<=i;j++){bc1[j]++;}for(m=0;m<=i;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}else{for(j=0;j<blockCount;j++)bc1[j]++;}for(m=0;m<blockCount;m++){if(bc[m]==pc[i]){break;}}bc1[m]=1;bc[m]=pc[i];}}//printf("\n");}printf("LRU缺页次数为:%d\n",noPage);printf("LRU缺页率为:%.2f%%\n",(float)noPage/pageCount*100);}}void Optiomal(int pc[],int bc[],int pageCount,int blockCount){printf("2：最佳置换算法\n");if(pageCount<=blockCount){printf("缺页次数为0\n");printf("缺页率为0\n");}else{int noPage=0;int i,j,k;for(i=0;i<pageCount;i++){// printf("引用页：%d\n",pc[i]);if(!Travel(bc,blockCount,pc[i])){if(i<blockCount){bc[i]=pc[i];}{int max=0;int blockIndex;;for(j=0;j<blockCount;j++){for(k=i;k<pageCount;k++){if(bc[j]==pc[k]){break;}}if(k>=max){max=k;blockIndex=j;}}bc[blockIndex]=pc[i];}noPage++;//printf("物理快情况：\n");//Print(bc,blockCount);}//printf("\n");}printf("OPT缺页次数为:%d\n",noPage);printf("OPT缺页率为:%.2f%%\n",(float)noPage/pageCount*100);}}int main(){int pageCount,blockCount,i,pc[100];printf("输入页面数\n");scanf("%d",&pageCount);printf("输入页面走向\n");for(i=0;i<pageCount;i++){scanf("%d",&pc[i]);}blockCount=3;//物理块数int bc1[100];printf("\n");FIFO(pc,bc1,pageCount,blockCount);int bc2[100];printf("\n");LRU(pc,bc2,pageCount,blockCount);int bc3[100];printf("\n");Optiomal(pc,bc3,pageCount,blockCount);return 0;}。

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

2.了解Windows2000/XP中内存管理机制，掌握页式虚拟存储技术。

3.理解内存分配原理，特别是以页面为单位的虚拟内存分配方法。

【实验内容】在Windows XP或Windows 2000等操作系统环境下，使用VC、VB、Delphi、java或C等编程语言，实现请求分页存储管理系统的Optimal、FIFO、LRU调度算法。

2.分析理解页面的几种基本算法的特点和原理，在纸上画出原理图。

3.编辑源程序，关键代码如下。

(1)先进先出页面置换算法。

#include<stdio.h>void main(){int i,n,t,k=3,a[100];scanf("%d",&n);for(i=0;i<n;i++)scanf("%d",&a[i]);for(i=3;i<n;i++)if(a[i]!=a[0]&&a[i]!=a[1]&&a[i]!=a[2]) //该页面在内存中，不需要置换。

{t=a[i];a[i]=a[k%3]; //通过对k值对3取余的值来确定需要置换的当前页面。

a[k%3]=t;k++; //仅当发生了页面置换时，k的值才发生改变。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

“计算机操作系统”课程设计大作业页面置换算法模拟实验(含完整资料，可直接提交)一、题目: 页面置换算法模拟实验二、目的分别采用最佳(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中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。

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

这种页面调入方式叫请求调页，为实现请求调页，核心配置了四种数据结构：页表、页框号、访问位、修改位、有效位、保护位等。

此设计为了了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb 编译、调试C程序，学会如何把学到的知识用于解决实际问题，培养学生的能力。

关键字UNIX 请求调页数据结构存储管理编辑器调试C程序正文一、设计思路页面置换算法：当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。

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

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

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

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

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

此设计为了了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb编译、调试C程序，学会如何把学到的知识用于解决实际问题，培养学生的动手能力。

二、设计目的1、用C语言实现页面置换算法。

2、了解内存分页管理策略3、掌握调页策略4、掌握一般常用的调度算法5．选取调度算法中的典型算法，模拟实现。

三、设计任务在Window98/2000 系统的TC2.0环境下运行程序；通过从一般常用的调页算法中选取典型算法程序，了解页面管理的相关细节，并用程序设计实现该算法实验。

四、设计内容与步骤分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。

五、调页策略1)何时调入页面如果进程的许多页是存放在外存的一个连续区域中，则一次调入若干个相邻的页，会比一次调入一页的效率更高效一些。

但如果调入的一批页面中的大多数都未被访问，则又是低效的。

可采用一种以预测为基础的预调页策略，将那些预计在不久之后便会被访问的页面，预先调入内存。

如果预测较准确，那么，这种策略显然是很有吸引力的。

但目前预调页的成功率仅为50%。

且这种策略主要用于进程的首次调入时，由程序员指出应该先调入哪些页。

2)请求调页策略当进程在运行中需要访问某部分程序和数据时，若发现其所在的页面不在内存，便即提出请求，由OS将其所需页面调入内存。

由请示调页策略所确定调入的页，是一定会被访问的，再加之请求调页策略比较易于实现，故在目前的虚拟存储器中，大多采用此策略。

但这种策略每次仅调入一页，故须花费较大的系统开销，增加了磁盘I/O的启用频率。

3）从何处调入页面在请求分页系统中的外存分为两部分：用于存放文件的文件区和用于存放对换页面的对换区。

通常，由于对换区是采用连续分配方式，而事件是采用离散分配方式，故对换区的磁盘I/O速度比文件区的高。

这样，每当发生缺页请求时，系统应从何处将缺页调入内存，可分成如下三种情况：(1) 系统拥有足够的对换区空间，这时可以全部从对换区调入所需页面，以提高调页速度。

为此，在进程运行前，便须将与该进程有关的文件，从文件区拷贝到对换区。

(2) 系统缺少足够的对换区空间，这时凡是不会被修改的文件，都直接从文件区调入；而当换出这些页面时，由于它们未被修改而不必再将它们换出时，以后需要时，再从对换区调入。

(3) UNIX方式。

由于与进程有关的文件都放在文件区，故凡是未运行过的页面，都从文件区调入。

而对于曾经运行过但又被换出的页面，由于被放在对换区，因此在下次时，应从对换区调入。

由于UNIX系统允许页面共享，因此，某进程所请求的页面有可能已被其它进程调入内存，此时也就无须再从对换区调入。

3页面调入过程每当程序所要访问的页面未在内存时，便向CPU发出一缺页中断，中断处理程序首先保留CPU环境，分析中断原因后，转入缺页中断处理程序。

该程序通过查找页表，得到该页在外在原物理块后，如果此时内存能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。

如果内存已满，则须先按照某种置换算法从内存中选出一页准备换出；如果该页未被修改过，可不必将该页写回磁盘；但如果此页已被修改，则必须将它写回磁盘，然后再把所缺的页调入内存，并修改页表中的相应表项，置其存在位“1”，并将此页表项写入快表中。

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

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

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

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

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

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

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

㈠常见置换算法①最佳置换算法(Optimal)：它是由Belady于1966年提出的一种理论上的算法。

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

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

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

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

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

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

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

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

由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t,，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。

七、各模块的伪码算法（1）先进先出算法伪码算法void fifo() //先进先出算法{int i=2,m,j;queye=1;a[1][0]=a[0][0];for(j=1;j<20;j++){if (i>3)i=1;if (find(j)=='F') //调用查找函数{a[i][j]=a[0][j];for(m=1;m<4;m++){if(m!=i)a[m][j]=a[m][j-1]; } queye=queye+1;i=i+1;}else{a[1][j]=a[1][j-1];a[2][j]=a[2][j-1];a[3][j]=a[3][j-1];return('F');}（2）OPT置换算法伪码算法void opt() //OPT置换算法{int i,j,m,t;a[1][0]=a[0][0];for(j=1;j<3;j++){for(i=1;i<j+2;i++){if((i-j)==1)a[i][j]=a[0][j];elsea[i][j]=a[i][j-1];}}int findo(int j) //查找OPT的函数{if (a[1][j-1]==a[0][m])x=m;if (a[2][j-1]==a[0][m])y=m;if (a[3][j-1]==a[0][m])z=m;}//max=x;t=1;if (y>x && y>z)t=2;if(z>x && z>y)t=3;return (t);}（3）LRu置换算法伪码算法void lru() //LRu置换算法{int u,j,i;int k;a[1][0]=a[0][0];//a[1][1]=a[0][0];for(j=1;j<3;j++){for(i=1;i<j+2;i++){if((i-j)==1)a[i][j]=a[0][j];elsea[i][j]=a[i][j-1];}}queye=3;for (j=3;j<20;j++){if (find(j)=='T') //调用查找函数{}a[3][j]=a[0][j];int l(int j) //查找要替换的位置{if (a[0][j]==a[1][j-1])return(1);if (a[0][j]==a[2][j-1])return(2);if (a[0][j]==a[3][j-1])return(3); }3、函数的调用关系图V oid fifo()函数流程图：Char find()函数流程图：V oid opt()流程图：int findo()流程图：V oid lru()流程图：Int l()流程图：4、测试请求页式存储管理中常用页面置换算法运行结果设计总结经过本次课程设计，完成题目“常用页面置换算法原理模拟实验”，熟悉了UNIX/LINUX的常用基本命令，理解并掌握了UNIX提供的vi编辑器来编译C 程序，学会利用gcc、gdb编译、调试C程序。

页面置换算法模拟实验 操作系统大作业(含源文件)

页面置换算法模拟实验报告材料

操作系统实验三(页面置换算法)实验报告材料

实验六 页面置换算法模拟实验

操作系统实验 页面置换算法模拟

页面置换算法源程序+实验报告

北邮-操作系统试验-页面置换算法

计算机操作系统页面置换算法模拟(DOC)

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

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

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

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

操作系统课程实验报告编程模拟页面置换算法

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

页面置换算法模拟实验操作系统大作业(含源文件)

实验六页面置换算法模拟实验

操作系统实验页面置换算法模拟