操作系统请求页式存储管理实验报告Word格式.docx
《操作系统请求页式存储管理实验报告Word格式.docx》由会员分享，可在线阅读，更多相关《操作系统请求页式存储管理实验报告Word格式.docx（14页珍藏版）》请在冰豆网上搜索。
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]）。
按以上方式，用户指令可以组成32页。
（3）计算并输出下述各种算法在不同内存容量下的命中率
a）先进先出的算法（FIFO）;
b）最近最少使用算法（LRU）;
c）最佳淘汰算法（OPT）;
2
命中率=1-页面失效次数/页地址流长度
在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次
数。
3.随机数产生办法
关于随机数产生办法，可以采用操作系统提供的函数，如Linux或UNIX系统提供函数srand（）和rand（），分
别进行初始化和产生随机数。
例如:
srand（）;
语句可以初始化一个随机数;
a[0]=10*rand（）/32767*319+1;
a[1]=10*rand（）/32767*a[0];
语句可以用来产生a[0]与a[1]中的随机数。
环境说明
此实验采用的是Win7下Code:
:
blocks10.05编译器编程。
此word实验文档中采用notepad++的语法高亮。
4.程序设计说明
4.1.全局变量
constintmaxn=320;
//序列个数
constintmax=maxn+20;
//数组大小
constintmaxp=max/10;
//最大页数
intinst[max];
//指令序列
intpage[max];
//页地址流
intsize;
//内存能容纳的页数
boolin[maxp];
//该页是否在内存里，提高效率intpin[maxp];
//现在在内存里的页
其中in[]数组是为了方便直接判断该页是否在内存里，而不用遍历内存里所有页来判断。
fault_n用来记录缺页次数。
3
4.2.随机指令序列的产生
按照实验要求的写了，但是由于没有考虑细节，开始时出了点问题。
（1）当m=319时，我们顺序执行m+1会产生第32页的页地址，从而使页地址没能按要求限制在[0,31]
之间。
解决方法:
采用循环模加来避免超出范围。
（2）但是这样之后有可能出现模0的问题。
所以我索性将等于0的模数都赋值为160.
最后的程序如下。
voidproduce_inst（）
{
intm,n;
intnum=0;
while（num<
maxn）
m=rand（）%maxn;
inst[num++]=（m+1）%maxn;
if（num==maxn）break;
m=（m+2）%maxn;
if（m==0）m=160;
n=rand（）%m;
inst[num++]=（n+1）%maxn;
n=（n+2）%maxn;
m=maxn-n;
m=rand（）%m+n;
inst[num++]=m;
}
4.3.FIFO算法
定义变量ptr。
一开始先预调页填满内存。
在这一部分，ptr指向下一个要存放的位置。
之后继续执行剩下的指令。
此时，ptr表示队列最前面的位置，即最先进来的位置，也就是下一个要被替换
的位置。
ptr用循环加，即模拟循环队列。
4.4.LRU算法
定义数组ltu[],即last_time_use来记录该页最近被使用的时间。
定义变量ti模拟时间的变化，每执行一次加一。
4
这个算法，我没有预调页，而是直接执行所有指令。
若当前需要的页没在内存里，就寻找最近最少使用的页，也就是ltu[]最小的页，即最近一次使用时间离现在最久的页，然后替换掉它。
或者在内存还未满时，直接写入，这个我以初始化内存里所有页为-1来实现。
若已经在内存里了，则只遍历内存内的页，把当前页的最近使用时间改一下即可。
4.5.OPT算法
定义数组ntu[],即next_time_use来记录下一次被使用的时间，即将来最快使用时间。
初始化为-1.
开始时预调页填满内存里的页。
同样利用变量ptr来表示下一个要存放的位置从而控制预调页的过程。
接着初始化ntu数组为-1。
然后求出每一页下一次被使用的指令号，以此代替使用时间。
如果所有剩下的序列都没有用该页时，则还是-1.这种值为-1的页显然是最佳替换对象。
然后执行所有剩下的指令。
当该页不在内存里时，遍历ntu数组，遇到-1的直接使用该页，没有则用ntu[]值最大的，也就是最晚使用的。
无论该页在不在内存里，因为这一次已经被使用了，所以都应该更新这个页的ntu[]，只需往前看要执行的页流，记录下第一个遇到的该页即可。
如果没有找到同样添-1即可。
#include<
stdio.h>
stdlib.h>
time.h>
string.h>
usingnamespacestd;
//该页是否在内存里，提高效率
intpin[maxp];
voidwelcome（）
printf（"
******************************************\n"
）;
**ByschneeOn2011-12-06**\n"
**班级:
09211311班内序号:
30**\n"
******************************************\n\n"
5
voidinput_hint（）
\n1--createnewinstructionsequence2--setmemorypagenumber（4to
32）\n"
3--solvebyFIFOalgorithm4--solvebyLRUalgorithm\n"
5--solvebyOPTalgorithm0--exit\n"
*********PleaseinputYourchoice:
"
/*通过随机数产生一个指令序列，共320条指令*/voidproduce_inst（）
/*将指令序列变换成为页地址流*/voidturn_page_address（）
for（inti=0;
i<
maxn;
i++）
page[i]=inst[i]/10;
}
voidFIFO_solve（）
memset（in,false,sizeof（in））;
intfault_n=0;
//缺页率
intptr,i;
6
//预调页填满空间
ptr=0;
//下一个要放的位置
for（i=0;
maxn&
&
ptr<
size;
if（!
in[page[i]]）
pin[ptr++]=page[i];
in[page[i]]=true;
fault_n++;
//继续执行剩下的指令
//队列里最先进来的位置，即下一个要被替换的位置
for（;
in[pin[ptr]]=false;
pin[ptr]=page[i];
ptr=（ptr+1）%size;
\nByFIFOalgorithm,thefault-pagenumberis:
%d\n"
fault_n）;
thehitratiois:
%.2lf\n"
（1-（fault_n+0.0）/320.0））;
voidLRU_solve（）
intltu[maxp];
//last_time_use
intti=1;
//模拟时间
memset（ltu,0,sizeof（ltu））;
memset（pin,-1,sizeof（pin））;
intmin,ptr,i,j;
//寻找lru
min=1000000;
ptr=0;
for（j=0;
j<
j++）
if（ltu[j]<
min）
7
min=ltu[j];
ptr=j;
//替换或写入
if（pin[ptr]!
=-1）
ltu[ptr]=ti++;
else//已经在内存里则只需更改最近使用时间
if（pin[j]==page[i]）
ltu[j]=ti++;
break;
\nByLRUalgorithm,thefault-pagenumberis:
voidOPT_solve（）
intntu[maxp];
//next_time_use
inti,j;
memset（ntu,-1,sizeof（ntu））;
//预调页填满
intptr=0;
fault_n<
ptr++;
8
//初始化ntu数组
for（j=i;
32;
if（ntu[page[j]]==-1）
ntu[page[j]]=j;
intmax;
max=0;
if（ntu[pin[j]]==-1）
if（ntu[pin[j]]>
max）
max=ntu[pin[j]];
ntu[page[i]]=-1;
for（j=i+1;
if（page[j]==page[i]）
ntu[page[i]]=j;
9
\nByOPTalgorithm,thefault-pagenumberis:
intmain（）
srand（time（NULL））;
welcome（）;
intchoice;
while
（1）
input_hint（）;
scanf（"
%d"
&
choice）;
\n"
if（choice==0）
BYE-BYE!
!
if（choice==1）
produce_inst（）;
turn_page_address（）;
NewpageaddresssequenceissetOK!
elseif（choice==2）
Pleaseinputthesizeofmemorypagenumber:
size）;
elseif（choice==3）
FIFO_solve（）;
elseif（choice==4）
LRU_solve（）;
elseif（choice==5）
OPT_solve（）;
else
INPUTERROR!
\n"
return0;
10
6.运行结果及分析
）
内存451015202532
2852722301781359032FIFO
2852742241851399132LRU
22120214096684832OPT
2722622061671288232FIFO
2712652041631308632LRU
20118312792664732OPT
随着页数的增多，除了FIFO对某些序列会有Belady’sanomaly（详见6.2）外，大部分情况和LRU算法、OPT算法都是缺页率减小。
OPT是理想情况，效率是最高的。
当然当不缺页时，所有的算法缺页次数都是把所有页调进去的次数。
LRU算法有时候和FIFO算法的效率差
升级会员 