操作系统请求分页式管理.docx

操作系统请求分页式管理.docx

《操作系统请求分页式管理.docx》由会员分享，可在线阅读，更多相关《操作系统请求分页式管理.docx（21页珍藏版）》请在冰豆网上搜索。

操作系统请求分页式管理

课程设计题目：

请求页式管理模拟实现

一、需求分析

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

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

1.设计目的

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

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

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

2.设计要求

通过随机数产生一个指令序列，共320条指令。

指令的地址按下述原则生成：

①50%的指令是顺序执行的；

②25%的指令是均匀分布在前地址部分；

③25%的指令是均匀分布在后地址部分。

具体的实施方法是：

①在[0,319]的指令地址之间随机选取一起点m；

②顺序执行一条指令；

③在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m′；

④顺序执行一条指令，其地址为m′+1；

⑤在后地址[m′+2,319]中随机选取一条指令并执行；

⑥重复上述步骤②~⑤，直到执行320次指令。

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

设：

①页面大小为1K；

②用户内存容量为4页到32页；

③用户虚存容量为32K。

在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：

第0条~第9条指令为第0页（对应虚存地址为[0,9]）；

第10条~第19条指令为第1页（对应虚存地址为[10,19]）；

┇

┇

第310条~第319条指令为第31页（对应虚存地址为[310,319]）。

按以上方式，用户指令可组成32页。

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

先进先出的算法（FIFO）；最近最少使用算法（LRR）；

最少访问页面算法（LFR）；最近最不经常使用算法（NUR）。

3.解决方案

（一）FIFO页面置换算法

先用boolIsExit（）函数判断请求页面是否在内存中，在内存中就直接运行，不在的话，就通过Simulate[x][y%M]算出先进来的页面，比如假如第6个数内存中没有，那置换时第6行第1列数一定是第一个进来的，我y的值这时候是6，然后y除以m取余，就是6除以5取余也就是1，然后将第一个置换出来，下面的就是重复上面的过程了。

每次要置换时LackNum的值就会加1,最后输出页面的置换的过程，算出缺页率。

（二）LRU页面置换算法

先用intIsExitLRU（）函数判断请求页面是否在内存中，在内存中就直接运行，不在的话，intCompare（）算出需要置换的页面，这个功能的实现需要数组PageCount[]来实现。

PageCount[]这个数组记录着内存里5个物理块使用情况，找出需要置换的页面的列数，然后赋值给k，再通过Simulate[x][k]=PageOrder[x]语句置换，每次要置换时LackNum的值就会加1,最后输出页面的置换的过程，算出缺页率。

（三）OPT页面置换算法

先用intIsExitOPT（）函数判断请求页面是否在内存中，在内存中就直接运行，不在的话，intCompare（）2算出需要置换的页面，我将请求数后面产生的的随机数一个一个和内存中的物理块的数比较，当相等的时候，记下相等的物理块号，再做第二个循环，第二个循环比较是除了第一个记录下来的数之外的4个数，相等的时候，再记下相等的物理块号，然后再做第三个循环...第四个做完后返回10减去刚刚找到的物理块号之和。

这个就是要置换的数的列号，然后置换，每次要置换时LackNum的值就会加1,最后输出页面的置换的过程，算出缺页率。

4．实验提示

提示：

A.命中率=1-页面失效次数/页地址流长度

B.本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。

C.关于随机数产生方法，采用TC系统提供函数RAND（）和RANDOMIZE（）来产生。

二、概要设计

1、结构说明

（一）FIFO页面置换算法

①在分配内存页面数小于进程页面数时，当然是最先运行的页面放入内存。

②这时有需要处理新的页面，则将原来内存中的页面最先进入的调出（是以称为FIFO），然后将新页面放入。

③以后如果再有新页面需要调入，则都按⑵的规则进行。

（二）LRU页面置换算法

①当分配内存页面数小于进程页面数时，当然是把最先执行的页面放入内存。

②当需要调页面进入内存，而当前分配的内存页面全部不空闲时，选择将其中最长时间没有用到的那个页面调出，以空出内存来放置新调入的页面（称为LRU）。

③以后如果再有新页面需要调入，则都按⑵的规则进行。

（三）OPT页面置换算法

①当分配内存页面数小于进程页面数时，当然是把最先执行的页面放入内存。

②当需要调页面进入内存，而当前分配的内存页面全部不空闲时，选择将其中最近时间不会用到的那个页面调出，以空出内存来放置新调入的页面（称为OPT）。

③以后如果再有新页面需要调入，则都按⑵的规则进行

2、数据结构及模块说明

定义的变量:

constintMaxNum=320;//指令数

constintM=5;//内存容量

intPageOrder[MaxNum];//页面请求

intSimulate[MaxNum][M];//页面访问过程

intPageCount[M],LackNum;//PageCount用来记录LRU算法中最久未使用时间,LackNum记录缺页数

floatPageRate;//命中率

函数说明：

boolIsExit（inti）//FIFO算法中判断新的页面请求是否在内存中

intIsExitLRU（inti）//LRU算法中判断新的页面请求是否在内存中

intCompare（）//LRU算法找出内存中需要置换出来的页面

intIsExitOPT（inti）//OPT算法中判断新的页面请求是否在内存中

intCompare2（inti）//OPT算法找出内存中需要置换出来的页面

voidInit（）//初始化页框

voiddesignBy（）//给自己加的一个标题

voidOutPut（）//输出

voidFIFO（）//FIFO算法

voidLRU（）//LRU算法

voidOPT（）//OPT算法

voidYourChoice（intchoice）//实现你选择哪个算法的功能

3、流程图

三、详细设计

主要函数设计及说明：

#include

#include

usingnamespacestd;

constintMaxNum=320;//指令数

constintM=5;//内存容量

intPageOrder[MaxNum];//页面请求

intSimulate[MaxNum][M];//页面访问过程

intPageCount[M],LackNum;//PageCount用来记录LRU算法中最久未使用时间,LackNum记录缺页数

floatPageRate;//命中率

boolIsExit（inti）//FIFO算法中判断新的页面请求是否在内存中

{

boolf=false;

for（intj=0;j

{

if（Simulate[i-1][j]==PageOrder[i]）//在前一次页面请求过程中寻找是否存在新的页面请求

{

f=true;

}

}

returnf;

}

intIsExitLRU（inti）//LRU算法中判断新的页面请求是否在内存中

{

intf=-1;

for（intj=0;j

{

if（Simulate[i-1][j]==PageOrder[i]）

{

f=j;

}

}

returnf;

}

intCompare（）//LRU算法找出内存中需要置换出来的页面

{

intp,q;

p=PageCount[0];

q=0;

for（inti=1;i

{

if（p

{

p=PageCount[i];

q=i;

}

}

returnq;

}

intIsExitOPT（inti）//OPT算法中判断新的页面请求是否在内存中

{

inth=-1;

for（intj=0;j

{

if（Simulate[i-1][j]==PageOrder[i]）

{

h=j;

}

}

returnh;

}

intCompare2（inti）//OPT算法找出内存中需要置换出来的页面

{

intq,n,l,m,y,j;

q=-1,n=-1,m=-1,l=-1,y=-1;

for（intd=i;d<320;d++）

{

for（j=0;j

if（Simulate[i-1][j]==PageOrder[d]）

{

q=j;

break;

}

}

for（d=i;d<320;d++）

{

for（j=0;j

if（j!

=q）

{

if（Simulate[i-1][j]==PageOrder[d]）

{

n=j;

break;

}

}

}

for（d=i;d<320;d++）

{

for（j=0;j

if（j!

=q&&j!

=n）

{

if（Simulate[i-1][j]==PageOrder[d]）

{

m=j;

break;

}

}

}

for（d=i;d<320;d++）

{

for（j=0;j

if（j!

=q&&j!

=n&&j!

=m）

{

if（Simulate[i-1][j]==PageOrder[d]）

{

l=j;

break;

}

}

}

return（10-q-n-m-l）;

}

说明：

将请求数后面产生的的随机数一个一个和内存中的物理块的数比较，当相等的时候，记下相等的物理块号，再做第二个循环，第二个循环比较是除了第一个记录下来的数之外的4个数，相等的时候，再记下相等的物理块号，然后再做第三个循环...第四个做完后返回10减去刚刚找到的物理块号之和，这个就是要置换的数的列号。

voidInit（）//初始化页框

{

for（intk=0;k

{

intn=rand（）%320;//随机数产生320次指令

PageOrder[k]=n/10;//根据指令产生320次页面请求

}

for（inti=0;i

{

for（intj=0;j

{

Simulate[i][j]=-1;

}

}

for（intq=0;q

{

PageCount[q]=0;

}

}

voiddesignBy（）

{

printf（"┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n"）;

printf（"┃课题四：

页面置换算法┃\n"）;

printf（"┃班级：

11计本2班┃\n"）;

printf（"┃学号：

20110303214┃\n"）;

printf（"┃姓名：

周玉亭┃\n"）;

printf（"┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"）;

}

voidOutPut（）//输出

{

inti,j;

cout<<"页面访问序列:

"<

for（j=0;j

{

cout<

}

cout<

cout<<"页面访问过程:

"<

for（i=0;i<10;i++）

{

for（j=0;j

{

if（Simulate[i][j]==-1）

cout<<"";

else

cout<

}

cout<

cout<

}

cout<<"缺页数="<

cout<<"命中率="<

cout<<"--------------------------------------------------------------"<

}

说明：

将FIFO算法、LRU算法、OPT算法的页面访问过程显示出来，并输出缺页数和命中率。

voidFIFO（）//FIFO算法

{

intj,x=0,y=0;

LackNum=0,

Init（）;

for（j=0;j

{

for（intk=0;k<=j;k++）

{

if（j==k）

Simulate[j][k]=PageOrder[j];

else

Simulate[j][k]=Simulate[j-1][k];

}

LackNum++;

}

for（x=M;x

{

for（intt=0;t

{

Simulate[x][t]=Simulate[x-1][t];

}

if（!

IsExit（x））//根据新访问页面是否存在内存中来更新页面访问过程

{

LackNum++;

Simulate[x][y%M]=PageOrder[x];

y++;

}

}

PageRate=1-（（float）LackNum/（float）MaxNum）;//算出命中率

OutPut（）;

}

说明：

用Simulate[x][y%M]算出需要置换页面，比如假如第6个数内存中没有，那置换时第6行第1列数一定是第一个进来的，我y的值这时候是6，然后y除以m取余，就是6除以5取余也就是1，然后将第一个置换出来。

voidLRU（）//LRU算法

{

intj,x=0,y=0;

LackNum=0,

Init（）;

for（j=0;j

{

for（intk=0;k<=j;k++）

{

PageCount[k]++;

if（j==k）

Simulate[j][k]=PageOrder[j];

else

Simulate[j][k]=Simulate[j-1][k];

}

LackNum++;

}

for（x=M;x

{

for（intt=0;t

{

Simulate[x][t]=Simulate[x-1][t];

}

intp=IsExitLRU（x）;

if（p==-1）//根据反回的p值来更新页面访问过程

{

intk;

k=Compare（）;

for（intw=0;w

{

if（w!

=k）

PageCount[w]++;

else

PageCount[k]=1;

}

Simulate[x][k]=PageOrder[x];

LackNum++;

}

else

{

for（intw=0;w

{

if（w!

=p）

PageCount[w]++;

else

PageCount[p]=1;

}

}

}

PageRate=1-（（float）LackNum/（float）MaxNum）;//算出命中率

OutPut（）;

}

说明:

先用一开始的五个页面放入内存中，然后判断下面要运行的页面是否在内存中，在内存中就直接运行，不在的话，intCompare（）算出需要置换的页面。

PageCount[]这个数组记录着内存里5个物理块使用情况，找出需要置换的页面的列数，然后赋值给k，再通过Simulate[x][k]=PageOrder[x]语句置换，每次要置换时LackNum的值就会加1。

voidOPT（）//OPT算法

{

intj,x=0,y=0;

LackNum=0,

Init（）;

for（j=0;j

{

for（intk=0;k<=j;k++）

{

//PageCount[k]++;

if（j==k）

Simulate[j][k]=PageOrder[j];

else

Simulate[j][k]=Simulate[j-1][k];

}

LackNum++;

}

for（x=M;x

{

for（intt=0;t

{

Simulate[x][t]=Simulate[x-1][t];

}

intp=IsExitOPT（x）;

if（p==-1）//根据反回的p值来更新页面访问过程

{

intk;

k=Compare2（x）;

Simulate[x][k]=PageOrder[x];

LackNum++;

}

}

PageRate=1-（（float）LackNum/（float）MaxNum）;//算出命中率

OutPut（）;

}

说明：

先用一开始的五个页面放入内存中，然后判断下面要运行的页面是否在内存中，在内存中就直接运行，不在的话，就将intCompare2（）算出需要置换的页面的列数，带入置换，每次要置换时LackNum的值就会加1,最后输出页面的置换的过程，算出缺页率。

voidYourChoice（intchoice）

{

switch（choice）

{

case1:

cout<<"----------------------------------------------------------"<

cout<<"FIFO算法结果如下：

"<

FIFO（）;

break;

case2:

cout<<"----------------------------------------------------------"<

cout<<"LRU算法结果如下：

"<

LRU（）;

break;

case3:

cout<<"----------------------------------------------------------"<

cout<<"OPT算法结果如下：

"<

OPT（）;

break;

case4:

break;

default:

cout<<"重新选择算法：

1--FIFO2--LRU3--OPT4--退出"<

cin>>choice;

YourChoice（choice）;

}

}

voidmain（）

{

system（"color0E"）;

designBy（）;

intchoice,i=1;

while（i）

{

cout<<"请选择算法：

1--FIFO2--LRU3--OPT4--退出"<

cin>>choice;

if（choice==4）

{

i=0;

}

else

{

YourChoice（choice）;

}

}

}

四．调试分析

调试过程和调试结果

一开始运行出来的界面：

选择FIFO算法运行的界面：

选择FRU算法运行的界面：

选择OPT算法运行的界面：

五、总结

1、遇到的问题

在做最佳置换算法时，对于选出要置换的页面的算法遇到了很大的困难，程序是对的，算法有点问题，可是理论上也是对的。

很纠结的一个问题啊！

2、不足

最佳置换算法在最后实现的时候还是有点问题的。

我就不告诉老师了，让它成为一个秘密吧！

3、心得体会

一周半的课程设计，在忙忙碌碌的日子中悄悄地结束了。

虽然课程设计的时间比较短，但是带给我的影响还是很大的。

不仅加强了我敲代码的能力，而且也培养了我对一个算法执着的精神。

通过课程设计，让枯燥乏味的课本变得多态有趣，让我觉得学习也不是那么枯燥的一件事，同时，课程设计也让我深入地理解了课本的知识，让我我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正为社会服务，从而提高自己的实际动手能力和独立思考的能力。

知识的获得是无止境的，只要你想学，只要你行动，就一定会有所收获的。

回首这两个星期的课程设计，在做最佳置换算法时，对于选出要置换的页面的算法遇到了很大的困难，程序是对的，算法有点问题，可是理论上也是对的。

当时课上忍了半天也没忍出来，后来回去到图书馆我请姚方贵同学来和我一起解决，终于把那个错的地方找出来了，在此，我由衷的感谢老师和姚方贵同学对我的帮助，我永远会记得大家一起努力的日子！

六、参考文献

（1）汤子瀛，哲风屏，汤小冉等，《计算机操作系统》，西安电子科技大学出社，2001年8月

（2）张尧学，史美林，《计算机操作系统课程》，清华大学出版社，2000年