操作系统请求页式存储管理实验报告分析解析Word文档下载推荐.docx
《操作系统请求页式存储管理实验报告分析解析Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《操作系统请求页式存储管理实验报告分析解析Word文档下载推荐.docx（15页珍藏版）》请在冰豆网上搜索。
b）用户内存容量为４页到32页；
c）用户虚存容量为3２K。
在用户虚存中，按每Ｋ存放10条指令排列虚存地址，即３20条指令在虚存中的存放方式为：
第0条～第9条指令为第0页（对应虚存地址为［0，9]）;
第１0条~第１9条指令为第1页（对应虚存地址为[1０,1９]）;
…
第３10条～第３19条指令为第31页（对应虚存地址为[3１０,３19]）。
按以上方式,用户指令可以组成32页。
（3）计算并输出下述各种算法在不同内存容量下的命中率
a）先进先出的算法（FＩＦO）;
ｂ）最近最少使用算法（LRＵ）;
c）最佳淘汰算法（OPＴ）；
ﻬ命中率=1－页面失效次数/页地址流长度
在本实验中,页地址流长度为32０,页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数。
3.随机数产生办法
关于随机数产生办法,可以采用操作系统提供的函数,如Linux或UNIＸ系统提供函数ｓｒand（）和rand（）,分别进行初始化和产生随机数。
例如:
srand（）;
语句可以初始化一个随机数;
a[0]=10*rand（）／327６7*３19+1；
a[1]=10*ｒaｎｄ（）/3２767*a[0］;
语句可以用来产生a[0]与a[1]中的随机数。
环境说明
此实验采用的是Wiｎ７下Codｅ:
:
bloｃks1０.05编译器编程。
此wｏrd实验文档中采用nｏtepad++的语法高亮。
4.程序设计说明
4.1.全局变量
constiｎtｍａxn=３２0；
/／序列个数
const intｍaｘ =maxn +２０;
//数组大小
cｏnst intmaxｐ ＝ max/10;
//最大页数
ｉｎｔinｓt[max];
/／指令序列
intｐage[mａx]；
／/页地址流
ｉｎtｓiｚe;
／／内存能容纳的页数
ｂoｏl ｉn[maxp];
／/该页是否在内存里，提高效率
int pin［mａxp];
//现在在内存里的页
其中in[]数组是为了方便直接判断该页是否在内存里，而不用遍历内存里所有页来判断。
faｕｌt＿ｎ用来记录缺页次数。
4.2.随机指令序列的产生
按照实验要求的写了，但是由于没有考虑细节,开始时出了点问题。
（1）当ｍ=31９时，我们顺序执行m+1会产生第32页的页地址，从而使页地址没能按要求限制在[0,31]之间。
解决方法：
采用循环模加来避免超出范围。
（2）但是这样之后有可能出现模０的问题。
所以我索性将等于0的模数都赋值为1６0.
最后的程序如下。
voidpｒoｄucｅ_inst（）
{
inｔm, n；
ｉnt ｎum =0;
whｉｌe（ｎum<
maxｎ）
｛
m=raｎd（）％ ｍaｘｎ;
ｉnsｔ[nｕｍ++］=（ｍ＋1）%mａｘn;
if（nｕm== maxｎ）bｒeａk；
m=（ｍ+2）%maxn;
iｆ（m =＝0）m=１60；
ｎ=rand（）%ｍ;
insｔ[nｕm++]=（ｎ+1）%mａxn;
iｆ（ｎｕm==mａxｎ）bｒeak；
n ＝（n＋2）％mａxｎ;
m=mａxｎ-n;
if（m==0）m=16０;
m= rａｎd（） % m＋n;
insｔ[ｎｕm++] ＝ m;
}
}
4.3.FIＦＯ算法
定义变量ｐtr。
一开始先预调页填满内存。
在这一部分,ｐtr指向下一个要存放的位置。
之后继续执行剩下的指令。
此时，ptr表示队列最前面的位置，即最先进来的位置,也就是下一个要被替换的位置。
ptr用循环加,即模拟循环队列。
4.4.LRU算法
定义数组ltu[]，即lａsｔ＿tiｍe_uｓe来记录该页最近被使用的时间。
定义变量ti模拟时间的变化，每执行一次加一。
这个算法,我没有预调页，而是直接执行所有指令。
若当前需要的页没在内存里，就寻找最近最少使用的页，也就是ltu[]最小的页,即最近一次使用时间离现在最久的页,然后替换掉它。
或者在内存还未满时,直接写入，这个我以初始化内存里所有页为-1来实现。
若已经在内存里了,则只遍历内存内的页，把当前页的最近使用时间改一下即可。
4.5.OPＴ算法
定义数组ntu［],即nｅｘｔ_timｅ_usｅ来记录下一次被使用的时间,即将来最快使用时间。
初始化为－1．
开始时预调页填满内存里的页。
同样利用变量ptr来表示下一个要存放的位置从而控制预调页的过程。
接着初始化nｔu数组为－１。
然后求出每一页下一次被使用的指令号,以此代替使用时间。
如果所有剩下的序列都没有用该页时，则还是－１．这种值为－1的页显然是最佳替换对象。
然后执行所有剩下的指令。
当该页不在内存里时，遍历ntｕ数组，遇到－1的直接使用该页，没有则用ｎｔu[]值最大的,也就是最晚使用的。
无论该页在不在内存里，因为这一次已经被使用了,所以都应该更新这个页的ntｕ[],只需往前看要执行的页流,记录下第一个遇到的该页即可。
如果没有找到同样添-1即可。
5.编程实现（源程序）：
#iｎｃlude＜stdio.h>
#inｃｌｕde<
stdｌib．h>
#incｌude＜ｔｉme.h>
#inｃludｅ＜stｒing.ｈ>
using namespacestｄ;
constintｍａxn ＝320;
／／序列个数
cｏｎsｔintｍax ＝mａxn+2０;
ｃonsｔｉntｍaxp= ｍａｘ/1０;
／／最大页数
ｉｎt iｎst［mａx];
//指令序列
ｉnｔｐａge[max］;
//页地址流
intsｉze；
／／内存能容纳的页数
boｏｌ in[ｍaxp];
//该页是否在内存里,提高效率
ｉntpiｎ[ｍａxp];
//现在在内存里的页
voｉd welｃome（）
ｐrintｆ（"
*********＊**************＊＊**＊*＊****＊**＊*＊*\n"
）;
prｉｎtf（＂*＊ By schnｅe Oｎ２0１1－１2-０６ ＊*\ｎ"
pｒintf（"
** 班级：
092１131１班内序号：
30 *＊\n"
priｎtf（＂＊*＊**＊*＊＊****＊＊******＊*＊**＊*＊******＊******\ｎ＼n"
｝
voidinput＿hｉnt（）
prｉｎtf（"
\n1-－ｃreａtenｅｗinstruｃtioｎsｅｑuｅnce 2--setmemorypagｅnumbｅr（4to32）＼n"
printf（"
3--soｌveｂyＦIFＯ algｏrithm 4--ｓolｖe by ＬRＵalgoｒｉthm\n"
printf（"
５--sｏlveｂyOPTａlgoritｈm ０－－eｘiｔ\ｎ"
prinｔｆ（"
＊***＊***＊Please input Ｙour chｏｉｃe:
"
/＊通过随机数产生一个指令序列，共3２０条指令*/
voｉｄｐrｏduce_ｉnst（）
｛
ｉnｔm,n;
int num= 0;
while（ｎｕｍ <
maxn）
{
m＝ rａnd（） %mａxn;
inｓt[nuｍ++]＝（m+１）%mａxｎ;
ｉf（num==maxn）ｂrｅak;
m =（m+2）%maxｎ；
iｆ（ｍ==０）ｍ =1６0;
n =ranｄ（） % m;
inst[nuｍ++]=（n+１）%maxn;
if（nuｍ==ｍａxn）breaｋ;
n = （n+2）%maxn;
ｍ=maxn - n；
ｉf（m ==０）m=160;
m=ｒaｎｄ（）%ｍ+ n;
ｉnst[num++］=m;
}
／*将指令序列变换成为页地址流*/
voidturn_pａge_ａｄdress（）
for（iｎti=0;
i＜maｘn;
ｉ++）
ｐａge[ｉ]＝inst[i］/1０;
voiｄFIＦO_sｏlve（）
memseｔ（ｉｎ,falｓe, ｓｉｚｅｏｆ（in））;
inｔｆault＿n=０;
/／缺页率
int ptr,i；
／/预调页填满空间
ptr=0;
/／下一个要放的位置
for（i=０;
ｉ＜maxn＆＆ptr<
size;
i＋+）
if（!
ｉn[paｇｅ[i]］）
{
ｐｉn[ｐtr++]=page［ｉ］;
iｎ[page［i］] =ｔrue;
fault_ｎ++;
}
//继续执行剩下的指令
ｐｔr＝0;
//队列里最先进来的位置,即下一个要被替换的位置
foｒ（;
i<
maｘn；
if（！
iｎ[paｇe[ｉ]]）
{
ｉn[ｐｉｎ［ptr]]=falsｅ;
in[ｐａgｅ[i]］=truｅ；
piｎ[ｐtr］=paｇｅ[i];
faulｔ_n++；
ptｒ=（ｐtr+1）%size;
}
ｐｒintf（＂\ｎByＦIFOａlgorithm, the faｕlt－page nｕｍber is:
％d\n"
， fauｌt_n）;
pｒiｎｔf（"
the hitrａtｉois:
％．2lｆ＼n"
（1-（fault_n＋0.0）/3２０．0））；
voｉdLRU_ｓｏlve（）
ｉｎtltu[maxp］;
//last_ｔｉmｅ＿ｕsｅ
inttｉ＝1;
//模拟时间
intｆaｕｌt_n=0；
ｍｅｍsｅt（ltu,0，sizeof（ltｕ））;
memｓｅt（in,false, sizeof（in））;
memset（piｎ,－1, sizeof（piｎ））;
inｔmiｎ，pｔr, i,j;
ｆor（i=0;
ｍａxn;
｛
ｉf（!
ｉn[page[i]]）
{
／／寻找lru
mｉn＝１0０0000;
ptｒ=0;
fｏr（j＝0;
j＜size;
j＋+）
{
if（lｔu[j]<
min）
{
miｎ =ｌtu[ｊ];
ptr= j;
}
}
//替换或写入
if（pin［ptr]!
=－1）
in［pｉn[ｐｔr］]= ｆalsｅ；
ｉn[page[ｉ]]=tｒｕe;
ｐiｎ[ｐtｒ]=ｐage[i];
faｕlt＿n++;
ltｕ［ptr］=ti+＋；
}
elｓe/／已经在内存里则只需更改最近使用时间
{
for（j=0；
j<
size；
ｊ++）
if（pin[j]==ｐage[i]）
lｔｕ[j]=ti++；
bｒeａk;
}
}
}
prｉnｔf（"
＼nByLRUａｌgoｒithm, ｔheｆａｕｌｔ－page numｂer ｉs:
%d＼n"
fauｌｔ_n）;
ｐrintf（"
thehｉt rａtioｉｓ :
%.２lf\n"
（1-（faulｔ_n＋0.0）/3２０.0））；
ｖoｉｄOPＴ_sｏlｖe（）
ｉntntu[maxp];
//neｘt_time_ｕse
ｉnｔfａｕlｔ_n＝0；
inｔi,j;
memｓet（in， false, siｚｅｏｆ（iｎ））;
mｅmset（ntu，-1, sizeof（ntu））；
//预调页填满
ｉnｔptr=０;
ｆor（i=０;
maxｎ＆&
faulｔ_n<
sizｅ;
{
if（!
in[page[ｉ］]）
｛
iｎ[paｇe[i]]=true；
piｎ[ptr]= pagｅ[i］；
ｆａulｔ_n++;
pｔr++;
｝
}
//初始化nｔu数组
pｔr= ０；
ｆor（j=i;
ｍaxn&
＆ptr<
3２;
j++）
ｉｆ（nｔu[ｐagｅ[j]]==-1）
{
ntu[page[ｊ]]＝ｊ;
ｐtr＋+;
intmax;
ｆor（;
mａxn;
i++）
{
ｉｆ（!
iｎ［pagｅ［i]］）
{
ｍax＝0；
pｔr=0;
for（j=0;
ｊ<
siｚｅ;
j+＋）
{
if（ntu［ｐin[j]]=＝ -１）
ｐtr=j;
ｂｒeａk;
}
if（nｔu[pin［j]]>
max）
｛
ｍax=ntu［ｐin[j]］;
ptr=j；
}
｝
in[ｐin［ptr］]= false;
in［page[i］］ =truｅ;
pin[ｐtr］=paｇe[i];
ｆault＿n++;
ntu［page[i]] = -1；
ｆoｒ（j=ｉ+１；
mａxn；
if（page[ｊ］== page[i]）
｛
ntｕ[pagｅ[i］] ＝ j;
break；
}
printf（＂\nByOPT algｏrithｍ,theｆａulｔ－paｇenｕmbeｒis:
%d＼ｎ"
fault_n）;
printf（＂ the ｈｉtratioiｓ:
%.2lf\n"
（1-（ｆauｌt_n+0.0）/320.0））;
iｎtmaｉn（）
srand（tｉme（NULL））；
welcoｍe（）;
intｃhoice;
whｉlｅ（１）
iｎpuｔ_hｉnt（）;
ｓcanｆ（"
%ｄ＂，&
ｃhoice）;
prｉntf（"
\ｎ＂）；
if（ｃhｏｉcｅ=＝０）
｛
ｐｒiｎｔf（"
BYE-BYE！
!
\n"
breaｋ;
}
if（chｏice==1）
{
ｐroduｃｅ_ｉnst（）;
turn＿page＿aｄｄrｅss（）;
printf（＂Ｎew pagｅaｄdrｅsssequenceis sｅtOＫ!
！
＼n＂）;
eｌseif（ｃhｏｉce==2）
prinｔf（"
Pleaｓe inpｕt tｈｅ sizeofmemorｙ ｐaｇｅ numｂer:
"
ｓcanf（"
%d＂,&
ｓize）；
}
ｅlsｅ iｆ（chｏice=＝ 3）
FIFO_sｏlｖe（）;
elｓe if（choｉｃe==4）
LRU_sｏlvｅ（）；
ｅlseｉf（chｏice==5）
OPT_ｓｏlvｅ（）;
else
ｐrｉnｔf（"
INPUT ERＲOＲ !
\n"
retuｒn０;
6.运行结果及分析
6.1.运行（以某两次运行结果为例,列表如下：
）
内存
４
５
10
15
20
2５
32
FIFO
285
2７2
23０
１7８
１35
90
３２
LRU
２85
2７4
２２4
１85
139
91
OPT
221
２０2
140
９6
68
4８
３2
２72
262
２0６
167
1２8
8２
LRＵ
271
265
204
1６３
1３０
8６
ＯＰT
２0１
183
1２7
92
66
４7
随着页数的增多，除了ＦIFO对某些序列会有Ｂelａdy’sanomaｌy（详见6．2）外，大部分情况和LRU算法、ＯＰT算法都是缺页率减小。
OPＴ是理想情况，效率是最高的。
当然当不缺页时,所有的算法缺页次数都是把所有页调进去的次数。
LＲU算法有时候和FIＦO算法的效率差别并不大。
甚至有时候它还比ＦIFＯ低一些的。
6.2.Ｂelａdy’sanomaly
如下，我稍微改了下输入,手动输入课本上的样例，编程见证了Belady异常现。
这是只有ＦＩＦO算法才有的异常。
升级会员 