实验报告关于请求调页存储管理方式
实验二--请求分页存储管理模拟实验

实验二请求分页存储管理模拟实验一、实验目的:通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。
熟悉虚存管理的各种页面淘汰算法。
通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。
二、实验要求:设计一个请求页式存储管理方案。
并编写模拟程序实现。
(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-请求分页存储管理模拟实验

实验四请求分页存储管理模拟实验一:实验目得通过对页面、页表、地址转换与页面置换过程得模拟,加深对请求分页存储管理系统得原理与实现技术得理解.二:实验内容假设每个页面可以存放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

昆明理工大学信息工程与自动化学院学生实验报告(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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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个显示出来。