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

合集下载

请求分页存储管理(虚拟存储)

请求分页存储管理(虚拟存储)

任务四、请求分页存储管理(虚拟存储)一、实验目的通过请求分页存储管理的设计,让学生了解虚拟存储器的概念和实现方法。

进行运行时不需要将所有的页面都调入内存,只需将部分调入内存,即可运行,在运行的过程中若要访问的页面不在内存时,则需求有请求调入的功能将其调入。

假如此时若内存没有空白物理块,则通过页面置换的功能将一个老的不用的页面淘汰出来,其中淘汰的算法有多种。

二、实验内容模拟仿真请求分页调度算法,其中淘汰的算法可选下列其一1、先进先出算法2、最近最久算法3、CLOCK算法三、实验代码#include<iostream>#include<vector>using namespace std;int n;typedef struct Queue{int time;int data;struct Queue *next;}Queue,*QueuePtr;typedef struct {QueuePtr front;QueuePtr rear;}LinkQueue;//fifo=======================================void InitQueue(LinkQueue &Q);void FiFoEnQueueRear(LinkQueue &Q,int e,vector<int> &v);void FiFoDeQueueFront(LinkQueue &Q);inline void PrintQueue(LinkQueue &Q);void FiFoFiFoDoQueueEarly(LinkQueue &Q,int a,vector<int> &v);void FiFoDoQueue(LinkQueue &Q,int a,vector<int> &v);inline int PanDuan(LinkQueue &Q,int a);inline int YeMianCount(LinkQueue &Q);void fifo();//lru=============================================void InitQueue(LinkQueue &Q);void EnQueueMid(LinkQueue &Q,int e,QueuePtr p,vector<int> &v);void EnQueueTheFist(LinkQueue &Q,int e);void PrintQueue(LinkQueue &Q);//void ZhiZhenInit(int n);void DoQueueEarly(LinkQueue &Q,int e,vector<int> &v);void EnQueueRear(LinkQueue &Q,int e,QueuePtr p,vector<int> &v);//void DeQueueFront(LinkQueue &Q);QueuePtr ZhiZhen(LinkQueue &Q,int e);void EnQueue(LinkQueue &Q,int e,vector<int> &v);//void DeQueue(LinkQueue &Q,QueuePtr p);int PanDuan(LinkQueue &Q,int a);int YeMianCount(LinkQueue &Q);void lru();QueuePtr OptimalZhiZhen(LinkQueue &Q,int e);//求出需要置换的页面的上一个页面的位置void EnQueue(LinkQueue &Q,int e,vector<int> &v,int i,vector<int> &vc);inline int YeMianCount(LinkQueue &Q);//使用内敛函数,提高性能inline int Destance(vector<int> &v,int i);inline void SubbDestance(LinkQueue &Q);//=================================================int main(){int k;for(;;){cout<<"请选择!"<<endl;cout<<"1——FiFo算法"<<endl;cout<<"2——LRU算法"<<endl;cout<<"0——退出"<<endl;cin>>k;if(k==0)break;else{switch(k){case 1:fifo();break;case 2:lru();break;default:cout<<" 请从以上的选择中选择一个选项!!"<<endl;}}}}//fifo========================================void InitQueue(LinkQueue &Q){Q.front=Q.rear=(QueuePtr)malloc(sizeof(Queue));if(!Q.front)cout<<"initqueue worng!"<<endl;Q.front->next=NULL;//return OK;}void FiFoEnQueueRear(LinkQueue &Q,int e,vector<int> &v){ QueuePtr p;p=(QueuePtr)malloc(sizeof(Queue));if(!p)cout<<"cannot malloc EnQueue of the p"<<endl;p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;v.push_back(e);//cout<<p->data;//return OK;}void FiFoDeQueueFront(LinkQueue &Q){QueuePtr p;if(Q.front==Q.rear)cout<<"the Queue is empty,cannot delete !!"<<endl;p=Q.front->next;Q.front->next=p->next;free(p);if(Q.rear==p)Q.rear=Q.front;//return OK}void PrintQueue(LinkQueue &Q){QueuePtr p;if(Q.front==Q.rear)cout<<"the Queue is empty,cannot print!"<<endl;p=Q.front;for(p=Q.front;p->next!=NULL;p=p->next){cout<<p->next->data<<" ";}cout<<endl;//retrun OK;}void FiFoFiFoDoQueueEarly(LinkQueue &Q,int a,vector<int> &v){ QueuePtr p;int count=0;//设置标志位,记录重复的个数。

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

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

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

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

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

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

并编写模拟程序实现。

(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;}。

操作系统实习二报告

操作系统实习二报告

实验二主存储器空间的分配和回收一、实验题目:模拟在分页式管理方式下采用位示图来表示主存分配情况,实现主存空间的分配和回收。

二、实验目的:主存的分配和回收的实现与主存储器的管理方式有关,通过本实习理解在不同的存储管理方式下应怎样实现主存空间的分配和回收。

三、实验内容:一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器,而且要能合理地分配和使用这些存储空间。

当用户提出申请存储器空间时,存储管理必须根据申请者的要求,按一定的策略分析主存空间的使用情况,找出足够的空闲区域分配给申请者。

当作业撤离或主动归还主存资源时,则存储管理要收回作业占用的主存空间或归还部分主存空间。

四、程序中使用的数据结构及符号说明:五、程序流程图:六、程序源代码:#include <stdlib.h>#include <stdio.h>typedef int datatype;typedef struct node{datatype pageNum,blockNum;struct node *next;}linknode;typedef linknode *linklist;linklist creatlinklist(int n)/*尾插法创建带头结点的单链表*/{linklist head,r,s;int x,y,i=0;head=r=(linklist)malloc(sizeof(linknode));printf("\n请分别输入页表的页号及块号(-1表示空):\n");printf("\n页号| 块号\n");while (i<n){scanf("%d %d",&x,&y);s=(linklist)malloc(sizeof(linknode));s->pageNum=x;s->blockNum=y;r->next=s;r=s;i++;}r->next=NULL;return head;}void init(int g[100][100],int N)/*初始化位示图,将值全置为零,0表示空闲状态*/{int i,j;for(i=0;i<100;i++){for(j=0;j<100;j++){g[i][j]=0; //全置为零}}g[N+1][0]=N*N; //在数组最后一个数的后面设置一个空间用来存放剩余空闲块数}linklist Init(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){i=p->blockNum/N;j=p->blockNum%N;g[i][j]=1;g[N+1][0]--;p=p->next;}}return head;}printStr(int g[100][100],int N)/*打印位示图*/{int i,j;printf("\n此时位示图为:\n");printf("\n ");for(i=0;i<N;i++){printf(" ");printf("%d",i);}printf("\n");for(i=0;i<N;i++){printf("%d",i);for(j=0;j<N;j++){printf(" ");printf("%d",g[i][j]);}printf("\n");}printf("\n");}void print(linklist head)/*输出带头结点的单链表*/{linklist p;p=head->next;printf("\n该页表为:\n");printf("\n");printf("\n 页号| 块号\n");while(p){printf("%11d%7d\n",p->pageNum,p->blockNum);p=p->next;}printf("\n");}linklist Dis(linklist head,int g[100][100],int n,int N){linklist p;int i,j;p=head->next;if(n<=g[N+1][0]) //首先判断作业的页数是否小于等于位示图剩余空闲块的个数{while(p){for(i=0;i<N;i++){for(j=0;j<N;j++){if(g[i][j]==0){p->blockNum=N*i+j; //将对应块号记录到页表g[i][j]=1; //将块置1,表示已被占用g[N+1][0]--; //剩余空闲块减1break; //跳出循环,进行下一个页的分配}}break; //跳出循环}p=p->next; //下一个页进行分配}return head;}}linklist Recy(linklist head,int g[100][100],int n,int N)/*回收已经完成的页*/ {int i,j;linklist p;p=head->next;while(p&&p->pageNum!=n) //找出要回收的页号{p=p->next;}if(p) //找到{i=p->blockNum/N;j=p->blockNum%N;g[i][j]=0; //将该块置0,表空闲状态g[N+1][0]++;p->blockNum=-1; //页表中对应的块号为空,置成-1}return head;}void main(){int m,n,N;int x,y,a,b,t;int graph[100][100];linklist head,Head;printf("\n*****分页式存储管理分配及回收算法*****\n");printf("\n请输入位示图字长:");scanf("%d",&N);printf("\n请输入已占用内存作业的页数:");scanf("%d",&m);head=creatlinklist(m);init(graph,N);head=Init(head,graph,m,N);printStr(graph,N);printf("\n当前空闲块数为:%d",graph[N+1][0]);printf("\n\n现在进行作业分配:\n");printf("\n请输入需要分配的作业的页数:");scanf("%d",&n);Head=creatlinklist(n);Head=Dis(Head,graph,n,N);print(Head);printStr(graph,N);printf("\n当前空闲块数为:%d",graph[N+1][0]);printf("\n\n您是否想回收已完成的页,“是”请按1,“否”请按0:");scanf("%d",&x);if(x) //判断是否要回收{printf("\n请输入您要回收的页号:");scanf("%d %d %d %d",&y,&a,&b,&t);head=Recy(head,graph,y,N);head=Recy(head,graph,a,N);head=Recy(head,graph,b,N);head=Recy(head,graph,t,N);printStr(graph,N);}printf("\n当前空闲块数为:%d",graph[N+1][0]);printf("\n");}七、运行结果:实习小结:本次实验是自己花了很多的时间去琢磨去尝试才完成的,虽然还不是很完美,但是在设计的过程中自己在对编程方面的逻辑思维得到了很好的锻炼。

分页氏存储管理实验报告

分页氏存储管理实验报告

分页存储管理实验报告姓名:何绍金班级:自动化1202学号:201203870408指导教师:张健2014年12月30日一.实验题目编写程序模拟操作系统的基本分页存储管理方式,进一步理解这种内存分配方式的原理和特点,加深对理论知识的掌握。

二. 实验内容1.实验要求(1)编写模拟操作系统对内存分页存储管理方式的程序。

(2)程序能正确对主存空间进行“分配”和“回收”。

(3)能接受用户的输入,显示内存的分配情况,并有一定的容错能力。

2.实现功能:(1)内存初始化(2)程序应该能接受用户输入的进程信息,并为之分配内存,返回分配结果注意:此处考虑到不合法的输入并进行相应处理。

(3)程序能回收用户指定的进程所占用的内存空间程序需要为每个进程分配一个唯一的进程号并给出详细的提示信息。

(4)能直观合理地显示内存分配情况三.实验流程图四.程序运行结果运行程序得到如下结果:五.实验小结这次实验让我清楚地认识到分页存储管理的基本原理和实现流程,特别是对主存空间的分配与回收的深层次理解,在编制程序是只需使用顺序的地址而不必去考虑如何去分页,因为分页存储管理时作业的地址是连续的。

更让我体会了页氏存储管理方式的优点就是没有外部碎片,程序不必连续存放在内存空间,而缺点是程序要全部装入内存。

此外,还增强了动手编程和分析解决问题的能力。

附:程序源代码按流程图编制的源代码如下所示:#include <stdio.h>#include <windows.h>#define N 100 // 共有100个内存块int process[N][N+1]; // 存放每个进程的页表int block[N]; // 内存块状态标志数组,0:空闲,1:使用int blockCount; // 记录当前内存剩余空间int processCount; // 记录当前进程数bool flag = true;void init();void output();bool createProcess();bool endProcess();void init(){int i, j;// 初始化内存状态标志数组for (i=0; i<N; i++)block[i] = 0;for (i=0; i<20; i++)block[rand()%(N-1)] = 1;blockCount = 0;for (i=0; i<N; i++)if (block[i] == 0)blockCount++;// 初始化存放进程的数组for (i=0; i<N; i++){process[i][0] = 0;for (j=1; j<N; j++)process[i][j] = -1;}processCount = 0;printf("初始化结果如下:");output();flag = false;}void output(){printf("\n内存总量:%d 块, 已用空间:%d 块, 剩余空间:%d 块, 进程总数:%d 个\n", N, N-blockCount, blockCount, processCount);if (flag && blockCount < N){printf("已使用的内存块(%d):\n", N-blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 1)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}// 输出各进程占用内存详细情况if (processCount > 0){printf("内存详细使用情况如下:\n");for (int i=0; i<N; i++){if (process[i][0] > 0){printf("进程号:%d \n占用内存块(%2d):", i, process[i][0]);for (int j=1,count=0; j<=process[i][0]; j++){printf("%2d ", process[i][j], count++);if (count == 15){putchar('\n');printf(" ");count = 0;}}putchar('\n');}}}elseprintf("当前内存无进程!\n");/*// 输出空闲内存块if (blockCount > 0){printf("空闲内存块(%d):\n", blockCount);for (int k=0,count=0; k<N; k++){if (block[k] == 0)printf("%2d ", k, ++count);if (count == 15){putchar('\n');count = 0;}}putchar('\n');}*/putchar('\n');}bool createProcess(){int pid, pages, k = 0;loop:printf("请输入进程号(小于%d)和所需页面数:", N);scanf("%d%d", &pid, &pages);if (pid > 99){printf("错误!进程号过大!\n");goto loop;}if (pages > blockCount)return false;blockCount -= pages;process[pid][0] = pages;for (int i=1; i<=pages; i++){while (block[k]==1 && k<100)k++;process[pid][i] = k;block[k] = 1;k++;}processCount++;return true;}bool endProcess(){int pid, pages;if (processCount < 1){printf("当前内存没有进程!\n\n");return false;}printf("当前内存中的进程有 %d 个,进程号为:", processCount);for (int i=0; i<N; i++)if (process[i][0] > 0)printf("%2d ", i);putchar('\n');printf("请输入您要结束的进程号(小于%d):", N);scanf("%d", &pid);pages = process[pid][0];if (pages == 0){printf("对不起!该进程不存在!\n");return false;}for (int j=1; j<pages; j++){block[process[pid][j]] = 0;process[pid][j] = -1;}process[pid][0] = 0;processCount--;blockCount += pages;return true;}void menu(){int choice;while (true){printf("操作菜单:\n");printf(" 1 --> 创建进程\n 2 --> 结束进程\n 3 --> 查看内存\n 0 --> 退出程序\n");printf("请输入您要进行的操作:");scanf("%d", &choice);switch (choice){case 1:if (createProcess())printf("创建新进程成功!\n\n");elseprintf("抱歉!内存空间不足,创建新进程失败!\n\n");break;case 2:if (endProcess())printf("进程已结束!\n\n");elseprintf("进程结束失败!\n\n");break;case 3:output();break;case 0:return ;default:printf("对不起!您的选择有误!请重新选择!\n\n");}}}void main(){init();menu();}。

操作系统实验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;ﻩ}}}。

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

基本分页存储管理的模拟实现

基本分页存储管理的模拟实现

基本分页存储管理的模拟实现学院:专业:学生姓名:学号:指导教师:2014年3月 18 日目录一、设计内容 (2)二、相关操作系统的知识介绍 (2)三、课程设计的目的及要求 (2)四、程序功能说明 (3)五、算法整体思想 (3)六、主要功能模块进程图 (3)七、实验结果 (4)八、实验总结 (7)九、程序代码 (7)一、设计内容根据设计要求实现对基本分页存储管理的模拟二、相关操作系统的知识介绍连续分配方式会形成许多“碎片”,虽然可通过“紧凑”方法将许多碎片拼接成可用的大块空间,但须为之付出很大的开销。

如果允许将一个进程直接分散的装入到许多不相邻接的分区中,则无需在进行“紧凑”。

基于这一思想而产生了离散分配方式。

如果离散分配的基本单位是页,则称为分页存储管理方式;如果离散分配的基本单位是段,则称为分段存储管理方式。

在分页存储管理方式中,如果不具备页面对换功能,则称为基本的分页存储管理方式,或称为纯分页存储管理方式,它不具有支持实现虚拟存储的功能,它要求把每个作业全部装入内存后方能运行。

三、课程设计的目的及要求1、课程设计的目的操作系统课程设计是计算机专业重要的教学环节,它为我们提供了一个既动手又动脑,将课本上的理论知识和实际有机的结合起来,独立分析和解决实际问题的机会。

●进一步巩固和复习操作系统的基础知识。

●培养我们结构化程序、模块化程序设计的方法和能力。

●提高我们调试程序的技巧和软件设计的能力。

●提高我们分析问题、解决问题以及综合利用 C 语言进行程序设计的能力。

2、设计要求1.选择恰当的数据结构表示页表2.进程名,进程所需页数,进程进行的操作(装入/退出)等操作可有键盘输入,也可从文件读出。

3.每进行一次进程的装入或者退出操作,就显示出操作执行后内存中各页的分配情况。

四、程序功能说明函数各模块部分功能void CreatA()//创建内存新函数void NewNode(LinkList &L)//建立新进程void FreeNode(LinkList &L)//回收进程,释放内存void Printf(LinkList L)//显示所有进程所占物理块信息void look(LinkList L)//查看进程信息void showit()//显示内存块使用信息函数的整体功能这个程序是为了实现离散分配方式,以消减内存的外零头,提高内存的利用率,由系统把逻辑地址划分为页号和页内地址两部分。

模拟分页式虚拟存储管理中硬件的地址转换和缺页中断--选择页面调度算法处理缺页中断

模拟分页式虚拟存储管理中硬件的地址转换和缺页中断--选择页面调度算法处理缺页中断

操作系统实验二〔第一题〕一.实验内容模拟分页式虚拟存储管理中硬件的地址转换和缺页中断,以及选择页面调度算法处理缺页中断。

二.实验目的在电脑系统总,为了提高主存利用率,往往把辅助存储器作为主存储器的扩充,使多道运行的作业的全部逻辑地址空间综合可以超出主存的绝对地址空间。

用这种方法扩充的主存储区成为虚拟存储器。

三.实验题目模拟分页式存储管理中硬件的地址转换和产生缺页中断。

四.程序清单//// 操作实验二.cpp : 定义控制台应用程序的入口点。

//#include "stdafx.h"#include<iostream>#include<string>#include<fstream>using namespace std;class ins{private:string ope;long int page;long int unit;public:ins(){ }ins(string o,long int p,long int u):ope(o),page(p),unit(u){}void setope(string o){ ope=o;}void setpage(long int p){ page=p;}void setunit(long int u){ unit=u;}string getope(){return ope;}long int getpage(){return page;}long int getunit(){return unit;}};class work{private:long int Page;int sym;long int inum;long int onum;public:work(){}work(long int P, int s,long int i,long int o):Page(P),sym(s),inum(i),onum(o){} void setPage(long int P){ Page=P;}void setsym( int s){ sym=s;}void setinum(long int i){ inum=i;}void setonum(long int o){ onum=o;}long int getPage(){return Page;}int getsym(){return sym;}long int getinum(){return inum;}long int getonum(){return onum;}};void diaodu(work *w,ins * i,int numofins){ for(int j=0;j<numofins;j++){long int tempofk;long int a =i[j].getpage();for(int k=0;k<7;k++) //7是页表的页数if(w[k].getPage()!=a)continue;else{tempofk=k;break;}if(w[tempofk].getsym()==1)cout<<"绝对地址:"<<w[tempofk].getinum()*128+i[j].getunit()<<" "<<"磁盘地址为:"<<w[tempofk].getonum()<<" "<<"操作为:"<<i[j].getope()<<endl;else cout<<"*"<<"发生缺页中断"<<endl;}}int main(){ins*INS=new ins[12];INS[0].setope ("+");INS[0].setpage(0);INS[0].setunit(70);INS[1].setope ("+");INS[1].setpage(1);INS[1].setunit(50);INS[2].setope ("×");INS[2].setpage(2);INS[2].setunit(15);INS[3].setope ("存"); INS[3].setpage(3);INS[3].setunit(21);INS[4].setope ("取"); INS[4].setpage(0);INS[4].setunit(56);INS[5].setope ("-");INS[5].setpage(6);INS[5].setunit(40);INS[6].setope ("移位"); INS[6].setpage(4);INS[6].setunit(53);INS[7].setope ("+");INS[7].setpage(5);INS[7].setunit(23);INS[8].setope ("存"); INS[8].setpage(1);INS[8].setunit(37);INS[9].setope ("取"); INS[9].setpage(2);INS[9].setunit(78);INS[10].setope ("+"); INS[10].setpage(4);INS[10].setunit(1);INS[11].setope ("存"); INS[11].setpage(6);INS[11].setunit(84);work*W =new work[7]; ifstream in("g://operate1.txt");long int p;int s;long int i;long int o;for(int jj=0;jj<7 ;jj++){in>>p;in>>s;in>>i;in>>o ;W[jj].setPage(p);W[jj].setsym(s);W[jj].setinum(i);W[jj].setonum(o);}diaodu(W,INS,12);}五.结果显示操作系统实验二〔第二题〕一.用先进先出〔FIFO〕九.程序清单/ 操作系统实验二.cpp : 定义控制台应用程序的入口点。

请求页式存储管理中常用页面置换算法模拟

请求页式存储管理中常用页面置换算法模拟

记录一个页面自上次被访问以来所经历的时间,当需淘汰一个页面的时 候选择现有页面中其时间值最大的进行淘汰。 最佳置换算法的替换规则:其所选择的被淘汰页面,将是以后永不 使用的或许是在最长(未来)时间内不再被访问的页面。 先进先出(FIFO)页面置换算法的替换规则:该算法总是淘汰最先进 入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法 实现简单只需把一个进程已调入内存的页面,按先后次序链接成一个队 列,并设置一个指针,称为替换指针,使它总是指向最老的页面。 三种替换算法的命中率由高到底排列OPT>LRU>FIFO。 本次的程序是在网上查找的相关代码然后自己进行修改,先自己仔 细地研读了这段代码,在这过程中我对C++代码编写有了更深的了解。 总之,本次实验使我明白要学会把课堂上的理论应用到实际操作中。我 需要在今后熟练掌握课堂上的理论基础,只有坚实的基础,才能在实际 操作中更得心应手。 附 录: #include "iostream.h" #include <iomanip.h> const int DataMax=100; const int BlockNum = 10; int DataShow[BlockNum][DataMax]; // 用于存储要显示的数组 bool DataShowEnable[BlockNum][DataMax]; // 用于存储数组中的数 据是否需要显示 int Data[DataMax]; // 保存数据 int Block[BlockNum]; // 物理块 int count[BlockNum]; // 计数器 int N ; // 页面个数 int M;//最小物理块数 int ChangeTimes; void DataInput(); // 输入数据的函数 void DataOutput(); void LRU(); // LRU函数 ///* int main(int argc, char* argv[]) { DataInput();// DataInput();

分页管理实验报告

分页管理实验报告

一、实验目的1. 理解分页存储管理的基本原理和实现方法。

2. 掌握分页存储管理的优缺点。

3. 分析分页存储管理在实际应用中的效果。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3. 开发工具:PyCharm三、实验内容1. 分页存储管理的基本原理分页存储管理是一种虚拟存储管理技术,将程序的逻辑地址空间划分为若干个固定大小的页,并将物理内存也划分为同样大小的页帧。

程序在执行时,只将当前需要的页加载到内存中,其余页面则在需要时再进行加载,从而实现程序的虚拟存储。

2. 分页存储管理实现方法(1)分页地址转换分页地址转换通过页表实现。

页表记录了逻辑地址与物理地址的对应关系。

当程序访问内存时,需要根据页表将逻辑地址转换为物理地址。

(2)页面置换算法页面置换算法用于解决内存中已满,而新页面需要加载时如何选择页面替换的问题。

常见的页面置换算法有:FIFO(先进先出)、LRU(最近最少使用)、OPT(最优页面置换)等。

(3)缺页中断当程序访问的页面不在内存中时,会发生缺页中断。

操作系统会根据页面置换算法选择一个页面进行替换,并将所需的页面加载到内存中。

3. 实验步骤使用Python编写分页存储管理程序,实现分页地址转换、页面置换算法和缺页中断等功能。

(2)测试程序编写测试用例,模拟程序运行过程中的分页操作,观察分页存储管理的效果。

(3)分析实验结果根据实验结果,分析分页存储管理的优缺点,以及在实际应用中的效果。

四、实验结果与分析1. 分页存储管理程序实现通过Python编写分页存储管理程序,实现分页地址转换、页面置换算法和缺页中断等功能。

2. 实验结果(1)分页地址转换当程序访问内存时,分页存储管理程序能够正确地将逻辑地址转换为物理地址。

(2)页面置换算法通过FIFO、LRU和OPT等页面置换算法,程序能够有效地处理内存中的页面替换问题。

(3)缺页中断程序在访问未在内存中的页面时,能够正确地发生缺页中断,并将所需的页面加载到内存中。

分区存储管理模拟实验报告

分区存储管理模拟实验报告

分区存储管理模拟实验报告1.实验目的了解动态分区存储管理方式中的数据结构和分配算法,加深对动态分区存储管理方式及其实现技术的理解。

2. 实验内容▪用C语言或Pascal语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程Allocate()和回收过程Free()。

其中,空闲分区采用空闲分区链来组织,内存分配时,优先使用空闲区低地址部分的空间。

▪假设初始状态,可用内存空间为640KB,作业请求序列如下(也可以编程从键盘输入,R表示请求,F表示释放):✧作业1请求130 KB。

✧作业2请求60 KB。

✧作业3请求100 KB。

✧作业2释放60 KB。

✧作业4请求200 KB。

✧作业3释放100 KB。

✧作业1释放130 KB。

✧作业5请求140 KB。

✧作业6请求60 KB。

✧作业7请求50 KB。

✧作业6释放60 KB。

▪要求每次分配和回收后显示出空闲区链的情况。

▪如果不能为作业的请求进行内存分配,给出相应的提示信息。

3.实验分析和思考▪采用首次适应算法和最佳适应算法,对内存的分配和回收速度有什么影响?▪如何解决碎片片问题?详细设计首次适应算法:当要分配内存空间时,就查表,在各空闲区中查找满足大小要求的可用块。

只要找到第一个足以满足要球的空闲块就停止查找,并把它分配出去;如果该空闲空间与所需空间大小一样,则从空闲表中取消该项;如果还有剩余,则余下的部分仍留在空闲表中,但应修改分区大小和分区始址。

最佳适应算法:当要分配内存空间时,就查找空闲表中满足要求的空闲块,并使得剩余块是最小的。

然后把它分配出去,若大小恰好合适,则直按分配;若有剩余块,则仍保留该余下的空闲分区,并修改分区大小的起始地址。

内存回收:将释放作业所在内存块的状态改为空闲状态,删除其作业名,设置为空。

并判断该空闲块是否与其他空闲块相连,若释放的内存空间与空闲块相连时,则合并为同一个空闲块,同时修改分区大小及起始地址。

typedef struct freearea{}ElemType;定义一个空闲区说明表结构,每申请一个作业,改作业便具有此结构体typedef struct DuLNode{}DuLNode,*DuLinkList;定义一个双向链表Status Initblock(){}开创带头结点的内存空间链表,通过双向链表把申请的作业链接起来,作业的插入和删除,和链表中节点的插入和删除类似。

请求调页存储管理方式的模拟实验报告

请求调页存储管理方式的模拟实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

计算机操作系统实验_源码_模拟请求分页虚拟存储管理中的硬件地址变换过程[技巧]

计算机操作系统实验_源码_模拟请求分页虚拟存储管理中的硬件地址变换过程[技巧]
4. 进行缺页中断处理。中断返回后,重新执行该指令。 假定主存的每块长度为64个字节,现有一个具有8页的作业,系统为其分配了4个主存块(即 m=4),且最多分4块。其中第0页至第3页已经装入主存 。该作业的页表如表10—2所示。
地址变换算法框图如图10—1所示。
运行设计的地址变换程序 ,显示或打印运行结果。。因为只是模拟地址变换,并不
cin>>menu;
while(menu)
{
switch(menu)
{
case 1:
cout<<"请输入指令的逻辑地址:";
cin>>ins;
changeaddr(p,ins);
break;
case 2:
cout<<"谢谢使用,下次再见~"<<endl;
exit(0);
break;
default:
cout<<"输入有误,请重新输入~"<<endl;
cout<<"----------\t\t1.输入指令\t\t---------"<<endl;
cout<<"----------\t\t2.退出程序\t\t---------"<<endl;
cout<<"----------欢迎使用分页虚拟存储器硬件地址变换算法---------"<<endl;
cout<<endl<<"请输入您的选择:";
p[2].pno=2;p[2].flag=1;p[2].cno=9;p[2].modf=0;p[2].addr=013;

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

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

操作系统模拟实验实验名称:请求分页存储管理模拟实验实验目的:通过实验了解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");//创建一个生产者线程和消费者线程。

分页存储管理实验报告

分页存储管理实验报告

分页存储管理实验报告分页存储管理实验报告篇一:分页存储管理的模拟实验上机报告分页存储管理的模拟实验上机报告页面管理的基本原理及方法:各进程的虚拟空间被划分成若干个长度相等的页(page)。

页长的划分和内存外存之间的数据传输速度以及内存大小等有关。

页式管理还把内存空间也按也的大小划分为页面(page frame)。

然后把页式虚拟地址与内存页面物理地址建立一一对应页表,并用相应的硬件地址变换机构,来解决离散地址变换问题。

在作业或进程开始执行之前,把该作业或进程的程序段和数据全部装入内存的各个页面中,并通过页表(page mapping table)和硬件地址变换机构实现虚拟地址到内存物理地址的地址映射。

1. 内存页面分配静态页面管理的第一步是为要求内存的作业或进程分配足够的页面。

系统依靠存储页面表,请求表及页表来完成内存的分配工作。

a. 页表页表由页号与页面号组成。

如右图所示页表的大小由进程或作业的长度决定。

例如,对于一个每页长1k,大小为20k的进程来说,如果一个内存单元存放一个页表项,则只要分配给该页表20个存储单元即可。

页式管理是每个进程至少拥有一个页表。

实验中对页表的定义如下(采用数组形式,数组下标表示页号,数组单元存放与数组下标(页号)相应的页面号):int pagetable[100] b.请求表(作业申请表)请求表用来确定作业或进程的虚拟空间的各页在内存中的对应位置。

为了完成这个认为,系统必须知道每个作业或进程的页表起始地址(本实验中假定为0)和长度,以进行内存分配和地址变换。

另外请求表中还包括每个作业或进程所要求的页面数。

请求表整个系统一张,实验中对请求表的定义如下(采用结构体数组形式,并将页表也作为其中一个成员(即域)):#define u 5 struct application_table{char name[8];/*作业名*/int size;/*作业大小――即将上表中的请求页面数改用字节表示*/int paddress; /*页表起始地址*/ int length;/*页表长度――以页面数表示*/int state; /*内存的分配状态,以分配的用1表示,未分配的用0表示*/int pagetable[100];/*页表,放在这里是为了方便虚地址转换及作业撤销的操作*/ }application[u];c.存储页面表(本实验中采用位示图法)位示图也是整个系统一张,它指出内存各页面是否已被分配出去,以及未分配页面的总数。

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

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

实验四请求分页存储管理模拟实验一:实验目的通过对页面、页表、地址转换和页面置换过程的模拟,加深对请求分页存储管理系统的原理和实现技术的理解;二:实验内容假设每个页面可以存放10条指令,分配给进程的存储块数为4;用C语言或Pascal语言模拟一进程的执行过程;设该进程共有320条指令,地址空间为32个页面,运行前所有页面均没有调入内存;模拟运行时,如果所访问的指令已经在内存,则显示其物理地址,并转下一条指令;如果所访问的指令还未装入内存,则发生缺页,此时需要记录缺页产生次数,并将相应页面调入内存,如果4个内存块已满,则需要进行页面置换;最后显示其物理地址,并转下一条指令;在所有指令执行完毕后,显示进程运行过程中的缺页次数和缺页率;页面置换算法:分别采用OPT、FIFO、LRU三种算法;进程中的指令访问次序按如下原则生成:50%的指令是顺序执行的;25%的指令是均匀分布在低地址部分;25%的指令是均匀分布在高地址部分;三:实验类别分页存储管理四:实验类型模拟实验五:主要仪器计算机六:结果OPT:LRU: FIFO:七:程序include<>include<>include<>define blocknum 4agenum=-1;blocki.accessed=0;m=0;}}int pageExistint curpageagenum == curpagereturn i; agenum==-1return i; ccessed > blockpos.accessedpos = i; agenum = -1{printf" %02d ",blocki.pagenum;printf"%p |",&blocki.pagenum;}}printf"\n";}void randamagenum = curpage; agenum= numj/10{blockk.accessed = 1000;} ccessed = j;break;}}}position = findReplace;agenum = curpage;agenum = curpage; agenum = curpage;display;n++; ccessed = -1;ccessed++;}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void FIFO{int n=0;agenum=curpage; agenum = curpage; //将此页面调入内存n++;display;}}}printf"缺页次数:%d\n",n;printf"缺页率:%f%%\n",n/100;}void main{int choice;printf"请求分页存储管理模拟系统\n";randam;printf"此进程的页面调用序列如下\n";pagestring;whilechoice = 4{printf"1:OPT 2:LRU 3:FIFO 4:退出\n";printf"请选择一种页面置换算法:";scanf"%d",&choice;init;switchchoice{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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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

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

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

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

并编写模拟程序实现。

(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; //4kB
log[i].pagedaddress=logicAddress%4096;
disp(i,log);
}
}
}
int main()
{
logic();
//show();
return 0;
}。

相关文档
最新文档