实验请求页式存储管理页面置换算法
页面置换算法的实验报告
的程序段和数据存放于外存待执行时调入，以提高内存利用率而提出来的页式管 理有动态页式管理和静态页式管理之分，动态页式管理是在静态页式管理的基础 上发展起来的。请求页式管理属于动态页式管理中的一种，它的地址变换过程与 静态页式管理时的相同，也是通过页表查出相应的页面号，由页面号与页内相对 地址相加而得到实际物理地址。有关的地址变换部分是由硬件自动完成的。当硬 件变换机构发现所要求的页不在内存时，产生缺页中断信号，由中断处理程序做 出相应的处理。中断处理程序是由软件实现的。除了在没有空闲页面时要按照置 换算法选择出被淘汰页面之外，还要从外存读入所需要的虚页。这个过程要启动 相应的外存和涉及到文件系统。因此，请求页式管理是一个十分复杂的过程，内 存利用率的提高是以牺牲系统开销的代价换来的。这里用到了置换算法。它是在 内存中没有空闲页面时被调用。目的是选出一个被淘汰的页面。如果内存中有足 够的空闲页面存放所调入的页，则不必使用置换算法。把内存和外存统一管理的 真正目的是把那些被访问概率非常高的页存放在内存中。因此，置换算法应该置 换那些被访问概率低的页，将它们移出内存。
第五章 调试............................................................................................................................... 16 第六章 体会与自我评价........................................................................................................ 18 第七章 参考文献...................................................................................................................... 19
存储管理
为了设计上述算法，可先用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同算法计算出命中率。
程序中的数据结构：
(1)页面类型
typedef struct {
int pn, pfn, counter, time;
}pl_type;
if(busypf_tail==NULL) busypf_head=busypf_tail=freepf_head;
else
{
busypf_tail->next=freepf_head;
busypf_tail=freepf_head;
}
freepf_head=p;
}
pl[i].counter=0;
pl[i].time=-1; /*置页面控制结构中的访问次数，时间为-1*/
}
for(i=1;i<total_pf;i++)
{
pfc[i-1].next=&pfc[i];
pfc[i-1].pfn=i-1;
} /*建立pfc[i-1]和pfc[i]之间的链接*/
第0条—第9条指令为第0页（对应虚存地址为[0, 9]）；
第10条—第19条指令为第1页（对应虚存地址为[10, 19]）；
┊
第310条—第319条指令为第31页（对应虚存地址为[310, 319]）；
按以上方式，用户指令可组成32页。
3．计算并输出下面各种算法在不同内存容量下的命中率：
int disaffect; 页面失效次数
5．程序的结构框架
#include <math.h>
实验五 请求页式存储管理中常用页面置换算法模拟
else { cout<<"---输入有误，物理块数请选择1-10的数---"<<endl<<"请输入分配的物理块数的大小:"; cin>>Nsize; } } break; case 2: cout<<"请输入分配的物理块数的大小: "; cin>>Nsize; while(1) { if(Nsize>0&&Nsize<=10) { Init(QString,Nsize); cout<<"页面号引用串: "; for(i=0;i<Psize;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"LRU算法结果如下:"<<endl; LRU(Nsize); BlockClear(Nsize); cout<<"----------------------"<<endl; system("pause"); system("cls");
void BlockClear(int Nsize) {//块清除 for(int i=0; i<Nsize; i++) { block[i].yemian = -1; block[i].biaoji = 0; } } /*主程序*/ void main(void) { int i,select,Nsize,QString[Psize]={0}; while(select) { cout<<"页面号引用串: "; for(i=0;i<20;i++) { cout<<QString[i]<<" "; } cout<<endl; cout<<"+******************************+"<<endl; cout<<"+------------欢迎--------------+"<<endl; cout<<"+--------页面置换算法----------+"<<endl; cout<<"+-----选择<1>应用FIFO算法------+"<<endl; cout<<"+-----选择<2>应用LRU算法-------+"<<endl; cout<<"+-----选择<3>应用OPT算法-------+"<<endl; cout<<"+---选择<4>插入新的页面号引用串+"<<endl; cout<<"+-------选择<0>退出------------+"<<endl;
实验请求页式存储管理页面置换算法
操作系统实验报告班级:计科0801班姓名：韩伟伟学号：08407106 时间：2018-5-25实验五请求页式存储管理的页面置换算法一．实验目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二．实验属性设计三．实验内容1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条至第9条指令为第0页；第10条至19条指令为第1页；…第310条至319条指令为第31页。
3.计算并输出下述各种算法在不同内存容量下的命中率。
(1>先进先出算法<FIFO）(2>最近最少使用算法<LRU）(3>最佳使用算<OPT）命中率＝１－页面失效次数／页地址流长度本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
四．思路关于随机数的产生办法。
首先要初始化设置随机数，产生序列的开始点，例如，通过下列语句实现：srand ( 400 > ；(1>计算随机数，产生320条指令序列m＝160；for (i＝0；i＜80；i++＝{j＝i﹡4；a[j]＝m；a[j+1]＝m+1；a[j+2]＝a[j] ﹡1.0﹡ rand( >/32767；a[j+3]＝a[j+2]+1m＝a[j+3]+(319-a[j+3]> ﹡1.0﹡rand( >/32767；}(2>将指令序列变换成为页地址流for ( k＝0；k＜320；k++>{ pt＝a[k]/10；pd= a[k]%10；…}(3>计算不同算法的命中率rate＝1-1.0﹡U/320 ；其中U为缺页中断次数，320是页地址流长度。
存储管理实验报告_6
昆明理工大学信息工程与自动化学院学生实验报告（2012 —2013 学年第二学期）一、实验目的存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
通过本次实验, 要求学生通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解, 通过请求页式存储管理中页面置换算法模拟设计, 了解虚拟存储技术的特点, 掌握请求页式存储管理的页面置换算法。
二、实验原理及基本技术路线图（方框原理图）用C或C++语言模拟实现请求式分页管理。
要求实现: 页表的数据结构、分页式内存空间的分配及回收（建议采用位图法）、地址重定位、页面置换算法（从FIFO,LRU,NRU中任选一种）。
int subareaSize[num]={8,12,16,32,24,16,64,128,40,64};//分区大小Process *pro=NULL;//保持进程信息int ProcessNum=0;//进程数目int applyProcessNum=0;//每次申请进程数目int maxApplyNum=0;//最大可申请数目int *applyIndex=NULL;//申请进程队列int totalApplyNum=0;//申请总数int *assignPointer=NULL;//已分配内存的进程队列int assignFlag=0;//分配索引, 表示已申请队列已分配的进程数int exeIndex;//执行的进程号Node *subareaNode=new Node[3];//分区回收时, 进程所在分区及其前, 后分区信息LinkList createLinkList(int n );//建立空闲分区链Node firstFit(LinkList &head,Process pro);//首次适应算法Node nestFit(LinkList &head,Process pro,Node flag);//循环适应算法Node bestFit(LinkList &head,Process pro);//最佳适应算法Node worstFit(LinkList &head,Process pro);//最坏适应算法Node assign(LinkList &head,int orderIndex,int index,Node flagNode);//一次分区分配int assignMemory(LinkList &head);//内存分配void insertNode(LinkList &head,Node q,int index);//插入节点Node deleteNode(LinkList &head,int index);//删除节点int display(LinkList &head);//打印分区分配情况int lowAttemper(int *excursionPointer);//低级调度int findSubarea(LinkList &head,int index);//回收内存int creatProcess();//创建进程Process* randomCreatPro(int n);//随机产生进程下面是各种方法简述:(1) 最优替换算法, 即OPT算法。
虚拟存储器管理实验报告
淮海工学院计算机科学系实验报告书课程名：《操作系统》题目：虚拟存储器管理页面置换算法模拟实验班级：学号：姓名：一、实验目的与要求1.目的：请求页式虚存管理是常用的虚拟存储管理方案之一。
通过请求页式虚存管理中对页面置换算法的模拟，有助于理解虚拟存储技术的特点，并加深对请求页式虚存管理的页面调度算法的理解。
2.要求：本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。
其中虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。
要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。
程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。
二、实验说明1．设计中虚页和实页的表示本设计利用C语言的结构体来描述虚页和实页的结构。
在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。
pfn代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。
time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。
在实页结构中中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。
pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。
next是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。
2．关于缺页次数的统计为计算命中率，需要统计在20次的虚页访问中命中的次数。
为此，程序应设置一个计数器count，来统计虚页命中发生的次数。
每当所访问的虚页的pfn项值不为-1，表示此虚页已被装入某实页内，此虚页被命中，count加1。
最终命中率=count/20*100%。
请求页式管理的页面置换算法
实验报告课程：操作系统班级：成绩：指导教师：实验密级：预习程度：仪器组次：必修/选修：姓名：学号：实验日期：实验时间：实验序号：实验名称：访问实验二请求页式管理中的置换算法实验目的与要求：１．采用FIFO〔先进先出〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。
２．采用LFU〔最不经常使用〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。
实验仪器：名称型号数量微机1一、实验内容１．假设有一个用户进程P的地址空间为n〔n=60〕页，系统已在内存中给该进程分配有m〔m<n，m=8〕个页面，且该进程的第0、5、6页〔p0、p5、p6〕已经装入内存，页长为1K。
根据进程访问的字地址序列，采用不同的置换算法，分别计算缺页中断率。
２．进程依次要访问的字地址序列〔访问串〕，在0~1024*n-1〔0~61439〕中模拟随机发生，访问序列的随机生成规那么为：50%的字地址前向顺序增长，25%的字地址均匀分布在前地址〔低地址〕局部，25%的字地址均匀分布在后地址〔高地址〕局部，为了减少模拟次数，前向顺序递增产生的字地址如小于1024*n-51360927〕那么自动加512。
模拟访问串长度为100。
以n=60为例，字地址序列〔访问串〕的随机生成方法如下：〔1〕在[0，61439]之间随机产生起始字地址，当前访问的字地址记为k；〔2〕前向顺序递增产生的字地址为 k+1+512；〔3〕前地址〔低地址〕在[0，k-1]内随机产生；〔4〕后地址〔高地址〕在[k+1，61439]内随机产生；〔5〕重复顺序递增、前地址区间随机产生、后地址区间随机产生的过程，概率分别为：50%、25%、25%。
二、实验要求１．采用FIFO〔先进先出〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。
２．采用LFU〔最不经常使用〕置换算法，发生缺页中断时，给出相应的字地址及页号，计算缺页中断率。
操作系统请求分页式存储管理页面置换算法课程设计报告
操作系统程序设计课程设计报告课题: 请求分页式存储管理页面置换算法姓名：学号：同组姓名：专业班级：指导教师：设计时间：目录1. 系统描述 (3)2. 分析与设计 (3)2.1.系统功能模块图 (3)2.2.系统文件结构描述 (3)2.3.系统功能流程图 (4)2.4．UI设计以及操作说明： (4)2.5.测试数据及期望 (11)3.系统测试 (12)4.总结心得体会 (12)5.参考文献 (13)6.核心代码 (13)1. 系统描述系统使用.net framework 4.0开发的，图形用户界面使用winform程序设计，功能模块分别实现了请求分页式存储管理的LRU算法，FIFO 算法。
通过虚拟系统存储的概念和实现方法，进行运行的时候不需要把所有页面都装入内存中，只需要将部分页面调入内存，就可以运行。
在运行过程中，若要访问的页面不在内存中，则需用请求调入的功能将其装入内存中，如果此时内存中没有空白的物理块，就通过页面置换功能淘汰一个页面，根据LRU,FIFO两种淘汰算法来进行页面置换，并能计算出FIFO，LRU两种算法在不同内存容量中的的命中率。
系统运行时通过输入访问内存的顺序，以及分配的内存页面数，来进行二种算法的页面置换，实现了虚拟存储的功能和特点。
2. 分析与设计2.1.系统功能模块图图4.1 页式存储管理模块划分2.2.系统文件结构描述2.3.系统功能流程图开始还有指令？计算页号找到了吗？新页进入计算过程数组第一位，其余为一次下移计算命中率结束YNNY FIFO开始还有指令？计算页号找到了吗？比较现有页面计数项的大小，新页面替换最大项页面计算命中率结束YNNY LRU2.4．UI 设计以及操作说明：主窗体：#region访问顺序private void btnSure_Click(object sender, EventArgs e){if (txtOrder.Text.Equals("")){MessageBox.Show("访问顺序字符串不能为空！！！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);return;}order = txtOrder.Text;listBox1.Items.Clear();string[] page = order.Split(' ');foreach (string pg in page){listBox1.Items.Add(pg);}txtOrder.Text = "";allocation alca = new allocation();this.Hide();DialogResult d = alca.ShowDialog();if (d == DialogResult.OK){this.Show();btnAlloc.Enabled = true;btnFifo.Enabled = true;btnlru.Enabled = true;alpage = alca.page;}}#endregion输入访问内存顺序，点击确定：#region确定内存页分配private void button1_Click(object sender, EventArgs e){if (textBox1.Text.Equals("")){MessageBox.Show("内存页面数不能为空！！！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);return;}page = Convert.ToInt32(textBox1.Text.Trim());this.Close();}#endregion输入分配内存页面数，点击确定：点击FIFO置换：FIFO 算法：淘汰最先进入的页面，也就是淘汰进入内存中驻留时间最长的页面，先进先出。
操作系统实验4-请求分页存储管理模拟实验
实验四请求分页存储管理模拟实验一：实验目的通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求分页存储管理系统的原理和实现技术的理解。
二：实验内容假设每个页面可以存放10条指令，分配给进程的存储块数为4。
用C语言或Pascal语言模拟一进程的执行过程。
设该进程共有320条指令，地址空间为32个页面，运行前所有页面均没有调入内存。
模拟运行时，如果所访问的指令已经在内存，则显示其物理地址，并转下一条指令；如果所访问的指令还未装入内存，则发生缺页，此时需要记录缺页产生次数，并将相应页面调入内存，如果4个内存块已满，则需要进行页面置换。
最后显示其物理地址，并转下一条指令。
在所有指令执行完毕后，显示进程运行过程中的缺页次数和缺页率。
页面置换算法：分别采用OPT、FIFO、LRU三种算法。
进程中的指令访问次序按如下原则生成：50%的指令是顺序执行的。
25%的指令是均匀分布在低地址部分。
25%的指令是均匀分布在高地址部分。
三：实验类别分页存储管理四：实验类型模拟实验五：主要仪器计算机六：结果OPT:LRU:FIFO:七：程序# include<stdio.h># include<stdlib.h># include<conio.h># define blocknum 4//页面尺寸大小int m; //程序计数器，用来记录按次序执行的指令对应的页号static int num[320]; //用来存储320条指令typedef struct BLOCK //声明一种新类型--物理块类型{int pagenum; //页号int accessed; //访问量，其值表示多久未被访问}BLOCK;BLOCK block[blocknum]; //定义一大小为8的物理块数组void init() //程序初始化函数,对block初始化{for(int i=0;i<blocknum;i++){block[i].pagenum=-1;block[i].accessed=0;m=0;}}int pageExist(int curpage)//查找物理块中页面是否存在,寻找该页面curpage是否在内存块block中，若在，返回块号{for(int i=0; i<blocknum; i++){if(block[i].pagenum == curpage )return i; //在内存块block中，返回块号}return -1;}int findSpace()//查找是否有空闲物理块,寻找空闲块block，返回其块号{for(int i=0;i<blocknum;i++){if(block[i].pagenum==-1)return i; //找到了空闲的block，返回块号}return -1;}int findReplace()//查找应予置换的页面{int pos = 0;for(int i=0;i<blocknum;i++){if(block[i].accessed > block[pos].accessed)pos = i; //找到应该置换页面，返回BLOCK中位置}return pos;void display()//显示物理块中的页面号{for(int i=0; i<blocknum; i++){if(block[i].pagenum != -1){printf(" %02d ",block[i].pagenum);printf("%p |",&block[i].pagenum);}}printf("\n");}void randam()//产生320条随机数,显示并存储到num[320]{int flag=0;printf("请为一进程输入起始执行指令的序号(0~320):\n");scanf("%d",&m);//用户决定的起始执行指令printf("******进程中指令访问次序如下：(由随机数产生)*******\n");for(int i=0;i<320;i++){//进程中的320条指令访问次序的生成num[i]=m;//当前执行的指令数，if(flag%2==0)m=++m%320;//顺序执行下一条指令if(flag==1)m=rand()%(m-1);//通过随机数，跳转到低地址部分[0，m-1]的一条指令处，设其序号为m1if(flag==3)m=m+1+(rand()%(320-(m+1)));//通过随机数，跳转到高地址部分[m1+2，319]的一条指令处，设其序号为m2flag=++flag%4;printf(" %03d",num[i]);//输出格式：3位数if((i+1)%10==0) //控制换行,每个页面可以存放10条指令，共32个页面printf("\n");}}void pagestring() //显示调用的页面序列,求出此进程按次序执行的各指令所在的页面号并显示输出{for(int i=0;i<320;i++){printf(" %02d",num[i]/10);//输出格式：2位数if((i+1)%10==0)//控制换行,每个页面可以存放10条指令，共32个页面printf("\n");}}void OPT() //最佳替换算法{int n=0;//记录缺页次数int exist,space,position;int curpage;//当前指令的页面号for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist=pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space=findSpace();if(space != -1){ //当前存在空闲的物理块block[space].pagenum = curpage; //将此页面调入内存display();//显示物理块中的页面号n++;//缺页次数+1}else{ //当前不存在空闲的物理块，需要进行页面置换for(int k=0;k<blocknum;k++){for(int j=i;j<320;j++){//找到在最长（未来）时间内不再被访问的页面if(block[k].pagenum!= num[j]/10){block[k].accessed = 1000;} //将来不会被访问，设置为一个很大数else{ //将来会被访问，访问量设为jblock[k].accessed = j;break;}}}position = findReplace();//找到被置换的页面 ,淘汰block[position].pagenum = curpage;// 将新页面调入display();n++; //缺页次数+1}}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void LRU() //最近最久未使用算法{int n=0;//记录缺页次数int exist,space,position ;int curpage;//当前指令的页面号for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist = pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space = findSpace();if(space != -1){ //当前存在空闲的物理块block[space].pagenum = curpage; //将此页面调入内存display();//显示物理块中的页面号n++;//缺页次数+1}else{ //当前不存在空闲的物理块，需要进行页面置换position = findReplace();block[position].pagenum = curpage;display();n++; //缺页次数+1}}elseblock[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1for(int j=0; j<blocknum; j++){//其余的accessed++block[j].accessed++;}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void FIFO(){int n=0;//记录缺页次数int exist,space,position ;int curpage;//当前指令的页面号int blockpointer=-1;for(int i=0;i<320;i++){m=num[i];curpage=m/10;exist = pageExist(curpage);if(exist==-1){ //当前指令的页面号不在物理块中space = findSpace();if(space != -1){ //当前存在空闲的物理块blockpointer++;block[space].pagenum=curpage; //将此页面调入内存n++;//缺页次数+1display();//显示物理块中的页面号}else{ // 没有空闲物理块，进行置换position = (++blockpointer)%4;block[position].pagenum = curpage; //将此页面调入内存n++;display();}}}printf("缺页次数:%d\n",n);printf("缺页率:%f%%\n",(n/320.0)*100);}void main(){int choice;printf("************请求分页存储管理模拟系统*************\n");randam();printf("************此进程的页面调用序列如下**************\n");pagestring();while(choice != 4){printf("********1:OPT 2:LRU 3:FIFO 4:退出*********\n");printf("请选择一种页面置换算法:");scanf("%d",&choice);init();switch(choice){case 1:printf("最佳置换算法OPT:\n");printf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");OPT();break;case 2:printf("最近最久未使用置换算法LRU:\n");printf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");LRU();break;case 3:printf("先进先出置换算法FIFO:\n");printf("页面号物理地址页面号物理地址页面号物理地址页面号物理地址\n");FIFO();break;}}}。
请求页式管理中的置换算法
请求页式管理中的置换算法页式管理是计算机内存管理的一种方式，它利用虚拟内存和分页技术使得操作系统可以在有限的物理内存下运行更多的进程。
在页式存储管理中，操作系统将物理内存分成若干个固定的大小的块，称为物理块，同时将进程分成若干个大小相等的块，称为页面。
当一个进程需要访问某个页面时，操作系统就将页面调入物理块中，若所有物理块都被占满，则需要选择一个物理块将其替换成即将调入的页面，这就需要使用到置换算法。
常见的置换算法有如下几种：1. 先进先出算法（FIFO）该算法是最简单的、最易实现的一种页面置换算法。
其原理是将先进入内存的页面优先替换出去。
使用一个先进先出的队列来维护物理块的使用情况，每次选择队列头的页面进行置换。
因此该算法的缺点就是无法考虑页面替换的实际使用情况。
2. 最近最少使用算法（LRU）该算法会将最近未被使用的页面优先置换出去，即在内存中驻留时间最长的页面最不容易被替换出去。
其难点在于如何确定何时页面被使用过。
可以使用栈或者链表来实现。
3. 最不常用算法（LFU）该算法会将内存中使用次数最少的页面优先置换出去，即在内存中使用次数最少的页面最容易被替换出去。
为实现该算法，需要维护每个页面的使用次数。
4. 时钟算法（Clock）该算法是一种Clock页面置换算法，在物理块使用情况时采用了一个环形链表的结构。
每个页面都有一个标志位，若该位为1，则说明该页面在当前的一轮中被使用过，同时将该位变为0；若该位为0，则说明该页面未被使用过，这时候会考虑是否将该页面替换出去。
5. 二次机会算法（Second chance）该算法对时钟算法进行了改进，增加了一个修改位，表明是否被修改过。
每次选择的是位0(未被使用/未被修改)或者1(未被使用/被修改)的页面，如果选择到的是1则把修改位清零，并转化为0重新加入内存块队列。
以上是常见的五种页面置换算法，不同的算法有各自的优缺点，需要根据内存管理的需要、机器性能和系统配置来选择合适的算法来实现。
页面置换算法实验报告
操作系统课程设计报告课程名称：操作系统课程设计课程设计题目：页面置换算法学院：计算机科学与技术学院专业：科技小组成员: 庞思慧E01114081王蒙E01114161姚慧乔E01114349朱潮潮E01114408指导老师：***目录1 实验目的 (3)2 实验要求 (3)3 实验内容与步骤 (3)4 算法思想 (4)5 模块设计 (4)6 程序设计 (5)7 测试结果 (7)8 结果分析 (9)9 程序代码 (9)10 课程设计小结 (24)页面置换算法模拟设计1.实验目的（1）通过模拟实现几种基本页面置换的算法，了解虚拟存储技术的特点。
（2）掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想，并至少用三种算法来模拟实现。
（3）通过对几种置换算法命中率的比较，来对比他们的优缺点。
2.实验要求计算并输出下述各种算法在不同内存容量下的命中率。
A 先进先出的算法（FIFO）B 最近最少使用算法（LRU）C最佳淘汰算法（OPT）3.实验内容与步骤(1)通过随机数产生一个指令序列，共320条指令，具体的实施方法是：A．[0，319]的指令地址之间随机选取一起点M;B．顺序执行一条指令，即执行地址为M+1的指令；C．在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’;D．顺序执行一条指令，其地址为M’+1；E．在后地址[M’+2，319]中随机选取一条指令并执行；F．重复A—E，直到执行320次指令。
(2)指令序列变换成页地址流A.页面大小为1K；B.用户内存容量为4页到32页；C.用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条—第9条指令为第0页（对应虚存地址为[0，9]）；第10条—第19条指令为第1页（对应虚存地址为[10，19]）；。
第310条—第319条指令为第31页（对应虚存地址为[310，319]）；(3)计算并输出上述各种算法在不同内存容量下的命中率。
实验四+页面置换算法
页面置换算法模拟实验【实验目的】1 ）进一步掌握虚拟存储器的工作原理。
2）通过实验理解和掌握FIFO, LRU，OPT三种页面置换算法。
3）比较各种页面置换算法的优缺点。
【实验要求】1）认真阅读和掌握预备知识。
2）上机操作。
【预备知识】在采用请求分页机制的操作系统中，当运行一个进程的时侯，若所要访问的页面不在内存中而需要把它们调入内存，但此时内存已无空闲空间，为了保证该进程能正常运行，需选择内存中暂时不用的一个页面调出到磁盘交换区。
选择调出哪个页面，由页面置换算法决定。
页面置换算法的好坏，直接影响着系统的性能。
一个好的页面置换算法，应尽可能选择调出较长时间内不会再访问的页面，以保证较低的缺页率。
常见的页面置换算法有OPT （最佳置换算法），FIFO （先进先出算法）及LRU （最近最久未使用算法）。
一、OPT算法1. 原理简述1）在分配内存页面数（B）小于进程页面数（P）时，最先用到的B个页面依次放入内存；2）这时若需要处理新的页面，而当前分配的内存页面全部不空闲时，选择换出以后永远不再使用的页。
如没有这样的页面存在，则应选择下次访问距离现在最久的页换出，以空出内存来放置新调入的页面；3）以后如果有新页面需要调入，按“2）”之规则进行。
该算法能保证有最低的缺页率，所以称为最佳置换算法。
但是该算法仅仅是一种理想状况下的算法，因为在进程实际运行过程中，将来会执行到哪个页是不可预知的，所以无法选择该置换哪个页出去。
因此，本算法在实际中无法使用，只能作为一种标准来衡量其他算法的性能。
2. 图表描述假设某个进程在交换区被分为5个页面（P=5 ），分别以1，2，3，4，5表示。
在该进程运行过程中，处理机调用它们的顺序即页地址流为：而系统分配给该进程的内存空间只有 3 （B= 3 ）个页面，那么在使用OPT算法时，这3个页面的内存使用情况应该是：为了便于比较学习，例子和前面的一样。
在使用FIFO 算法时，这3个页面的内存使用523355 42(f)、FIFO 算法1. 原理简述1） 在分配内存页面数（B ）小于进程页面数（P ）时，最先用到的 B 个页面依次放入内 存； 2） 这时若需要处理新的页面，则从当前内存中的 B 个页面中选择调出最先进入的那个页（所以称为FIFO ）,然后放入新页面；3） 以后如果有新页面需要调入，按“ 2）”之规则进行。
常用页面置换算法模拟实验 说明书
*******************实践教学*******************兰州理工大学计算机与通信学院2012年秋季学期操作系统原理课程设计题目：常用页面置换算法模拟实验专业班级：计算机科学与技术4班姓名：宋辉学号：10240424指导教师：王燕成绩：目录摘要 (3)正文 (4)1、设计思路 (4)2、各模块的伪码算法 (7)3、函数的调用关系图 (10)4、测试 (17)设计总结 (18)参考文献 (19)致谢 (18)附录：部分源程序代码 (19)摘要UNIX中，为了提高内存利用率，提供了内外存进程对换机制；内存空间的分配和回收均以页为单位进行；一个进程只需将其一部分（段或页）调入内存便可运行；还支持请求调页的存储管理方式。
当进程在运行中需要访问某部分程序和数据时，发现其所在页面不在内存，就立即提出请求（向CPU发出缺页中断），由系统将其所需页面调入内存。
这种页面调入方式叫请求调页，为实现请求调页，核心配置了四种数据结构：页表、页框号、访问位、修改位、有效位、保护位等。
此设计为了了解UNIX的命令及使用格式，熟悉UNIX/LINUX的常用基本命令，练习并掌握UNIX提供的vi编辑器来编译C程序，学会利用gcc、gdb 编译、调试C程序，学会如何把学到的知识用于解决实际问题，培养学生的能力。
关键字UNIX 请求调页数据结构存储管理编辑器调试C程序正文一、设计思路页面置换算法：当CPU接收到缺页中断信号，中断处理程序先保存现场，分析中断原因，转入缺页中断处理程序。
该程序通过查找页表，得到该页所在外存的物理块号。
如果此时内存未满，能容纳新页，则启动磁盘I/O将所缺之页调入内存，然后修改页表。
如果内存已满，则须按某种置换算法从内存中选出一页准备换出，是否重新写盘由页表的修改位决定，然后将缺页调入，修改页表。
利用修改后的页表，去形成所要访问数据的物理地址，再去访问内存数据。
整个页面的调入过程对用户是透明的。
请求页式存储管理中常用页面置换算法模拟.
湖南科技学院计算机与信息科学系实验报告实验名称请求页式存储管理中常用页面置换算法模拟课程名称计算机操作系统所属系部班级计科0902时间2011年12地E305月8日第3,4节点姓名姜泽政学号200908001217成绩本组成员（一人一组）一、实验要求1、熟练掌握页面请求算法的原理；2、熟练掌握页面置换算法的思路；3、上机前编写程序源码；4、上机后，写好实验报告和实验结果，实验报告交任课教师。
二、实验目的页式虚拟存储器实现的一个难点是设计页面调度（置换）算法，即将新页面调入内存时，如果内存中所有的物理页都已经分配出去，就要按某种策略来废弃某个页面，将其所占据的物理页释放出来，供新页面使用。
本实验的目的是通过编程实现几种常见的页面调度（置换）算法，加深读者对页面思想的理解三、实验环境每人一台电脑，在下实现。
四、实验内容及过程（1）设计程序实现以上三种页面调度算法，要求：①.可以选择页面调度算法类型；②.可以为进程设置分到物理页的数目，设置进程的页面引用情况，可以从键盘输入页面序列，也可从文件中读取；③.随时计算当前的页面调度次数的缺页中断率；④.使用敲键盘或响应WM-TIMER的形式模仿时间的流逝；⑤.以直观的的形式将程序的执行情况显示在计算机屏幕上；⑥.存盘及读盘功能，可以随时将数据存入磁盘文件，供以后重复实验时使用。
（2）假定进程分配到3个物理块，对于下面的页面引用序列：7-0-1-2-0-3-0-4-2-3-0-3-2-1-2-0-1-7-0-1请分别用先进和先出调度算法，最近最少用调度算法，最近最不常用调度算法计算缺页中断次数，缺页中断率和缺页调度次数、缺页置换率。
再假定进程分配到4、5个物理块，重复本实验。
（3）假定进程分配到3个物理块，对于下面的页面引用序列：4-3-2-1-4-3-5-4-3-2-1-5-0-7-3-8-9-0-2-1-4-7-3-9请分别用先进先出调度算法、最近最少用调度算法，最近最不常用调度算法计算缺页中断次数，缺页中断率和缺页调度次数、缺页置换率。
请求页式存储管理的页面置换算法
请求页式存储管理的页面置换算法实验环境Linux 2.6.24实验内容设计一个虚拟存储区和内存工作区,并使用下列算法计算页面失效次数.（1）进先出的算法（FIFO）（2）最近最少使用的算法（LRU）（3）最佳淘汰算法(OPT)在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
算法描述及实验步骤实验步骤（1）通过随机数产生一个指令序列，共320条指令。
指令的地址按下述原则生成：①50%的指令是顺序执行的；②50%的指令是均匀分布在前地址部分；③50%的指令是均匀分布在后地址部分。
具体的实施方法是：①在[0，319] 的指令之间随即选取一起点m;②顺序执行一条指令，即执行地址为m+1的指令；③在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m′；④顺序执行一条指令，其地址为m′+ 1；⑤在后地址[m′+ 2，319]中随机选取一条指令并执行；⑥重复上述步骤①-⑤，直到执行320次指令。
（2）将指令序列变换为页地址流设：①页面大小为1k；②用户内存容量为4页到32页；③用户虚存容量为32k。
在用户虚存中，按每k存放10条指令排在虚存地址，即320条指令在虚存中的存放方式为：第0条-第9条指令为第0页（对应虚存地址为[0，9]）；第10条-第19条指令为第一页（对应虚存地址为[10，19]）；… …第310条~第319条指令为第31页（对应虚地址为[310，319]）。
按以上方式，用户指令可组成32页。
（3）计算并输出下述各种算法在不同内存容量下的页面失效次数。
①先进先出的算法（FIFO）；②最近最少使用算法（LRU)；③最佳淘汰算法（OPT）先淘汰最不常用的页地址；随机数产生办法，Linux或UNIX系统提供函数strand()和rand(),分别进行初始化和产生随机数。
例如：strand (); 语句可初始化一个随机数；a[0]=10*rand()/65535*319+1;a[1]=10*rand()/65535*a[0];语句可用来产生a[0]与a[1]中的随机数实验指导本实验的程序设计基本上按照实验内容进行。
请求页式存储管理中常用页面置换算法
计算机操作系统实验报告大学信息科学与技术学院2013年xx月xx日一、实验概述1. 实验名称请求页式存储管理中常用页面置换算法管理2. 实验目的（1）了解存分页管理策略（2）掌握调页策略（3）掌握一般常用的调度算法（4）学会各种存储分配算法的实现方法。
（5）了解页面大小和存实际容量对命中率的影响3. 实验容（1）采用页式分配存储方案，通过分别计算不同算法的命中率来比较算法的优劣，同时也考虑页面大小及存实际容量对命中率的影响；（2）实现OPT 算法(最优置换算法) 、LRU 算法(Least Recently) 、FIFO 算法(First IN First Out)的模拟；（3）使用某种编程语言模拟页面置换算法。
二、实验环境C语言三、实验过程1. 设计思路和流程图选择置换算法，先输入所有页面号，为系统分配物理块，依次进行置换2. 算法实现（1）OPT基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组next[mSIZE]记录物理块中对应页面的最后访问时间。
每当发生缺页时，就从物理块中找出最后访问时间最大的页面，调出该页，换入所缺的页面。
（2）FIFO基本思想：是用队列存储存中的页面，队列的特点是先进先出，与该算法是一致的，所以每当发生缺页时，就从队头删除一页，而从队尾加入缺页。
或者借助辅助数组time[mSIZE]记录物理块中对应页面的进入时间，每次需要置换时换出进入时间最小的页面。
(3)LRU基本思想：是用一维数组page[pSIZE]存储页面号序列，memery[mSIZE]是存储装入物理块中的页面。
数组flag[10]标记页面的访问时间。
每当使用页面时，刷新访问时间。
发生缺页时，就从物理块中页面标记最小的一页，调出该页，换入所缺的页面。
3.源程序并附上注释#include <stdio.h>#include <stdlib.h>/*全局变量*/int mSIZE; /*物理块数*/int pSIZE; /*页面号引用串个数*/static int memery[10]={0}; /*物理块中的页号*/static int page[100]={0}; /*页面号引用串*/static int temp[100][10]={0}; /*辅助数组*//*置换算法函数*/void FIFO();void LRU();void OPT();/*辅助函数*/void print(unsigned int t);void designBy();void download();void mDelay(unsigned int Delay);/*主函数*/void main(){int i,k,code;system("color 0A");designBy();printf("┃请按任意键进行初始化操作... ┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");printf(" >>>");getch();system("cls");system("color 0B");printf("请输入物理块的个数(M<=10)：");scanf("%d",&mSIZE);printf("请输入页面号引用串的个数(P<=100)：");scanf("%d",&pSIZE);puts("请依次输入页面号引用串(连续输入，无需隔开)：");for(i=0;i<pSIZE;i++)scanf("%1d",&page[i]);download();system("cls");system("color 0E");do{puts("输入的页面号引用串为：");for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}}printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("* 请选择页面置换算法：\t\t\t *\n");printf("* ----------------------------------------- *\n");printf("* 1.先进先出(FIFO) 2.最近最久未使用(LRU) *\n");printf("* 3.最佳(OPT) 4.退出*\n");printf("* * * * * * * * * * * * * * * * * * * * * * *\n");printf("请选择操作：[ ]\b\b");scanf("%d",&code);switch(code){case 1:FIFO();break;case 2:LRU();break;case 3:OPT();break;case 4:system("cls");system("color 0A");designBy(); /*显示设计者信息后退出*/printf("┃使用页面置换算法演示器! 正版授权㊣┃\n");printf("┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");exit(0);default:printf("输入错误，请重新输入：");}printf("按任意键重新选择置换算法：>>>");getch();system("cls");}while (code!=4);getch();}/*载入数据*/void download(){int i;system("color 0D");printf("╔════════════╗\n");printf("║正在载入数据，请稍候!!!║\n");printf("╚════════════╝\n");printf("Loading...\n");printf(" O");for(i=0;i<51;i++)printf("\b");for(i=0;i<50;i++){mDelay((pSIZE+mSIZE)/2);printf(">");}printf("\nFinish.\n载入成功，按任意键进入置换算法选择界面：>>>");getch();}/*设置延迟*/void mDelay(unsigned int Delay){unsigned int i;for(;Delay>0;Delay--){for(i=0;i<124;i++){printf(" \b");}}}/*显示设计者信息*/void designBy(){printf("┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("┃课题三：页面置换算法┃\n");printf("┃学号：┃\n");printf("┃：瑶┃\n");printf("┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"); }void print(unsigned int t){int i,j,k,l;int flag;for(k=0;k<=(pSIZE-1)/20;k++){for(i=20*k;(i<pSIZE)&&(i<20*(k+1));i++){if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))printf("%d\n",page[i]);elseprintf("%d ",page[i]);}for(j=0;j<mSIZE;j++){for(i=20*k;(i<mSIZE+20*k)&&(i<pSIZE);i++){if(i>=j)printf(" |%d|",temp[i][j]);elseprintf(" | |");}for(i=mSIZE+20*k;(i<pSIZE)&&(i<20*(k+1));i++){for(flag=0,l=0;l<mSIZE;l++)if(temp[i][l]==temp[i-1][l])flag++;if(flag==mSIZE)/*页面在物理块中*/printf(" ");elseprintf(" |%d|",temp[i][j]);}/*每行显示20个*/if(i%20==0)continue;printf("\n");}}printf("----------------------------------------\n");printf("缺页次数：%d\t\t",t+mSIZE);printf("缺页率：%d/%d\n",t+mSIZE,pSIZE);printf("置换次数：%d\t\t",t);printf("访问命中率：%d%%\n",(pSIZE-(t+mSIZE))*100/pSIZE);printf("----------------------------------------\n");}/*计算过程延迟*/void compute(){int i;printf("正在进行相关计算，请稍候");for(i=1;i<20;i++){mDelay(15);if(i%4==0)printf("\b\b\b\b\b\b \b\b\b\b\b\b");elseprintf("Θ");}for(i=0;i++<30;printf("\b"));for(i=0;i++<30;printf(" "));for(i=0;i++<30;printf("\b"));}/*先进先出页面置换算法*/void FIFO(){int memery[10]={0};int time[10]={0}; /*记录进入物理块的时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];time[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++;/*计算换出页*/max=time[0]<time[1]?0:1;for(m=2;m<mSIZE;m++)if(time[m]<time[max])max=m;memery[max]=page[i];time[max]=i; /*记录该页进入物理块的时间*/for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}/*最近最久未使用置换算法*/void LRU(){int memery[10]={0};int flag[10]={0}; /*记录页面的访问时间*/int i,j,k,m;int max=0; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];flag[i]=i;for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;elseflag[j]=i; /*刷新该页的访问时间*/ }if(k==mSIZE) /*如果不在物理块中*/{count++;/*计算换出页*/max=flag[0]<flag[1]?0:1;for(m=2;m<mSIZE;m++)if(flag[m]<flag[max])max=m;memery[max]=page[i];flag[max]=i; /*记录该页的访问时间*/for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else{for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}/*最佳置换算法*/void OPT(){int memery[10]={0};int next[10]={0}; /*记录下一次访问时间*/int i,j,k,l,m;int max; /*记录换出页*/int count=0; /*记录置换次数*//*前mSIZE个数直接放入*/for(i=0;i<mSIZE;i++){memery[i]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}for(i=mSIZE;i<pSIZE;i++){/*判断新页面号是否在物理块中*/for(j=0,k=0;j<mSIZE;j++){if(memery[j]!=page[i])k++;}if(k==mSIZE) /*如果不在物理块中*/{count++;/*得到物理快中各页下一次访问时间*/for(m=0;m<mSIZE;m++){for(l=i+1;l<pSIZE;l++)if(memery[m]==page[l])break;next[m]=l;}/*计算换出页*/max=next[0]>=next[1]?0:1;for(m=2;m<mSIZE;m++)if(next[m]>next[max])max=m;/*下一次访问时间都为pSIZE,则置换物理块中第一个*/memery[max]=page[i];for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}else {for(j=0;j<mSIZE;j++)temp[i][j]=memery[j];}}compute();print(count);}6. 程序运行时的初值和运行结果1. 按任意键进行初始化：2. 载入数据：3. 进入置换算法选择界面：4.运算中延迟操作5.三种算法演示结果：四、实验体会掌握了一般的调度算法，了解了页面大小和存实际容量对命中率的影响。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验报告班级:计科0801班姓名：韩伟伟学号：08407106 时间：2018-5-25实验五请求页式存储管理的页面置换算法一．实验目的通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二．实验属性设计三．实验内容1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：50％的指令是顺序执行的；25％的指令是均匀分布在前地址部分；25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：第0条至第9条指令为第0页；第10条至19条指令为第1页；…第310条至319条指令为第31页。
3.计算并输出下述各种算法在不同内存容量下的命中率。
(1>先进先出算法<FIFO）(2>最近最少使用算法<LRU）(3>最佳使用算<OPT）命中率＝１－页面失效次数／页地址流长度本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
四．思路关于随机数的产生办法。
首先要初始化设置随机数，产生序列的开始点，例如，通过下列语句实现：srand ( 400 > ；(1>计算随机数，产生320条指令序列m＝160；for (i＝0；i＜80；i++＝{j＝i﹡4；a[j]＝m；a[j+1]＝m+1；a[j+2]＝a[j] ﹡1.0﹡ rand( >/32767；a[j+3]＝a[j+2]+1m＝a[j+3]+(319-a[j+3]> ﹡1.0﹡rand( >/32767；}(2>将指令序列变换成为页地址流for ( k＝0；k＜320；k++>{ pt＝a[k]/10；pd= a[k]%10；…}(3>计算不同算法的命中率rate＝1-1.0﹡U/320 ；其中U为缺页中断次数，320是页地址流长度。
(4>输出格式k fifo 1ru4 0.23 0.25…32 1.0 1.0五．实验报告1．写出你编写的C语言程序。
#include<conio.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#define Myprintf printf("|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n"> /*表格控制*/#define bsize 4 //物理块大小#define psize 16 //进程大小typedef struct page{int num。
/*记录页面号*/int time。
/*记录调入内存时间*/}Page。
/* 页面逻辑结构，结构为方便算法实现设计*/Page b[bsize]。
/*内存单元数*/int c[bsize][psize]。
/*暂保存内存当前的状态：缓冲区*/int queue[100]。
/*记录调入队列*/int K。
/*调入队列计数变量*/int phb[bsize]={0}。
//物理块标号int pro[psize]={0}。
//进程序列号int flag[bsize] = {0}。
//进程等待次数(存放最久未被使用的进程标志>int i = 0, j = 0,k = 0。
//i表示进程序列号,j表示物理块号int m = -1, n = -1。
//物理块空闲和进程是否相同判断标志int max = -1,maxflag = 0。
//标记替换物理块进程下标int count = 0。
//统计页面缺页次数//**************************************************************////**************************************************************//随机产生序列号函数//**************************************************************int* build(>{printf("随机产生一个进程序列号为：\n">。
int i = 0。
for(i=0。
i<psize。
i++>{pro[i] = 10*rand(>/(RAND_MAX+1>+1。
printf("%d ",pro[i]>。
}printf("\n">。
return(pro>。
}//**************************************************************//查找空闲物理块//**************************************************************int searchpb(>{for(j=0。
j<bsize。
j++>{if(phb[j] == 0>{m = j。
return m。
break。
}}return -1。
}//**************************************************************//查找相同进程//**************************************************************int searchpro(>{for(j = 0。
j < bsize。
j++>{if(phb[j] == pro[i]>{n = j。
return j。
}}return -1。
}//**************************************************************//初始化内存//**************************************************************void empty(>{for(i=0。
i<bsize。
i++>phb[i]=0。
count=0。
//计数器置零}//**************************************************************//先进先出页面置换算法//**************************************************************void FIFO(>{for(i = 0。
i<psize。
i++>{m=searchpb(>。
n=searchpro(>。
//找flag值最大的for(j = 0。
j < bsize。
j++>{if(flag[j]>maxflag>{maxflag = flag[j]。
max = j。
}}if(n == -1> //不存在相同进程{if(m != -1> //存在空闲物理块{phb[m] = pro[i]。
//进程号填入该空闲物理块count++。
flag[m] = 0。
for(j = 0。
j <= m。
j++>{flag[j]++。
}m = -1。
}else //不存在空闲物理块{phb[max] = pro[i]。
flag[max] = 0。
for(j = 0。
j < bsize。
j++>flag[j]++。
}max = -1。
maxflag = 0。
count++。
}}else //存在相同的进程{phb[n] = pro[i]。
for(j = 0。
j < bsize。
j++>{flag[j]++。
}n = -1。
}for(j = 0 。
j < bsize。
j++>{printf("%d ",phb[j]>。
}printf("\n">。
}printf("缺页次数为：%d\n",count>。
printf("\n">。
}//************************************************************** //************************************************************** /*初始化内存单元、缓冲区*/void Init(Page *b,int c[bsize][psize]>{int i,j。
for(i=0。
i<psize。
i++>{b[i].num=-1。
b[i].time=psize-i-1。
}for(i=0。
i<bsize。
i++>for(j=0。
j<psize。
j++>c[i][j]=-1。
}/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/int GetMax(Page *b>{int max=-1。
int tag=0。
for(i=0。
i<bsize。
i++>{if(b[i].time>max>{max=b[i].time。
tag=i。
}}return tag。
}/*判断页面是否已在内存中*/int Equation(int fold,Page *b>{int i。
for(i=0。
i<bsize。
i++>{if (fold==b[i].num>return i。
}return -1。
}/*LRU核心部分*/void Lruu(int fold,Page *b>{int i。
int val。
val=Equation(fold,b>。
if (val>=0>{b[val].time=0。
for(i=0。
i<bsize。
i++>if (i!=val>b[i].time++。
}else{queue[++K]=fold。
/*记录调入页面*/ val=GetMax(b>。
b[val].num=fold。