实验报告关于请求调页存储管理方式

合集下载

实验二--请求分页存储管理模拟实验

实验二--请求分页存储管理模拟实验

实验二请求分页存储管理模拟实验一、实验目的:通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。

熟悉虚存管理的各种页面淘汰算法。

通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。

二、实验要求:设计一个请求页式存储管理方案。

并编写模拟程序实现。

(1)产生一个需要访问的指令地址流。

它是一系列需要访问的指令的地址。

为不失一般性,你可以适当地(用人工指定地方法或用随机数产生器)生成这个序列。

(2)简单起见,页面淘汰算法采用LRU页面淘汰算法,并且在淘汰一页时,只将该页在页表中抹去。

而不再判断它是否被改写过,也不将它写回到辅存。

#include<iostream>#include<stdio.h>#include<stdlib.h>#include<string.h>using namespace std;struct pagetable{int pagenumber;//页号int phnumber;//物理块号int state;//状态位int visit;//访问字段int modify;//修改位int address;//外存地址};struct logicA{int pagenumber;int pagedaddress;};pagetable p[10];int ph[4]={1,2,3,4};//4个物理块int j=0;bool boolph[4]={true,true,false,true};void show(){for(int i=0;i<5;i++){cout<<"页号\t"<<"物理块号\t"<<"状态位\t"<<"访问字段"<<endl;cout<<p[i].pagenumber<<"\t"<<p[i].phnumber<<"\t\t"<<p[i].state<<"\t"<<p[i].visit<<endl;}}int phaddress;void disp(int i,logicA log[]){int page;page=log[i].pagenumber;if(page>5)cout<<"越界"<<endl;else{if(p[page].state==1){p[page].visit++;phaddress=log[i].pagedaddress+4096*p[page].phnumber;cout<<"在内存中---------------------------------"<<endl;show();cout<<"物理地址为:"<<phaddress<<endl;}else{int sum=0;for(int i=0;i<5;i++)sum+=p[i].state;if(sum==4)//内存满{int temp=1000,j,x;for( j=0;j<5;j++){if(p[j].state==1&&p[j].visit<temp){temp=p[j].visit;x=j;}}p[page].phnumber=p[x].phnumber;p[page].state=1;p[x].state=0;p[x].phnumber=0;cout<<"内存已经满,替换第"<<x+1<<"块"<<endl;show();}else //内存未满{cout<<"内存未满,调入页面进内存----------------------"<<endl;if(p[page].modify==0){for(int j=0;j<4;j++){if(!boolph[j]){p[page].phnumber=ph[j];boolph[j]=true;}}p[page].state=1;show();}else{cout<<"先写回外存"<<endl;cout<<"外存换回内存"<<endl;for(int j=0;j<4;j++){if(!boolph[j]){p[page].phnumber=ph[j];boolph[j]=true;}}p[page].state=1;show();}}}}}void init(){p[0].pagenumber=0;p[0].phnumber=1;p[0].state=0;p[0].visit=1;p[0].modify=0;//1 p[1].pagenumber=1;p[1].phnumber=0;p[1].state=0;p[1].visit=0;p[1].modify=0;//2 p[2].pagenumber=2;p[2].phnumber=2;p[2].state=0;p[2].visit=2;p[2].modify=1;//3 p[3].pagenumber=3;p[3].phnumber=0;p[3].state=0;p[3].visit=0;p[3].modify=0;//4 p[4].pagenumber=4;p[4].phnumber=4;p[4].state=0;p[4].visit=1;p[4].modify=0;//5 }void logic(){int logicAddress;//31——12 为页号(0-4),11-0为页内地址(5-7)212=4KB int sum;init();while(1){printf("输入逻辑地址快数:");scanf("%d",&sum);logicA log[sum];for(int i=0;i<sum;i++){printf("输入第%d个逻辑地址:",i+1);scanf("%d",&logicAddress);//show();log[i].pagenumber=logicAddress/4096; //4kBlog[i].pagedaddress=logicAddress%4096;disp(i,log);}}}int main(){logic();//show();return 0;}。

实验四 存储管理

实验四  存储管理

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

2 实验内容:1)通过随机数产生一个指令序列,共320条指令;2)将指令序列变换为页面号;3)计算FIFO算法在分配不同内存块下的命中率。

(假设分配的内存块从4块至32块。

)<程序设计>设计一个虚拟存储区和内存工作区,使用FIFO算法计算访问命中率。

首先用Srand()和rand()函数定义和产生指令序列,然后将指令序列变换成相应的页面号,并针对FIFO算法计算相应的命中率。

命中率=1-缺页率相关定义如下:1.数据结构(1)页面类型结构pl_type中pn页号,pfn块号,counter为一个周期内访问页面次数,time为访问时间(2)页面控制结构中pfc[total_vp]定义用户进程虚页控制结构*freepf_head为空页面头的指针*busypf_head为忙页面头的指针*busypf_tail为忙页面尾的指针2.函数定义(1)void initialize():初始化函数,给每个相关的页面赋值(2)void FIFO():计算使用FIFO算法时的命中率3.变量定义(1)int a[total_instruction]:指令流数组(2)int page[total_instruction]:每条指令所属页号(3)int offset[total_instruction]:每页装入10条指令后取模运算页号偏移值(4)int total_pf:用户进程的内存块数(5)int diseffect:页面失效次数,即缺页次数[root@localhost ~]# cd wuxiaofeng[root@localhost wuxiaofeng]# pwd/root/wuxiaofeng[root@localhost wuxiaofeng]# cat >fifo.c#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <unistd.h>#define TRUE 1#define FALSE 0#define INVALID -1#define NULL 0#define total_instruction 320 //指令流长#define total_vp 32 //虚页长#define clear_period 50 //清零周期typedef struct{ //定义页面类型int pn; //pn为页号int pfn; //pfn为块号int counter; //为一个周期内访问页面次数int time; //为访问时间}pl_type;pl_type pl[total_vp]; //页面结构数组struct pfc_struct{ //定义页面控制结构int pn,pfn;struct pfc_struct *next;};typedef struct pfc_struct pfc_type;pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;[root@localhost wuxiaofeng]# cp www.c mmm.c//pfc[total_vp]定义用户进程虚页控制结构//*freepf_head为空内存块号的头指针//*busypf_head为忙内存块的头指针//*busypf_tail为忙内存块的尾指针int diseffect, a[total_instruction];int page[total_instruction], offset[total_instruction];//int a[total_instruction]:指令流数组//int page[total_instruction]:每条指令所属页号//int offset[total_instruction]:每页装入10条指令后取模运算页号偏移值//int diseffect:页面失效次数void initialize();void FIFO();main(){int S,i,j,temp;srand(getpid()*10); //由于每次运行时进程号不同,故可用来作为初始化[root@localhost wuxiaofeng]# cp www.c mmm.c随机数队列的“种子”S=(float)319*rand()/32767+1;for(i=0;i<total_instruction;i+=4) //产生指令队列{a[i]=S; //任选一指令访问点a[i+1]=a[i]+1; //顺序执行一条指令a[i+2]=(float)a[i]*rand()/RAND_MAX; //执行前地址指令m'a[i+3]=a[i+2]+1; //执行后地址指令S=(float)rand()*(318-a[i+2])/RAND_MAX+a[i+2]+2;}for(i=0;i<total_instruction;i++) //将指令序列变换成页地址流{page[i]=a[i]/10;offset[i]=a[i]%10;}for(i=4;i<=32;i++) //用户内存工作区从4个块到32个块{printf("%2d page frames",i);[root@localhost wuxiaofeng]# cp www.c mmm.cFIFO(i);printf("\n");}}void FIFO(total_pf)int total_pf; //用户进程的内存块数{int i,j;pfc_type *p,*t;initialize(total_pf); //初始化相关内存块控制用数据结构busypf_head=busypf_tail=NULL;for(i=0;i<total_instruction;i++){if(pl[page[i]].pfn==INVALID) //页面失效{diseffect+=1; // 失效次数if(freepf_head==NULL) //无空闲块{p=busypf_head->next;pl[busypf_head->pn].pfn=INVALID;freepf_head=busypf_head; //释放忙内存块队列中的第一个块freepf_head->next=NULL;busypf_head=p;[root@localhost wuxiaofeng]# cp www.c mmm.c}p=freepf_head->next; //按FIFO方式调新页面入内存块freepf_head->next=NULL;freepf_head->pn=page[i];pl[page[i]].pfn=freepf_head->pfn;if(busypf_tail==NULL)busypf_head=busypf_tail=freepf_head;else{busypf_tail->next=freepf_head;busypf_tail=freepf_head;}freepf_head=p;}}printf(" FIFO:%6.4f",1-(float)diseffect/320);}void initialize(total_pf) //初始化相关数据结构int total_pf; //用户进程的内存页面数{int i;diseffect=0;for(i=0;i<total_vp;i++){pl[i].pn=i;pl[i].pfn=INVALID; //置页面控制结构中的页号,页面为空pl[i].counter=0;pl[i].time=-1; //页面控制结构中的访问次数为0,时间为-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]之间的连接}pfc[total_pf-1].next=NULL;pfc[total_pf-1].pfn=total_pf-1;freepf_head=&pfc[0]; //空页面队列的头指针为pfc[0]}[root@localhost wuxiaofeng]# lsa.out fifo.c[root@localhost wuxiaofeng]# /root/wuxiaofeng/a.out4 page frames FIFO:0.54065 page frames FIFO:0.56256 page frames FIFO:0.58137 page frames FIFO:0.59068 page frames FIFO:0.60629 page frames FIFO:0.612510 page frames FIFO:0.637511 page frames FIFO:0.656212 page frames FIFO:0.671913 page frames FIFO:0.681314 page frames FIFO:0.696915 page frames FIFO:0.715616 page frames FIFO:0.728117 page frames FIFO:0.750018 page frames FIFO:0.759419 page frames FIFO:0.771920 page frames FIFO:0.775021 page frames FIFO:0.781222 page frames FIFO:0.809423 page frames FIFO:0.843824 page frames FIFO:0.843825 page frames FIFO:0.843826 page frames FIFO:0.843827 page frames FIFO:0.850028 page frames FIFO:0.887529 page frames FIFO:0.893830 page frames FIFO:0.893831 page frames FIFO:0.893832 page frames FIFO:0.9000[root@localhost wuxiaofeng]#实验小结:通过本次实验,我收获很多。

操作系统实验4-请求分页存储管理模拟实验

操作系统实验4-请求分页存储管理模拟实验

实验四请求分页存储管理模拟实验一:实验目得通过对页面、页表、地址转换与页面置换过程得模拟,加深对请求分页存储管理系统得原理与实现技术得理解.二:实验内容假设每个页面可以存放10条指令,分配给进程得存储块数为4。

用C语言或Pascal语言模拟一进程得执行过程。

设该进程共有320条指令,地址空间为32个页面,运行前所有页面均没有调入内存。

模拟运行时,如果所访问得指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问得指令还未装入内存,则发生缺页,此时需要记录缺页产生次数,并将相应页面调入内存,如果4个内存块已满,则需要进行页面置换。

最后显示其物理地址,并转下一条指令。

在所有指令执行完毕后,显示进程运行过程中得缺页次数与缺页率.页面置换算法:分别采用OPT、FIFO、LRU三种算法。

进程中得指令访问次序按如下原则生成:50%得指令就是顺序执行得。

25%得指令就是均匀分布在低地址部分.25%得指令就是均匀分布在高地址部分.三:实验类别分页存储管理四:实验类型模拟实验五:主要仪器计算机六:结果OPT:LRU:FIFO:七:程序# i nclude 〈stdio 、h 〉# incl ude 〈stdlib 、h 〉# include 〈conio 、h># def ine blockn um 4//页面尺寸大小int m; //程序计数器,用来记录按次序执行得指令对应得页号s ta ti c in t num [320]; //用来存储320条指令typedef s truct BLOCK //声明一种新类型—-物理块类型{ﻩint pagenum; //页号ﻩint acces sed; //访问量,其值表示多久未被访问}BLOCK ;BLOCK bl ock [bl ocknum ]; //定义一大小为8得物理块数组void init () //程序初始化函数,对bl ock 初始化{for (int i=0;i <blo cknum;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]得一条指令处,设其序号为m2ﻩﻩflag=++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;ﻩintcurpage;//当前指令得页面号ﻩ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(intk=0;k<blocknum;k++)ﻩﻩﻩﻩ{for(int j=i;j〈320;j++)ﻩ{//找到在最长(未来)时间内不再被访问得页面ﻩﻩﻩﻩif(block[k]、pagenum!= num[j]/10)ﻩﻩﻩ{ﻩﻩblock[k]、accessed = 1000;ﻩﻩﻩ} //将来不会被访问,设置为一个很大数ﻩﻩﻩelseﻩﻩﻩ{ //将来会被访问,访问量设为jﻩﻩﻩblock[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ﻩ}ﻩﻩ}elseﻩﻩblock[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++;//缺页次数+1ﻩﻩﻩ display();//显示物理块中得页面号ﻩ}ﻩ 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;ﻩ}}}。

实验请求页式存储管理页面置换算法

实验请求页式存储管理页面置换算法

操作系统实验报告班级:计科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)命中率=1-页面失效次数/页地址流长度本实验中,页地址流长度为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

存储管理实验报告_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算法。

请求页式存储管理方案设计说明书

请求页式存储管理方案设计说明书

请求页式存储管理方案设计说明书一:实验题目:设计一个请求页式存储管理方案,为简单起见。

页面淘汰算法采用FIFO页面淘汰算法,并且在淘汰一页时,只将该页在页表中修改状态位。

而不再判断它是否被改写过,也不将它写回到辅存。

[基本要求]页面尺寸1K,输入进程大小(例如5300bytes),对页表进行初始化, 页表结构:系统为进程分配3 个物理块(页框),块号分别为0、1、2,页框管理表(空闲块表):任意输入一个需要访问的指令地址流(例如:3635、3642、1140、0087、1700、5200、4355,输入负数结束),打印页表情况。

每访问一个地址时,首先要计算该地址所在的页的页号,然后查页表,判断该页是否在主存——如果该页已在主存,则打印页表情况;如果该页不在主存且页框未满(查空闲块表,找到空闲块),则调入该页并修改页表,打印页表情况;如果该页不在主存且页框已满,则按FIFO页面淘汰算法淘汰一页后调入所需的页,修改页表,打印页表情况;二:实验题目与要求:1.实验题目:请求页式存储管理方案。

2.要求:实现请求页式的管理,再淘汰一页时,只修改该页在页表中的状态位,不再判断它是否被改写过。

2.功能模块四:模块功能介绍1.页表初始化:根据输入的进程大小初始化页表。

初始化的内容包括:计算页表长度,将状态位置零,物理块号置零。

2.地址链表建立:将输入的地址流以链表的形式存储,3.页面调用:从地址链表的头指针开始调页。

调页包括:首先计算所调页面的页号,对于不在内存中的页面使用请求调页策略。

4。

页面置换:对于不在内存中的页面采用先进先出策略进行置换,置换包括:改变页表的状态位,换入请求页面,换出最早调入的页面。

五:主要模块代码:import java.util.*;public class Memory{static int h=0;static int n=0;//主程序public static void main(String[] args){//创建页表int presize=Integer.parseInt(args[0]);//获得进程的大小int j;int lengh=presize/1024+1;//页号int leaf[]=new int[lengh];for(int x=0;x<lengh;x++){leaf[x]=x;}//块号int block[]=new int[lengh];for(int x=0;x<lengh;x++){block[x]=-1;}//标志位int flag[]=new int[lengh];for(int x=0;x<lengh;x++){flag[x]=0;}int a[]=new int[3];for(int x=0;x<3;x++){a[x]=0;}//块信息int d[]=new int[3];for(int x=0;x<3;x++){d[x]=x;}System.out.println("页表长:"+lengh);System.out.println("请输入指令地址流:");for(int k=1;k<lengh;k++){int i=Integer.parseInt(args[k]);//获得地址的大小System.out.print("指令地址:"+i);System.out.println("");if(i<0){System.exit(0);}if(i>presize){System.out.println("地址超出范围!");}else{j=i/1024;if(n<3){block[j]=h;flag[j]=1;a[h]=j;h++;System.out.println("页信息:");System.out.println("页号"+"块号"+"标志");for(int m=0;m<lengh;m++){System.out.println(leaf[m]+" "+block[m]+""+flag[m]+" ");}System.out.println("块信息:");System.out.println("块号"+"进程");for(int m=0;m<3;m++){System.out.println(d[m]+" "+a[m]+" ");}}else{n=0;int y=a[n];a[n]=j;block[y]=-1;flag[j]=0;n++;System.out.println("页信息:");System.out.println("页号"+"块号"+"标志");for(int m=0;m<lengh;m++){System.out.println(leaf[m]+" "+block[m]+" "+flag[m]+" ");}System.out.println("块信息:");System.out.println("块号"+"进程");for(int m=0;m<3;m++){System.out.println(d[m]+" "+a[m]+" ");}}}}}。

操作系统-请求页式存储管理实验报告分析解析

操作系统-请求页式存储管理实验报告分析解析

操作系统-请求页式存储管理实验报告分析解析实验背景在计算机系统中,内存是一项很重要的资源。

其中,操作系统需要管理内存,以便为用户进程和内核提供适当的内存空间。

页式内存管理是操作系统能够管理和维护内存的一种方式。

在页式内存管理中,主存分为固定大小的框架,称为页框,而进程的地址空间被分割为固定大小的页。

页式内存管理系统采用了一种称为“请求页式存储”的技术,允许进程只存取正在使用的那些页面。

这样可以节省空间,并且提高了处理器访问内存的速度。

实验环境本次实验使用的操作系统是 Ubuntu 20.04 LTS 操作系统。

实验目标本次实验的主要目标是通过模拟请求页式内存管理系统,来了解和深入理解页式内存管理技术。

本次实验需要完成以下任务:1.编写一个简单的请求页式存储模拟器;2.使用该模拟器对作业和内存进行模拟;3.分析模拟结果并撰写实验报告。

实验过程阅读并理解作业说明在开始实验之前,我们首先需要阅读和了解具体的作业说明。

在本次实验中,我们需要完成一个请求页式存储模拟器,以及使用该模拟器对作业与内存进行模拟。

编写模拟器在了解了作业说明后,我们开始按照作业的要求,编写请求页式内存管理模拟器。

在这里,我们需要使用到Python 编程语言。

实际上,我们在编写该模拟器时,主要分为以下几步:1.文件操作:首先,我们需要通过读取文件中的数据来模拟进程对内存的请求。

在输入文件中,每一行表示一个请求,包含了进程 ID、请求的地址和访问类型。

2.内存分配:接着,我们需要模拟请求页式内存管理系统中对于内存分配的操作,即在访问时,将需要的页加载到内存中,如果内存已满,则需要选择一个页面将其从内存中移除,为新的页面腾出空间。

3.页面置换:如果进行页面置换,则需要选出最久未访问的页面并移出内存,空出空间用于新的页面,这就是所谓的“最久未使用”(LRU)策略。

进行模拟有了模拟器之后,我们就可以针对不同的作业和内存大小进行实验。

在实验的过程中,我们可以观察不同大小的内存和不同的作业怎样影响模拟的结果。

实验六请求分页存储管理

实验六请求分页存储管理

实验六:请求分页存储管理一.实验目的深入理解请求页式存储管理的基本概念和实现方法,重点认识其中的地址变换、缺页中断、置换算法等实现思想。

二.实验属性该实验为综合性、设计性实验。

三.实验仪器设备及器材普通PC386以上微机四.实验要求本实验要求2学时完成。

本实验要求完成如下任务:(1)建立相关的数据结构:页表、页表寄存器、存储块表等;(2)指定分配给进程的内存物理块数,设定进程的页面访问顺序;(3)设计页面置换算法,可以选择OPT、FIFO、LRU等,并计算相应的缺页率,以比较它们的优劣;(4)编写地址转换函数,实现通过查找页表完成逻辑地址到物理地址的转换;若发生缺页则选择某种置换算法(OPT、FIFO、LRU等)完成页面的交换;(5)将整个过程可视化显示出来。

实验前应复习实验中所涉及的理论知识和算法,针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。

实验后认真书写符合规范格式的实验报告(参见附录A),并要求用正规的实验报告纸和封面装订整齐,按时上交。

三、设计过程3.1算法原理分析OPT算法是未来最远出现,当当前内存中没有正要访问的页面时,置换出当前页面中在未来的访问页中最远出现的页面或再也不出现的页面。

FIFO算法是先进先出,当当前内存中没有正要访问的页面时,置换出最先进来的页面。

LRU算法是最近最久未使用,当当前内存中没有正要访问的页面时,置换出在当前页面中最近最久没有使用的页面。

3.2数据定义int length,num_page,count,seed; //length记录访问串的长度,num_page页面数,count记录缺页次数int result[20][30],order[30],a[10]; //result记录结果,order存储访问串,a存储当前页面中的值int pos1,flag1,flag2,flag3; //pos1位置变量,flag1等为标志变量 char result1[30]; //记录缺页数组 void opt() //最佳void fifo() //先进先出bool search(int n) //查找当前内存中是否已存在该页3.3流程图与运行截图图6.1 FIFO ()函数流程图;否是 是否 开始得到执行的指令指令是否在内存中最先存入指令被淘汰下面是否还有指令 结束得出命中率图2.2 OPT算法流程图四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

实验报告关于请求调页存储管理方式

实验报告关于请求调页存储管理方式

《网络操作系统》课程设计报告书题目:请求调页存储管理方式的模拟学号:学生姓名:指导教师:年月日目录一. 实验内容................................................... 错误!未定义书签。

二. 实验目的................................................... 错误!未定义书签。

三. 设计思想................................................... 错误!未定义书签。

四. 程序流程图................................................. 错误!未定义书签。

五. 程序清单................................................... 错误!未定义书签。

六. 运行结果及分析............................................. 错误!未定义书签。

七. 总结....................................................... 错误!未定义书签。

一、实验内容1.假设每个页面中可存放10条指令,分配给作业的内存块数为4。

2.用C语言或C++语言模拟一个作业的执行过程,该作业共有320条指令,即它的地址空间为32页,目前它的所有页都还未调入内存。

在模拟过程中,如果所访问的指令已在内存,则显示其物理地址,并转下一条指令。

如果所访问的指令还未装入内存,则发生缺页,此时需记录缺页的次数,并将相应页调入内存。

如果4个内存块均已装入该作业,则需进行页面置换,最后显示其物理地址,并转下一条指令。

在所有320指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。

3.置换算法:请分别考虑最佳置换算法(OPT)、先进先出(FIFO)算法和最近最久未使用(LRU)算法。

实验六请求分页存储管理

实验六请求分页存储管理

实验六:请求分页存储管理一.实验目的深入理解请求页式存储管理的基本概念和实现方法,重点认识其中的地址变换、缺页中断、置换算法等实现思想。

二.实验属性该实验为综合性、设计性实验。

三.实验仪器设备及器材普通PC386 以上微机四.实验要求本实验要求 2 学时完成。

本实验要求完成如下任务:(1)建立相关的数据结构:页表、页表寄存器、存储块表等;(2)指定分配给进程的内存物理块数,设定进程的页面访问顺序;(3)设计页面置换算法,可以选择OPT、FIFO 、LRU 等,并计算相应的缺页率,以比较它们的优劣;(4)编写地址转换函数,实现通过查找页表完成逻辑地址到物理地址的转换;若发生缺页则选择某种置换算法(OPT、FIFO、LRU 等)完成页面的交换;(5)将整个过程可视化显示出来。

实验前应复习实验中所涉及的理论知识和算法,针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。

实验后认真书写符合规范格式的实验报告(参见附录 A ),并要求用正规的实验报告纸和封面装订整齐,按时上交。

三、设计过程3.1 算法原理分析OPT 算法是未来最远出现,当当前内存中没有正要访问的页面时,置换出当前页面中在未来的访问页中最远出现的页面或再也不出现的页面。

FIFO 算法是先进先出,当当前内存中没有正要访问的页面时,置换出最先进来的页面。

LRU 算法是最近最久未使用,当当前内存中没有正要访问的页面时,置换出在当前页面中最近最久没有使用的页面。

3.2 数据定义int length,num_page,count,seed; //length 记录访问串的长度,num_page 页面数,count 记录缺页次数int result[20][30],order[30],a[10]; //result 记录结果,order 存储访问串,a 存储当前页面中的值int pos1,flag1,flag2,flag3; 〃pos1 位置变量,flagl 等为标志变量char result1[30]; // 记录缺页数组void opt() //最佳void fifo() //先进先出bool search(i nt n) 〃查找当前内存中是否已存在该页3.3流程图与运行截图图6.1 FIFO ()函数流程图替换内存中将来不岀现或离当前最 图22 OPT 算法流程图 1 5 7 8 4 5 41 2 直1 机& 随B 内5 !£」八-?--- 3 丄度产串- 匸番问数 剽的控访个 馬早随面页6 圣5 邸入入生入示四、小结本次课程设计目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

操作系统-请求页式存储管理实验报告

操作系统-请求页式存储管理实验报告

操作系统-请求页式存储管理实验报告操作系统实验三存储管理实验班级:学号:姓名:目录1. 实验目的 ..................................................................... ........................................................................ (2)2. 实验内容 ..................................................................... ........................................................................ (2)(1) 通过随机数产生一个指令序列,共320条指令 ..................................................................... ............ 2 (2) 将指令序列变换成为页地址流 ..................................................................... ........................................ 2 (3) 计算并输出下述各种算法在不同内存容量下的命中率 .....................................................................23. 随机数产生办法 ..................................................................... (3)环境说明 ..................................................................... ........................................................................ . (3)4. 程序设计说明 ..................................................................... . (3)4.1. 全局变量...................................................................... (3)4.2. 随机指令序列的产生...................................................................... . (4)4.3. FIFO算法...................................................................... .. (4)4.4. LRU算法...................................................................... . (4)4.5. OPT算法...................................................................... . (5)5. 编程实现(源程序): ................................................................... ....................................................... 5 6. 运行结果及分析 ..................................................................... . (11)6.1. 运行(以某两次运行结果为例,列表如下:).................................................................... . (11)6.2. Belady’s anomaly................................................................. . (11)11. 实验目的存储管理的主要功能之一是合理地分配空间。

请求页式管理实验报告

请求页式管理实验报告

请求页式管理一、实验目的:1.学会用各种存储分配算法的实现方法。

2.了解页面大小和内存实际容量对命中率的影响。

二、实验要求:1.采用下列分配存储方案,通过分别计算不同算法的命中率与比较算法的优劣,同时也考虑页面大小及内存实际容量对命中率的影响。

2.假定虚存空间Vsize=32K,页面大小Psize从1K到8K(每次加倍)。

内存容量Msize从4页到虚存空间大小。

3.要求算法:1)OPT算法2)LRU算法3)FIFO算法4)NUR算法(可以选择其中两种完成)举例:主要数据结构typedef struct{int sign;//表示该内存页面有未被分配int pagenumber;//表示该空间是分配的虚存中的哪一页int entertime;//表示该页何时被分配int usetime;//表示该页何时被使用}三、本程序用到的主要数据结构struct SERIAL //记录随机访问序列的一项的情况{int PageID; //页号bool bFIFO; //用FIFO方法时是否命中bool bOPT; //用OPT方法时是否命中bool bLRU; //用LRU方法时是否命中int NextSame;//记录OPT算法的当前页号与下一个相同页号的距离};struct MEMITEM{int PageSize; //页面大小float FIFORate; // 对当前页面大小情况下20个随机序列测试下来的平均命中率float OPTRate;float LRURate;HTREEITEM hti;//用于树控件显示的句柄SERIAL Serial[20]; //20个随机生成的页面号测试序列};struct PAGEITEM{int vPageSize;float AveFIFORate;float AveOPTRate;float AveLRURate;HTREEITEM hti;CArray<MEMITEM,MEMITEM> VMemItem;};struct MEMSTACK{int PageID;int BlockID;int UseTime; //表示该页何时被使用int NextSame;};CArray<MEMSTACK,MEMSTACK>FIFOStack;CArray<MEMSTACK,MEMSTACK>OPTStack;CArray<MEMSTACK,MEMSTACK>LRUStack;//CArray<MEMPAGE,MEMPAGE>MemBlock;//CArray<MAR,MAR>MemPage;PAGEITEM VPageItem[4];HTREEITEM hti[4];说明:本程序通过实验比较三种算法FIFO、OPT、LRU由要求二:假定虚存空间Vsize=32K,页面大小Psize从1K到8K(每次加倍)。

请求页式管理实验报告

请求页式管理实验报告

操作系统请求页式存储管理报告学院:班级:姓名:学号:请求页式存储管理一、问题描述设计一个请求页式存储管理方案,为简单起见。

页面淘汰算法采用 FIFO页面淘汰算法,并且在淘汰一页时,只将该页在页表中修改状态位。

而不再判断它是否被改写过,也不将它写回到辅存。

二、基本要求页面尺寸1K,输入进程大小(例如5300bytes),对页表进行初始化,页表结构:页号物理块号状态位0 2 True (在主存)1 12 False (在辅存)3 04 False (在辅存)5 False (在辅存)系统为进程分配3 个物理块(页框),块号分别为0、1、2,页框管理表(空闲块表):物理块号是否空闲0 true1 true2 true任意输入一个需要访问的指令地址流(例如:3635、3642、1140、0087、1700、5200、4355,输入负数结束),打印页表情况。

每访问一个地址时,首先要计算该地址所在的页的页号,然后查页表,判断该页是否在主存——如果该页已在主存,则打印页表情况;如果该页不在主存且页框未满,则调入该页并修改页表,打印页表情况;如果该页不在主存且页框已满,则按 FIFO页面淘汰算法淘汰一页后调入所需的页,修改页表,打印页表情况。

三、主要代码#include <stdio.h>#include <stdlib.h>#include <string.h>#define N 7#define q 3 //物理块个数#define p 6 //页面个数int JCsize=5300; //进程大小int Psize=1024; //页面长度int phb[q]={0}; //物理块标号int pro[N]={0}; //进程序列号int m = -1, n = -1; //物理块空闲和进程是否相同判断标志int i = 0, j = 0,k = 0; //i表示进程序列号,j表示物理块号int Q[q] = {0}; //进程等待次数(存放最久未被使用的进程标志) int max = -1,maxQ = 0; //标记替换物理块进程下标int count=0; //统计页面缺页次数struct Page{int Ynum; //页号int Wnum; //物理块号int P; //状态位int time; //记录调入内存时间};struct Phb{int Pnum; //物理块号int b; //是否空闲};void scan(struct Page *P,struct Phb *R) //输入页表和物理块页框初始化信息{int i;for(i=0;i<p;i++){P[i].Ynum=i;P[i].Wnum=-1;P[i].P=0;}for(i=0;i<q;i++){R[i].Pnum=i; R[i].b=0;}}void print_Page(struct Page *P,struct Phb *R){int n;printf("按1键打印输出物理块页框管理表如下所示:");scanf("%d",&n);printf("\n------------------------------------\n");if(n==1){printf("\t物理块号 \t是否空闲 \t");for(i=0;i<q;i++){printf("\t\t %d \t",R[i].Pnum);printf("\t\t %d \t",R[i].b);}printf("\n");}}void print(struct Page *P,struct Phb *R){int i,j;printf("\n按0键打印输出页表结构如下所示:");scanf("%d",&j);printf("\n---------------------------------------\n");if(j==0){printf("\t页号 \t物理块号 \t状态位 \t");for(i=0;i<p;i++){printf("\t\t %d ",P[i].Ynum);printf("\t %d ",P[i].Wnum);printf("\t %d \t",P[i].P);}printf("\n");}}int* listnumber(struct Page *P,struct Phb *R){int a[N];printf("请输入一个需要访问的指令地址流:\n"); for(i=0;i<N;i++){scanf("%d",&a[i]);if(a[i]>=0 && a[i]<=JCsize){pro[i]=a[i]/Psize; } elseprintf("访问指令不合理!结束访问");}printf("显示所输入地址流地址对应的页号分别为:");for(i=0;i<N;i++)printf("%d ",pro[i]);printf("\n");return (pro);}//查找空闲物理块int rsearchphb(struct Page *P,struct Phb *R){for(j=0; j<q; j++){if(phb[j] == 0){m = j;return m;break;}}return -1;}//查找相同进程int rsearchpage(struct Page *P,struct Phb *R){for(j = 0; j < q; j++) //物理块{if(phb[j]==pro[i]){n = j;return j; //第j块物理块中的进程与此同步}}return -1;}//FIFO算法void FIFO(struct Page *P,struct Phb *R){int t;for(i = 0; i<N; i++) //依次判断进程序列号{m=rsearchphb(P,R);n=rsearchpage(P,R); for(j = 0; j < q;j++){if(Q[j]>maxQ){maxQ = Q[j]; //进程等待次数最大值max = j; //物理块标号 }}if(n == -1) //该页不在主存中即:不存在相同进程 {if(m != -1) //该页不在主存中且页框未满时 {phb[m] = pro[i]; //进程号填入该空闲物理块count++; //页面缺页次数+1Q[m] = 0; //等待次数置为0for(t=0;t<p;t++) //改变页表结构{if(pro[i]==P[t].Ynum){P[t].Wnum=m;P[t].P=1;}}for(j = 0;j <= m; j++){Q[j]++; } //等待次数分别+1 m = -1;print(P,R); //打印页表结构}//该页不在主存且页框已满,执行FIFO淘汰算法else{phb[max] =pro[i];Q[max] = 0;for(t=0;t<p;t++){if(P[t].Wnum==max){P[t].Wnum=-1;P[t].P=0;}}for(t=0;t<p;t++){if(pro[i]==P[t].Ynum){P[t].Wnum=max;P[t].P=1; }}print(P,R);for(j = 0;j < q; j++){ Q[j]++; }max = -1;maxQ = 0;count++; }}else //该页在主存时打印页表情况{phb[n]=pro[i];for(j = 0 ;j <q; j++){ Q[j]++; }n=-1; print(P,R);}}printf("缺页次数为:%d\n",count); printf("\n");}void main(){struct Page P[p]; struct Phb R[q];printf("*****************************************\n");printf(" \n");printf(" |内存页面调度算法| \n");printf(" \n");printf("*****************************************\n");scan(P,R); print(P,R); print_Page(P,R);listnumber(P,R); FIFO(P,R);}。

操作系统-请求页式存储管理实验报告分析解析汇编

操作系统-请求页式存储管理实验报告分析解析汇编

操作系统实验三存储管理实验班级:学号:姓名:目录1. 实验目的 (2)2. 实验内容 (2)(1) 通过随机数产生一个指令序列,共320条指令 (2)(2) 将指令序列变换成为页地址流 (2)(3) 计算并输出下述各种算法在不同内存容量下的命中率 (2)3. 随机数产生办法 (3)环境说明 (3)4. 程序设计说明 (3)4.1.全局变量 (3)4.2.随机指令序列的产生 (4)4.3.FIFO算法 (4)4.4.LRU算法 (4)4.5.OPT算法 (5)5. 编程实现(源程序): (5)6. 运行结果及分析 (11)6.1.运行(以某两次运行结果为例,列表如下:) (11)6.2.Belady’s anomaly (11)1.实验目的存储管理的主要功能之一是合理地分配空间。

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

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

2.实验内容(1) 通过随机数产生一个指令序列,共320条指令指令的地址按下述原则生成:a) 50% 的指令是顺序执行的;b) 25% 的指令是均匀分布在前地址部分;c) 25% 的指令是均匀分布在后地址部分;具体的实施方法是:a) 在[0,319]的指令地址之间随机选取一起点m;b) 顺序执行一条指令,即执行地址为m+1的指令;c) 在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m';d) 顺序执行一条指令,其地址为m'+1;e) 在后地址[m'+2,319]中随机选取一条指令并执行;f) 重复上述步骤a)~f),直到执行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])。

请求页式存储管理

请求页式存储管理

软件学院操作系统实验报告专业:软件工程班级:RB软工互152学号:201560160226学生姓名:王泽华指导教师:韩新超实验四:请求页式存储管理一.实验目的深入理解请求页式存储管理的原理,重点认识其中的地址变换、缺页中断、置换算法等实现思想。

二.实验属性该实验为综合性、设计性实验。

三.实验仪器设备及器材普通PC386以上微机四.实验要求本实验要求4学时完成。

本实验要求完成如下任务:(1)建立相关的数据结构:存储块表、页表等;(2)实现基本分页存储管理,如分配、回收、地址变换;(3)在基本分页的基础上实现请求分页存储管理;(4)给定一批作业/进程,选择一个分配或回收模拟;(5)将整个过程可视化显示出来。

实验前应复习实验中所涉及的理论知识和算法,针对实验要求完成基本代码编写并完成预习报告、实验中认真调试所编代码并进行必要的测试、记录并分析实验结果。

实验后认真书写符合规范格式的实验报告(参见附录A),并要求用正规的实验报告纸和封面装订整齐,按时上交。

五、实验提示1、本实验虽然不以前面实验为基础,但建议在其界面中继续增加请求页式存储管理功能。

2、数据结构:内存分配表、页表空间(用数组实现),修改PCB结构增加页表指针、页表长度。

3、存储管理:编写内存分配、内存回收算法、页面置换算法。

4、主界面设计:在界面上增加一个请求分页内存分配按钮、请求分页内存回收按钮、装入指定进程的指定页按钮。

触发请求分页内存分配按钮,弹出作业大小输入框,输入后调用内存分配函数,在内存分配表和页表中看到分配的存储块。

触发请求分页内存回收按钮,弹出进程ID输入框,输入后调用内存回收函数,在内存分配表中看到回收后的状态改变。

5、功能测试:从显示出的内存分配表和页表,可查看操作的正确与否。

六、实验步骤(1)任务分析:1.最佳页面置换算法(OPT ):其所选择的被淘汰页面,将是以后永不使用的或许是在最长(未来)时间内不再被访问的页面。

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

请求分页存储管理模拟实验

请求分页存储管理模拟实验

操作系统模拟实验实验名称:请求分页存储管理模拟实验实验目的:通过实验了解windows系统中的线程同步如何使用,进一步了解操作系统的同步机制。

实验内容:调用Windows API,模拟解决生产者-消费者问题;思考在两个线程函数中哪些是临界资源?哪些代码是临界区?哪些代码是进入临界区?哪些代码是退出临界区?进入临界区和退出临界区的代码是否成对出现?学习Windows API中的如何创建线程,互斥,临界区等。

程序运行结果:源程序:#include "stdAfx.h"//包含头文件以支持多线程#include "windows.h"#include "stdio.h"//用于标志所有的子线程是否结束//每次子线程结束后,此值便加1。

static long ThreadCompleted = 0;//互斥量HANDLE mutex;//信号量,用于生产者通知消费者HANDLE full;//信号量,用于消费者通知生产者HANDLE empty;//信号量,当所有的子线程结束后,通知主线程,可以结束。

HANDLE evtTerminate;//生产标志#define p_item 1//消费标志#define c_item 0//哨兵#define END 10//缓冲区最大长度const int max_buf_size=11;const int cur_size=10;//缓冲区定义int BUFFER[max_buf_size];//放消息指针int in=0;//取消息指针int out=0;int front=0;int tail=0;int sleep_time=1000;bool flag=true;//线程函数的标准格式unsigned long __stdcall p_Thread(void *theBuf);unsigned long __stdcall c_Thread(void *theBuf);//打印缓冲区内容void PrintBuf(int buf[],int buf_size);int main(int argc, char* argv[]){//初始化缓冲区unsigned long TID1, TID2;for(int i=0;i<cur_size;i++)BUFFER[i]=0;//互斥量和信号量的创建,函数用法可查看MSDNmutex=CreateMutex(NULL,false,"mutex");full=CreateSemaphore(NULL,0,1,"full");empty=CreateSemaphore(NULL,max_buf_size,max_buf_size,"empty");evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");//创建一个生产者线程和消费者线程。

请求调页存储管理方式的模拟

请求调页存储管理方式的模拟

实验3请求调页存储管理方式的模拟1实验目的通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求调页系统的原理和实现过程的理解。

2实验内容(1)假设每个页面中可存放10条指令,分配给一作业的内存块数为4。

(2)模拟一作业的执行过程。

该作业共有320条指令,即它的地址空间为32页,目前它的所有页都还未调入内存。

在模拟过程中,如果所访问的指令已经在内存中,则显示其物理地址,并转下一条指令。

如果所访问的指令还未装入内存,则发生缺页,此时需记录缺页的次数,并将相应页调入内存。

如果4个内存块中均已装入该作业,则需进行页面置换。

最后显示其物理地址,并转下一条指令。

在所有320条指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。

(3)置换算法:请分别考虑OPT、FIFO和LRU算法。

(4)作业中指令的访问次序按下述原则生成:•50%的指令是顺序执行的。

•25%的指令是均匀分布在前地址部分。

•25%的指令时均匀分布在后地址部分。

代码:package mainDart;import java.util.ArrayList;import java.util.List;import java.util.Random;public class FIFO {private static int times=0;//记录置换内存页面的次数/*** 随机产生0~319之间的数* 产生320条指令** @return 包含320条指令的数组*/public static int[] productNumber(){int order[] = new int[320];//数组存储的数字表示指令Random rand = new Random();for(int i=0;i<320;i++){if(i%4==0){order[i]=rand.nextInt(319); //0<=order<319}else if(i%4==1){order[i]=order[i-1]+1;//1<=order<320}else if(i%4==2){order[i]= rand.nextInt(order[i-1]);}else if(i%4==3){order[i]=order[i-1]+rand.nextInt(320-order[i-1]);}}return order;}/*** 打印链表* @param list*/public static void printList(List<Integer> list){for(int temt:list){System.out.print(temt+"\t");}System.out.println();}/*** 先进先出算法* 总是淘汰最先进入内存的页面* 在实现的时候,记录上一次所替换的页面在内存的下标,则本次要替换的位置就是上次下标+1的位置,并且下标是0~3循环的* @param memoryNum* @param page*/public static void FIFOChangePage(List<Integer> memoryNum,int page){int index = FIFOChangePage(memoryNum,page,++times);memoryNum.remove(index);memoryNum.add(index, page);}/*** 返回本次替换的页面在内存中的位置* @param memoryNum* @param page* @param times记录替换页面的次数,第一次替换的是内存第0个单元* @return*/public static int FIFOChangePage(List<Integer> memoryNum,int page,int times) {if(times==1){return 0;}int index = (FIFOChangePage(memoryNum,page,times-1)+1)%4;return index;}public static void main(String[] args) {int[] order = productNumber();System.out.println("320条随机指令数:");for(int i =0;i<order.length;i++){System.out.print(order[i]+"\t");if((i+1)%10==0){System.out.println();}}List<Integer> memoryNum= new ArrayList<Integer>(4);//内存块存储的页面int count=0;//记录缺页次数for(int i=0;i<320;i++){int page = order[i]/10;if(memoryNum.contains(page)) //若该指令所在页面已经在内存,输出该页面所在内存块的号{}else//没在内存,发生缺页,需要判断内存块是否存满,{if(memoryNum.size()<4) //内存没满,直接将所需页面调入内存{memoryNum.add(page);}else//内存存满,需要调用页面置换算法,进行页面置换{FIFOChangePage(memoryNum,page);//先进先出算法}count++;//记录缺页次数}printList(memoryNum);//打印内存所调入页面的情况}System.out.println("缺页率:"+(double)count/320);}}package mainDart;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.Random;public class LRU {/*** 随机产生0~319之间的数* 产生320条指令** @return 包含320条指令的数组*/public static int[] productNumber(){int order[] = new int[320];//数组存储的数字表示指令Random rand = new Random();for(int i=0;i<320;i++){if(i%4==0){order[i]=rand.nextInt(319); //0<=order<319}else if(i%4==1){order[i]=order[i-1]+1;//1<=order<320}else if(i%4==2){order[i]= rand.nextInt(order[i-1]);}else if(i%4==3){order[i]=order[i-1]+rand.nextInt(320-order[i-1]);}}return order;}/*** 打印链表* @param list*/public static void printList(List<Integer> list){for(int temt:list){System.out.print(temt+"\t");}System.out.println();}/*** 最近最久未使用算法* @param order*/public static void LRUChangePage(int [] order){List<Integer> memoryNum = new ArrayList<Integer>(4);//内存块int[] timeFlag =new int[]{-1,-1,-1,-1}; //用来记录内存当中各单元未被访问的时间值int count=0;//记录缺页次数for(int i=0;i<320;i++){int page = order[i]/10;if(memoryNum.contains(page)) //若该指令所在页面已经在内存{int index = memoryNum.indexOf(page);timeFlag[index]=0;//将时间变为0 }else//没在内存,发生缺页,需要判断内存块是否存满,{if(memoryNum.size()<4) //内存没满,直接将所需页面调入内存{//将没有命中的所有页面的时间加一for(int in=0;in<4;in++){if(timeFlag[in]!=-1){timeFlag[in]+=1;}}//将page加入内存并将时间置为0memoryNum.add(page);timeFlag[memoryNum.indexOf(page)]=0;}else//内存存满,需要调用页面置换算法,进行页面置换{int maxIn=-1;//记录拥有最大时间值的标记的下标int maxT=-1;//记录最大的时间值for(int in=0;in<4;in++)//找出内存中时间值最大的进行替换{if(timeFlag[in]>maxT){maxT=timeFlag[in];maxIn=in;}}memoryNum.remove(maxIn);memoryNum.add(maxIn,page);timeFlag[maxIn]=0;//将没有命中的所有页面的时间加一for(int in=0;in<4;in++){if(in!=maxIn){timeFlag[in]+=1;}}}count++;//记录缺页次数}printList(memoryNum);//打印内存所调入页面的情况}System.out.println("缺页率:"+(double)count/320);}public static void main(String[] args) {int[] order = productNumber();System.out.println("320条随机指令数:");for(int i =0;i<order.length;i++){System.out.print(order[i]+"\t");if((i+1)%10==0){System.out.println();}}LRUChangePage(order);}}package mainDart;import java.util.ArrayList;import java.util.List;import java.util.Random;public class Optimal {/*** 随机产生0~319之间的数* 产生320条指令** @return 包含320条指令的数组*/public static int[] productNumber(){int order[] = new int[320];//数组存储的数字表示指令Random rand = new Random();for(int i=0;i<320;i++){if(i%4==0){order[i]=rand.nextInt(319); //0<=order<319}else if(i%4==1){order[i]=order[i-1]+1;//1<=order<320}else if(i%4==2){order[i]= rand.nextInt(order[i-1]);}else if(i%4==3){order[i]=order[i-1]+rand.nextInt(320-order[i-1]);}}return order;}/**** @param order320条指令数组* @return 返回一个链表,依次保存着320条指令每条指令所在的页面*/public static List<Integer> pageSeq(int[] order){List<Integer> pageSeq = new ArrayList<Integer>();for(int temp:order){pageSeq.add(temp/10);}return pageSeq;}/*** 打印链表* @param list*/public static void printList(List<Integer> list){for(int temt:list){System.out.print(temt+"\t");}System.out.println();}/*** 最佳置换算法* 根据当前已经在内存中的页面在之后被需要的先后进行置换** @param pageSeq 整个320条指令,从头到尾所需要的页面* @param memoryNum 已满的内存空间* @param page等待被调入内存的页面*/public static void OptimalChangePage(List<Integer> pageSeq,int start,List<Integer> memoryNum,int page){int maxSeq=-1,index=0;for(int pageNum:memoryNum) //遍历内存{for(int i=start;i<pageSeq.size();i++){if(pageNum==pageSeq.get(i)){if(i>maxSeq){maxSeq=i;}break;}}}if(maxSeq>-1)//maxSeq==-1说明内存当中的四个页面在将来都不会再被使用,这时默认将内存块中的第一个页面置换出{index = memoryNum.indexOf(pageSeq.get(maxSeq));//记录将要被置换的那个页面所在内存位置}memoryNum.remove(index);//将内存中将来最久被使用的页面删除memoryNum.add(index, page);//将需要调入的页面加入内存}public static void main(String[] args) {int[] order = productNumber();System.out.println("320条随机指令数:");for(int i =0;i<order.length;i++){System.out.print(order[i]+"\t");if((i+1)%10==0){System.out.println();}}List<Integer> pageSeq = pageSeq(order); //依次存放着指令所在的页面号List<Integer> memoryNum= new ArrayList<Integer>(4);//内存块存储的页面int count=0;//记录缺页次数for(int i=0;i<320;i++){int page = order[i]/10;if(memoryNum.contains(page)) //若该指令所在页面已经在内存,输出该页面所在内存块的号{}else//没在内存,发生缺页,需要判断内存块是否存满,{if(memoryNum.size()<4) //内存没满,直接将所需页面调入内存{memoryNum.add(page);}else//内存存满,需要调用页面置换算法,进行页面置换{OptimalChangePage(pageSeq,i+1,memoryNum,page);//最佳置换算法}count++;//记录缺页次数}printList(memoryNum);//打印内存所调入页面的情况}System.out.println("缺页率:"+(double)count/320);}}package mainDart;import java.util.ArrayList;import java.util.List;public class TestAPP {public static void main(String[] args) {List<Integer> list = new ArrayList<Integer>();list.add(1);list.add(3);list.add(45);System.out.println(list);list.remove(1);list.add(1, -1);System.out.println(list);}}。

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

《网络操作系统》课程设计报告书题目:请求调页存储管理方式的模拟学号:学生姓名:指导教师:年月日目录一. 实验内容................................................... 错误!未定义书签。

二. 实验目的................................................... 错误!未定义书签。

三. 设计思想................................................... 错误!未定义书签。

四. 程序流程图................................................. 错误!未定义书签。

五. 程序清单................................................... 错误!未定义书签。

六. 运行结果及分析............................................. 错误!未定义书签。

七. 总结....................................................... 错误!未定义书签。

一、实验内容1.假设每个页面中可存放10条指令,分配给作业的内存块数为4。

2.用C语言或C++语言模拟一个作业的执行过程,该作业共有320条指令,即它的地址空间为32页,目前它的所有页都还未调入内存。

在模拟过程中,如果所访问的指令已在内存,则显示其物理地址,并转下一条指令。

如果所访问的指令还未装入内存,则发生缺页,此时需记录缺页的次数,并将相应页调入内存。

如果4个内存块均已装入该作业,则需进行页面置换,最后显示其物理地址,并转下一条指令。

在所有320指令执行完毕后,请计算并显示作业运行过程中发生的缺页率。

3.置换算法:请分别考虑最佳置换算法(OPT)、先进先出(FIFO)算法和最近最久未使用(LRU)算法。

4.作业中指令的访问次序按下述原则生成;50%的指令是顺序执行的;25%的指令是均匀分布在前地址部分;25%的指令均匀分布在后地址部分。

具体的实现办法是:(1)在[0,319]之间随机选取一条起始执行指令,其序号为m;(2)顺序执行下一条指令,其序号为m+1条指令;(3)通过随机数,跳转到前地址部分[0,m-1]中的某条指令处,其序号为m1;(4)顺序执行下一条指令,即序号为m1+1的指令;(5)通过随机数,跳转到后地址部分[m1+2,319]中的某条指令处,其序号为m2;(6)顺序执行下一条指令,则序号为m2+1的指令;(7)重复跳转到前地址部分,顺序执行,跳转到后地址部分;顺序执行的过程,直至执行320条指令。

二、实验目的1.通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟储技术的特点。

2.通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求调页系统的原理和实现过程的理解。

3.掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程,并比较它们的效率。

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

但应将哪个页面调出,所以需要根据一定的算法来确定。

在这一过程中,选择换出页面的算法称为页面置换算法。

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

页面置换算法的好坏,将直接影响到系统的性能。

以下分别是实验要求的两个页面置换算法的介绍及设计思想。

(1)先进先出法(First In First Out):该算法总是淘汰最先进入内存的页面,既选择在内存中驻留时间最久的页面予以淘汰。

在该算法的模拟过程中,每当页面被置换进入内存时,将置换页面所在的物理块中访问标记设为-1;并且每执行一次指令,便将物理块的访问标记自动加1,需要置换时将访问标记最大的物理块中的页面置换出去,这样能防止当物理块访问标记出现两个以上相同的值的错误执行,更好地模拟了先进先出法;(2)最近最久未使用(Least Recently Used):该算法以最近的过去作为不久将来的近似,将过去最长一段时间里不曾被使用的页面置换掉。

在该算法的模拟过程中,每当物理块中的页面被访问时(包括原先存在的和后来置换进入的页面),便将其物理块访问标记置为-1。

以后每执行一条指令,便将物理块中各页面的访问标记加1,需置换时访问标记最大的便是将要被置换的。

(3)最佳置换算法(OPT):发生缺页时,有些页面在内存中,其中有一页见很快被访问(也包含紧接着的下一条指令的那页),而其他页面则可能要到10、100或者1000条指令后才会被访问,每个页面都可以用在该页面首次被访问前所要执行的指令数进行标记。

最佳页面置换算法只是简单地规定:标记最大的页应该被置换。

如果某页在八百万条指令内不会被使用,另一页在600万条指令内不会被使用,则置换前一个页面,从而把因需要调回这一页发生的缺页推到将来,越远越好。

这个算法唯一的一个问题就是它无法实现。

当缺页发生时,操作系统无法知道各个页面下一次是在什么时候被访问。

虽然这个算法不可能实现,但是最佳页面置换算法可以用于对可实现算法的性能进行衡量比较。

四、程序流程图及数据结构数据结构:typedef struct BLOCK//声明一种新类型——物理块类型{int pagenum;//页号int accessed;//访问字段,其值表示多久未被访问}BLOCK;int count;//程序计数器,用来记录指令的序号int n;//缺页计数器,用来记录缺页的次数static int temp[320];//用来存储320条随机数BLOCK block[size]; //定义一大小为4的物理块数组void init( ); //程序初始化函数int findExist(int curpage);//查找物理块中是否有该页面int findSpace( );//查找是否有空闲物理块int findReplace( );//查找应予置换的页面void display ( );//显示void Random( );//产生320条随机数,显示并存储到temp[320] void pagestring( );//显示调用的页面队列void OPT( );//OPT算法void LRU( );// LRU算法void FIFO( );//FIFO算法五、程序清单#include <iostream.h>#include<stdlib.h>#include<conio.h>#include<stdio.h>#define size 4typedef struct BLOCK//声明一种新类型——物理块类型{int pagenum;//页号int accessed;//访问字段,其值表示多久未被访问}BLOCK;int count;//程序计数器,用来记录指令的序号int n;//缺页计数器,用来记录缺页的次数static int temp[320];//用来存储320条随机数BLOCK block[size]; //定义一大小为4的物理块数组void init( ); //程序初始化函数int findExist(int curpage);//查找物理块中是否有该页面int findSpace( );//查找是否有空闲物理块int findReplace( );//查找应予置换的页面void display ( );//显示void Random( );//产生320条随机数,显示并存储到temp[320]void pagestring( );//显示调用的页面队列void OPT( );//OPT算法void LRU( );// LRU算法void FIFO( );//FIFO算法void init( ){for(int i=0;i<size;i++){block[i].pagenum=-1;block[i].accessed=0;count=n=0;}}int findExist(int curpage) //查找物理块中是否有该页面{for(int i=0; i<size; i++){if(block[i].pagenum == curpage )return i; //检测到内存中有该页面,返回block中的位置}return -1;}int findSpace( ) //查找是否有空闲物理块{for(int i=0; i<size; i++){if(block[i].pagenum == -1)return i; //找到空闲的block,返回block中的位置}return -1;}int findReplace( ) //查找应予置换的页面{int pos = 0;for(int i=0; i<size; i++){if(block[i].accessed >block[pos].accessed)pos = i;//找到应予置换页面,返回BLOCK中位置}return pos;}void display( ){for(int i=0; i<size; i++){if(block[i].pagenum != -1) //物理块不空{printf(" %02d",block[i].pagenum);}}cout<<endl;}void Random( ){ int flag=0;cin>>count;cout<<"******按照要求产生的320个随机数:*******"<<endl;for(int i=0;i<320;i++){temp[i]=count;if(flag%2==0)count=++count%320;//产生50%的顺序执行指令(flag=0或2时顺序执行)if(flag==1) count=rand( )% (count-1); //产生25%的均匀分布在前地址部分指令if(flag==3) count=count+1+(rand( )%(320-(count+1))); //产生25%的均匀分布在后地址部分指令flag=++flag%4;printf(" %03d",temp[i]);if((i+1)%10==0) cout<<endl;}}void pagestring( ) //显示调用的页面队列{for(int i=0;i<320;i++){printf(" %02d",temp[i]/10);if((i+1)%10==0) cout<<endl;}}//------------最佳置换算法void OPT( ){int exist,space,position ;int curpage;for(int i=0;i<320;i++){if(i%100==0) getch( );count=temp[i];curpage=count/10;exist = findExist(curpage);if(exist==-1){space = findSpace ( );if(space != -1){block[space].pagenum = curpage;display( );n=n+1;}else{for(int k=0;k<size;k++){for(int j=i;j<320;j++){if(block[k].pagenum!= temp[j]/10){block[k].accessed = 1000;}//将来不会用,设置为一个很大数else{block[k].accessed = j;break;}}}position = findReplace( );block[position].pagenum = curpage;display( );n++;}}}cout<<"缺页次数:"<<n<<endl;cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;}//------------------ 最近最少使用算法void LRU( ){int exist,space,position ;int curpage;for(int i=0;i<320;i++){if(i%100==0) getch( ); //getch直接从键盘获取键值count=temp[i]; //指令在数组中的位置curpage=count/10; //指令所在页面exist = findExist(curpage); //查找物理块中是否有该页面,若有返回物理块号if(exist==-1) //物理块中不存在该页{space = findSpace( ); //查找是否有空闲物理块if(space != -1) //有空闲物理块{block[space].pagenum = curpage;display( );n=n+1;}else //无空闲物理块,则寻找置换页面{position = findReplace( ); //查找应予置换的页面block[position].pagenum = curpage;block[position].accessed = -1; //恢复刚调入的BLOCK中页面accessed为-1display( );n++;}}else block[exist].accessed = -1;//恢复存在的并刚访问过的BLOCK中页面accessed为-1for(int j=0; j<4; j++){block[j].accessed++;}}cout<<"缺页次数:"<<n<<endl;cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;}//--------------- 先进先出算法void FIFO( ){int exist,space,position ;int curpage;for(int i=0;i<320;i++){if(i%100==0) getch( ); //getch直接从键盘获取键值count=temp[i];curpage=count/10;exist = findExist(curpage); //查找物理块中是否有该页面if(exist==-1){space = findSpace( ); //查找是否有空闲物理块if(space != -1) //有空闲物理块{block[space].pagenum = curpage;display( );n=n+1;}else //无空闲物理块,则寻找置换页面{position = findReplace( ); //查找应予置换的页面block[position].pagenum = curpage;display( );n++;block[position].accessed--; //置换页面所在的物理块中访问标记设为-1}}else//若存在该页{for(int i=0; i<size; i++){ if(block[i].pagenum != -1) //物理块不空printf(" %02d ",block[i].pagenum);}cout<<"指令已经存在! 其物理块地址为:"<<&block[exist]<<endl;}for(int j=0; j<size; j++)block[j].accessed++;}cout<<"缺页次数:"<<n<<endl;cout<<"缺页率:"<<(n/320.0)*100<<"%"<<endl;}void main( ){int select;cout<<"请输入第一条指令号(1~320): ";Random( );cout<<"*****对应的调用页面队列*******"<<endl;pagestring( );do{cout<<"****************************************"<<endl; cout<<"* 1:OPT 2:LRU 3:FIFO 4:退出 *"<<endl; cout<<"****************************************"<<endl; cout<<" 请选择一种页面置换算法:";cin>>select;cout<<"****************************************"<<endl; init( );switch(select){case 1:cout<<"最佳置换算法OPT:"<<endl;cout<<"*****************"<<endl;OPT( );break;case 2:cout<<"最近最久未使用置换算法LRU:"<<endl;cout<<"**************************"<<endl;LRU( );break;case 3:cout<<"先进先出置换算法FIFO:"<<endl;cout<<"*********************"<<endl;FIFO( );break;default: ;}}while(select!=4);}六、使用说明及运行结果分析运行程序依次测试相应的算法:1、先输入一个指令号(1-319)随意输入;2、然后选择测试算法;本程序能通过输入第一条指令号(用3位整数代表指令号),产生320个随机数,并以每行10个显示出来。

相关文档
最新文档