北邮大三上操作系统存储管理实验报告.docx
《北邮大三上操作系统存储管理实验报告.docx》由会员分享，可在线阅读，更多相关《北邮大三上操作系统存储管理实验报告.docx（15页珍藏版）》请在冰豆网上搜索。
北邮大三上操作系统存储管理实验报告
操作系统
实验三
存储管理实验
ﻩ
班级:
2009211３1１
学号:
姓名:
scｈneｅ
目 录
1．实验目的2
２.ﻩ实验内容２
（１）通过随机数产生一个指令序列，共320条指令ﻩ2
（２）将指令序列变换成为页地址流ﻩ2
（3）计算并输出下述各种算法在不同内存容量下的命中率2
３．ﻩ随机数产生办法３
环境说明ﻩ3
4．程序设计说明ﻩ3
4．４.ﻩLRU算法ﻩ4
6．ﻩ运行结果及分析1１
6.１.ﻩ运行（以某两次运行结果为例,列表如下：
）ﻩ11
6.２．ﻩBｅlady’s anｏmａlｙﻩ11
1.实验目的
存储管理的主要功能之一是合理地分配空间。
请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。
2.实验内容
（１） 通过随机数产生一个指令序列，共320条指令
指令的地址按下述原则生成:
a）５０%的指令是顺序执行的；
b）25%的指令是均匀分布在前地址部分;
c） 25% 的指令是均匀分布在后地址部分；
具体的实施方法是:
a） 在[0，31９］的指令地址之间随机选取一起点m;
b）顺序执行一条指令，即执行地址为ｍ＋1的指令；
c）在前地址［0，ｍ+１］中随机选取一条指令并执行，该指令的地址为m';
ｄ）顺序执行一条指令，其地址为m'+1;
ｅ） 在后地址[ｍ'+２，319]中随机选取一条指令并执行;
f）重复上述步骤a）~f）,直到执行320次指令。
（2）将指令序列变换成为页地址流
设:
a）页面大小为1K;
b）用户内存容量为4页到32页；
c）用户虚存容量为32K。
在用户虚存中，按每K存放１0条指令排列虚存地址,即３20条指令在虚存中的存放方式为:
第０条～第9条指令为第0页（对应虚存地址为[０,9]）;
第１0条~第19条指令为第1页（对应虚存地址为[1０,19］）;
…
…
第310条~第319条指令为第3１页（对应虚存地址为［31０,319]）。
按以上方式，用户指令可以组成32页。
（3）计算并输出下述各种算法在不同内存容量下的命中率
ａ）先进先出的算法（FIＦＯ）;
b） 最近最少使用算法（LRU）;
c） 最佳淘汰算法（OＰT）;
ﻬ命中率=1-页面失效次数/页地址流长度
在本实验中，页地址流长度为３20，页面失效次数为每次访问相应指令时,该指令所对应的页不在内存的次数。
3.随机数产生办法
关于随机数产生办法,可以采用操作系统提供的函数，如Liｎｕx或UＮIX系统提供函数sｒaｎｄ（）和rand（），分别进行初始化和产生随机数。
例如:
srand（）;
语句可以初始化一个随机数;
a［0]=10＊ｒanｄ（）/3276７*３１9＋１;
a［1]=10*ranｄ（）／３2767*a[０]；
…
语句可以用来产生a[0]与a[1]中的随机数。
环境说明
此实验采用的是Ｗin7下Cｏde:
：
ｂｌocｋs10．05编译器编程。
此ｗord实验文档中采用ｎｏteｐad++的语法高亮。
4.程序设计说明
4.1.全局变量
conｓtintｍaxn=３2０;//序列个数
constｉnt max =maｘn +２０;／/数组大小
ｃonsｔ inｔ ｍａｘｐ=max／10;/／最大页数
ｉntinｓｔ[max]；/／指令序列
ｉntpagｅ［ｍａx]；//页地址流
inｔsｉze; /／内存能容纳的页数
bｏｏl ｉｎ[maｘｐ]；/／该页是否在内存里,提高效率
intpiｎ[maxp];//现在在内存里的页
其中in[]数组是为了方便直接判断该页是否在内存里,而不用遍历内存里所有页来判断。
fａｕlt_n用来记录缺页次数。
4.2.随机指令序列的产生
按照实验要求的写了，但是由于没有考虑细节,开始时出了点问题。
（1）当ｍ=31９时,我们顺序执行m+1会产生第3２页的页地址，从而使页地址没能按要求限制在[0，31］之间。
解决方法：
采用循环模加来避免超出范围。
（2）但是这样之后有可能出现模0的问题。
所以我索性将等于0的模数都赋值为160．
最后的程序如下。
ｖoｉdprodｕcｅ_iｎst（）
{
iｎtｍ,n;
intnum ＝０;
ｗｈｉｌｅ（nuｍ {
m =rand（）％ｍａxｎ;
inst[ｎum＋+］=（m+１）%maxn;
ｉf（num==maxn）brｅaｋ;
m= （m+2）％maxn;
if（ｍ==0）m=160;
ｎ=raｎd（）％m;
inst[nｕm++]＝（n+1）%ｍaxn；
if（num ==ｍaｘn）breaｋ;
n＝（n+２）%maｘn;
m=maxｎ-n;
ｉf（m＝=0）m=160;
m =rand（）%m+n;
iｎsｔ[num++]=m;
｝
}
4.3.FIFO算法
定义变量ｐtr。
一开始先预调页填满内存。
在这一部分，pｔr指向下一个要存放的位置。
之后继续执行剩下的指令。
此时，ｐtr表示队列最前面的位置,即最先进来的位置，也就是下一个要被替换的位置。
ptｒ用循环加,即模拟循环队列。
4.4.LRＵ算法
定义数组ｌtｕ[］，即ｌast＿ｔｉｍe_use来记录该页最近被使用的时间。
定义变量ti模拟时间的变化,每执行一次加一。
这个算法，我没有预调页，而是直接执行所有指令。
若当前需要的页没在内存里,就寻找最近最少使用的页,也就是ltu[]最小的页，即最近一次使用时间离现在最久的页，然后替换掉它。
或者在内存还未满时,直接写入，这个我以初始化内存里所有页为-1来实现。
若已经在内存里了，则只遍历内存内的页，把当前页的最近使用时间改一下即可。
4.5.OＰT算法
定义数组ntu［]，即next＿timｅ＿use来记录下一次被使用的时间,即将来最快使用时间。
初始化为-1.
开始时预调页填满内存里的页。
同样利用变量ptｒ来表示下一个要存放的位置从而控制预调页的过程。
接着初始化ntu数组为－1。
然后求出每一页下一次被使用的指令号,以此代替使用时间。
如果所有剩下的序列都没有用该页时,则还是－1.这种值为-1的页显然是最佳替换对象。
然后执行所有剩下的指令。
当该页不在内存里时，遍历ntu数组，遇到-1的直接使用该页,没有则用nｔu［]值最大的，也就是最晚使用的。
无论该页在不在内存里，因为这一次已经被使用了，所以都应该更新这个页的ｎtu［］，只需往前看要执行的页流,记录下第一个遇到的该页即可。
如果没有找到同样添-１即可。
5.编程实现（源程序）:
#ｉｎclude
#ｉncludｅ<ｓtdliｂ.ｈ>
#iｎclude
#iｎclｕｄｅ
usingnamｅsｐacestｄ;
coｎｓｔintmaxｎ=3２0; ／/序列个数
ｃonstintmax=mａxn+2０;//数组大小
cｏnst intｍaxｐ=max/10; /／最大页数
intinst[max];/／指令序列
intｐage[mａx］;／/页地址流
int sｉze; ／/内存能容纳的页数
bｏｏliｎ[ｍａxp]； //该页是否在内存里,提高效率
inｔｐin［maxｐ］; //现在在内存里的页
vｏｉdweｌｃome（）
{
pｒiｎtf（"***＊*******＊*****＊＊**＊＊****＊＊******＊＊***＊*＼n"）;
prｉntｆ（"** Byscｈnee On20１1-12-06＊*\n＂）；
priｎtf（"** 班级：
0921１31１班内序号：
30 **＼n"）;
printf（"***＊********************＊******＊＊**＊***＊＊＊＼n\n"）;
}
ｖoidinｐut＿hiｎt（）
{
pｒｉntf（＂\n１－-creaｔenｅｗ ｉnsｔructionsequence 2-－setmemorypage ｎuｍｂer（４to３２）＼ｎ"）;
pｒintf（＂３--solvｅ bｙFIFO aｌgｏｒｉthm 4－-sｏlvｅbyLＲUalgorithm\n"）;
printf（"5--sｏlvｅbyＯPT ａlgorｉthｍ 0--ｅxｉt\n"）;
printf（"*＊******＊Pｌeａse iｎpuｔYourchoice：
"）;
}
／*通过随机数产生一个指令序列,共3２0条指令*／
void prodｕce_inst（）
{
inｔm，n;
iｎt ｎｕm =0；
wｈile（nuｍ ｛
m =rａnｄ（）%maｘn;
iｎｓt［num＋+]= （m+1）%ｍaｘn；
ｉf（ｎum ==ｍａｘｎ）bｒｅak;
m ＝ （m+2） %ｍaxｎ;
iｆ（m==０）m=1６0;
ｎ=rａｎd（）% m;
inst[ｎum++］=（n+１）%maxn;
iｆ（ｎum == ｍａｘn）break;
n =（n+２）%mａxn;
ｍ=maｘn－n;
ｉf（m =＝0） m =160；
m＝rａｎd（）%m＋n;
inｓt[num＋+] =m;
}
}
／*将指令序列变换成为页地址流＊／
voidturｎ_pａgｅ_addresｓ（）
｛
fｏr（inti＝0; i＜maxｎ;i＋＋）
pａge[i]＝ iｎｓt[ｉ］/10;
}
voidFIＦO_soｌve（）
{
memset（in,faｌse， sizeof（iｎ））;
ｉntfault_ｎ＝0;／/缺页率
iｎtptr,ｉ;
／/预调页填满空间
ptr＝ 0；//下一个要放的位置
for（i＝０;iif（!
in[paｇe［i］]）
{
piｎ［ptr++] =pａge[ｉ]；
iｎ［paｇｅ［ｉ]］ =tｒｕe;
fault_n＋+;
}
/／继续执行剩下的指令
ptr=0；/／队列里最先进来的位置,即下一个要被替换的位置
for（;ｉ ｉf（！
ｉn［page[ｉ]]）
{
ｉn[pｉｎ[ptr]]=false;
in[pagｅ［i]］ =ｔｒue;
piｎ［ptr] =ｐage［i];
faｕlｔ_ｎ＋＋；
ｐtｒ=（pｔr+1）％sizｅ；
｝
priｎtf（"\nBｙFIＦＯaｌgoritｈm, tｈefauｌt-ｐagenumber is:
%d\n＂,fａult_ｎ）;
pｒintf（" thehiｔrａｔｉoｉs：
％.2lｆ\ｎ",（1-（fauｌｔ_n＋0.0）／3２0．0））;
}
void LRU_solve（）
｛
ｉnｔｌtｕ[maxp];/／laｓｔ_tｉｍe＿use
iｎt ｔi= １；//模拟时间
iｎtfaｕlt_n =0;
memseｔ（lｔu,０,ｓizeof（ｌｔｕ））;
memset（in, faｌse, ｓizeoｆ（in））;
ｍemｓeｔ（ｐin，-１, sizｅｏf（pin））；
intmｉn,pｔr,ｉ,ｊ;
fｏｒ（ｉ=0；i ｛
ｉf（!
in[paｇe[i]]）
｛
／/寻找lru
ｍiｎ＝１000000;ｐｔr=０;
ｆoｒ（j=０;j {
if（ｌｔu[j] {
ｍiｎ =lｔｕ[j];
ptr =j;
｝
}
//替换或写入
if（pin[ｐtｒ]!
= －1）
in[ｐin[ptr]]= faｌse;
in[ｐage[ｉ］]＝ trｕe；
pin[ｐtr]= paｇｅ[i］；
faｕｌｔ＿ｎ++;
ltｕ［ptr]＝tｉ++；
}
else/／已经在内存里则只需更改最近使用时间
{
foｒ（ｊ=0;j＜ｓiｚe;j+＋）
iｆ（pin[j]== page[ｉ]）
｛
ｌtｕ[j]=ｔi++;
break;
｝
}
}
printf（"\ｎByLＲＵalｇoritｈm,thｅfａulｔ-pagenumｂeｒｉs:
％d\n"，fault＿n）;
pｒinｔf（＂ thehitratiｏiｓ:
%.2lf\ｎ＂, （1－（fault_ｎ+0.０）/３20.0））;
}
ｖｏｉｄOPT_solve（）
{
ｉntｎtu［mａxｐ];//nexｔ_time_ｕse
inｔ ｆaｕlt＿n=0;
iｎtｉ， j;
mｅmsｅt（in,falｓe,sｉzｅｏｆ（in））;
ｍemｓet（ｎtu,-1，siｚeof（ntu））;
//预调页填满
ｉｎtptｒ= 0；
foｒ（i=０; i<ｍaｘn&& fault＿n{
if（!
in[ｐage[ｉ]］）
{
in[paｇe[i］]=ｔrue;
pｉn[ptr］=page［ｉ];
fauｌt_n＋＋；
ptｒ+＋；
}
｝
//初始化ntu数组
pｔr=0;
foｒ（j=ｉ；ｊ＜maxｎ&&pｔr＜３２；j++）
{
if（ｎtu[pａｇe[j]］＝= -1）
{
ntu[pagｅ[j]]=ｊ;
ptr＋+;
}
}
ｉnｔｍax；
for（； i{
if（!
ｉn[page[ｉ]]）
{
max=0；ｐｔr＝0；
ｆor（j＝０;j {
iｆ（nｔu[pin[j]]＝=-1）
｛
ｐtｒ=j;
brｅａk;
}
ｉf（nｔu[pin[j]]>max）
{
ｍax=ntu[piｎ[ｊ]];
ｐｔr =j;
}
｝
iｎ［ｐin[ptr]] ＝ ｆalｓe;
iｎ[ｐagｅ[i]] =tｒue;
pin[ptr]=ｐａge[i];
fａult_ｎ++;
}
ntｕ[pａge[ｉ]]= -1；
fｏr（ｊ=i+1;j if（page[ｊ]＝＝ｐａge[i]）
{
ntu[pａge［i］] =ｊ;
ｂrｅａk;
｝
}
printf（＂\nBｙＯＰTalgoｒithm，ｔｈefault－pagｅnumｂeｒｉs:
％d\n＂, ｆａｕlｔ＿n）;
printf（" tｈe ｈitratiｏ is:
%．2ｌf\n",（1-（faulｔ_n＋0.０）/３20.0））;
}
ｉntmａiｎ（）
{
srand（time（NULL））；
ｗeｌcｏｍe（）;
iｎtchoice;
ｗhiｌe
（1）
{
inｐut_ｈint（）；
ｓcanf（"％d",&ｃｈoiｃｅ）;
prinｔf（"\ｎ"）；
iｆ（chｏice== 0）
{
printf（"BYE-BYＥ!
!
!
＼ｎ＂）;
brｅak;
}
iｆ（chｏice==1）
｛
prｏduｃｅ_inst（）;
tｕrn_pａge_addrｅss（）;
printf（"Newpageａｄdｒesｓseｑuencｅiｓset OＫ!
!
!
＼n"）；
}
else if（chｏiｃe== ２）
{
printｆ（"Ｐleａseiｎpuｔtｈesｉzｅ oｆｍemoｒypage ｎumber:
"）;
sｃanf（"%d",&ｓｉze）;
｝
eｌseｉf（cｈoｉcｅ＝=３）
FIFO_soｌve（）;
elseiｆ（chｏice==4）
LRU＿solve（）;
ｅｌseif（ｃｈoｉce=＝5）
OPT_sｏlvｅ（）;
eｌｓe
prｉnｔf（"ＩNPUＴERRＯR！
!
!
\n"）;
}
retｕｒｎ0；
｝
6.运行结果及分析
6.1.运行（以某两次运行结果为例,列表如下:
）
内存
4
５
１0
15
20
２５
3２
FＩFＯ
285
272
２30
1７8
１35
90
３２
ＬRU
2８5
274
2２4
１8５
139
9１
３2
ＯＰＴ
221
202
１４０
96
６8
48
32
FIFO
２７２
26２
2０6
16７
1２8
82
３2
LRU
27１
2６5
204
１63
130
86
32
OPT
201
183
127
9２
66
47
３２
随着页数的增多，除了FIFＯ对某些序列会有Ｂeｌaｄｙ’s aｎomaly（详见6.2）外，大部分情况和LＲU算法、ＯPＴ算法都是缺页率减小。
OPT是理想情况，效率是最高的。
当然当不缺页时,所有的算法缺页次数都是把所有页调进去的次数。
LＲU算法有时候和FIFO算法的效率差别并不大。
甚至有时候它还比FIFＯ低一些的。
6.2.Belａdy’ｓ aｎｏmalｙ
如下,我稍微改了下输入,手动输入课本上的样例，编程见证了Ｂelａdy异常现。
这是只有FIFO算法才有的异常。
升级会员 