实验请求页式存储管理页面置换算法.docx
《实验请求页式存储管理页面置换算法.docx》由会员分享，可在线阅读，更多相关《实验请求页式存储管理页面置换算法.docx（16页珍藏版）》请在冰点文库上搜索。
实验请求页式存储管理页面置换算法
操作系统实验报告
班级:
计科0801班姓名：
韩伟伟学号：
08407106时间：
2018-5-25
实验五请求页式存储管理的页面置换算法
一．实验目的
通过请求页式存储管理中页面置换算法模拟程序，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
二．实验属性
设计
三．实验内容
1.通过随机数产生一个指令序列，共320条指令，指令的地址按下述原则生产：
50％的指令是顺序执行的；
25％的指令是均匀分布在前地址部分；
25％的指令是均匀分布在后地址部分。
2.将指令序列变换成为页地址流
设页面大小为1K；用户内存容量为4页到32页；用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：
第0条至第9条指令为第0页；第10条至19条指令为第1页；…第310条至319条指令为第31页。
3.计算并输出下述各种算法在不同内存容量下的命中率。
（1>先进先出算法（2>最近最少使用算法（3>最佳使用算命中率＝１－页面失效次数／页地址流长度
本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
四．思路
关于随机数的产生办法。
首先要初始化设置随机数，产生序列的开始点，例如，通过下列语句实现：
srand（400>；
（1>计算随机数，产生320条指令序列
m＝160；
for（i＝0；i＜80；i++＝
{
j＝i﹡4；
a[j]＝m；
a[j+1]＝m+1；
a[j+2]＝a[j]﹡1.0﹡rand（>/32767；
a[j+3]＝a[j+2]+1
m＝a[j+3]+（319-a[j+3]>﹡1.0﹡rand（>/32767；
}
（2>将指令序列变换成为页地址流
for（k＝0；k＜320；k++>
{pt＝a[k]/10；
pd=a[k]%10；
…
}
（3>计算不同算法的命中率
rate＝1-1.0﹡U/320；
其中U为缺页中断次数，320是页地址流长度。
（4>输出格式
kfifo1ru
40.230.25
…
321.01.0
五．实验报告
1．写出你编写的C语言程序。
#include
#include
#include
#include
#defineMyprintfprintf（"|---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---|\n">/*表格控制*/
#definebsize4//物理块大小
#definepsize16//进程大小
typedefstructpage
{
intnum。
/*记录页面号*/
inttime。
/*记录调入内存时间*/
}Page。
/*页面逻辑结构，结构为方便算法实现设计*/
Pageb[bsize]。
/*内存单元数*/
intc[bsize][psize]。
/*暂保存内存当前的状态：
缓冲区*/
intqueue[100]。
/*记录调入队列*/
intK。
/*调入队列计数变量*/
intphb[bsize]={0}。
//物理块标号
intpro[psize]={0}。
//进程序列号
intflag[bsize]={0}。
//进程等待次数（存放最久未被使用的进程标志>
inti=0,j=0,k=0。
//i表示进程序列号,j表示物理块号
intm=-1,n=-1。
//物理块空闲和进程是否相同判断标志
intmax=-1,maxflag=0。
//标记替换物理块进程下标
intcount=0。
//统计页面缺页次数
//**************************************************************//
//**************************************************************//随机产生序列号函数
//**************************************************************
int*build（>
{
printf（"随机产生一个进程序列号为：
\n">。
inti=0。
for（i=0。
ii++>
{
pro[i]=10*rand（>/（RAND_MAX+1>+1。
printf（"%d",pro[i]>。
}
printf（"\n">。
return（pro>。
}
//**************************************************************//查找空闲物理块
//**************************************************************
intsearchpb（>
{
for（j=0。
jj++>
{
if（phb[j]==0>
{
m=j。
returnm。
break。
}
}
return-1。
}
//**************************************************************//查找相同进程
//**************************************************************
intsearchpro（>
{
for（j=0。
jj++>
{
if（phb[j]==pro[i]>
{
n=j。
returnj。
}
}
return-1。
}
//**************************************************************//初始化内存
//**************************************************************
voidempty（>
{
for（i=0。
ii++>
phb[i]=0。
count=0。
//计数器置零
}
//**************************************************************//先进先出页面置换算法
//**************************************************************
voidFIFO（>
{
for（i=0。
ii++>
{
m=searchpb（>。
n=searchpro（>。
//找flag值最大的
for（j=0。
jj++>
{
if（flag[j]>maxflag>
{
maxflag=flag[j]。
max=j。
}
}
if（n==-1>//不存在相同进程
{
if（m!
=-1>//存在空闲物理块
{
phb[m]=pro[i]。
//进程号填入该空闲物理块
count++。
flag[m]=0。
for（j=0。
j<=m。
j++>
{
flag[j]++。
}
m=-1。
}
else//不存在空闲物理块
{
phb[max]=pro[i]。
flag[max]=0。
for（j=0。
jj++>
{
flag[j]++。
}
max=-1。
maxflag=0。
count++。
}
}
else//存在相同的进程
{
phb[n]=pro[i]。
for（j=0。
jj++>
{
flag[j]++。
}
n=-1。
}
for（j=0。
jj++>
{
printf（"%d",phb[j]>。
}
printf（"\n">。
}
printf（"缺页次数为：
%d\n",count>。
printf（"\n">。
}
//**************************************************************
//**************************************************************
/*初始化内存单元、缓冲区*/
voidInit（Page*b,intc[bsize][psize]>
{
inti,j。
for（i=0。
ii++>
{
b[i].num=-1。
b[i].time=psize-i-1。
}
for（i=0。
ii++>
for（j=0。
jj++>
c[i][j]=-1。
}
/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/
intGetMax（Page*b>
{
inti。
intmax=-1。
inttag=0。
for（i=0。
ii++>
{
if（b[i].time>max>
{
max=b[i].time。
tag=i。
}
}
returntag。
}
/*判断页面是否已在内存中*/
intEquation（intfold,Page*b>
{
inti。
for（i=0。
ii++>
{
if（fold==b[i].num>
returni。
}
return-1。
}
/*LRU核心部分*/
voidLruu（intfold,Page*b>
{
inti。
intval。
val=Equation（fold,b>。
if（val>=0>
{
b[val].time=0。
for（i=0。
ii++>
if（i!
=val>
b[i].time++。
}
else
{
queue[++K]=fold。
/*记录调入页面*/
val=GetMax（b>。
b[val].num=fold。
b[val].time=0。
for（i=0。
ii++>
if（i!
=val>
b[i].time++。
}
}
voidLRU（>
{
inti,j。
K=-1。
Init（b,c>。
for（i=0。
ii++>
{
Lruu（pro[i],b>。
c[0][i]=pro[i]。
/*记录当前的内存单元中的页面*/
for（j=0。
jj++>
c[j][i]=b[j].num。
}
/*结果输出*/
printf（"内存状态为：
\n">。
Myprintf。
for（j=0。
jj++>
printf（"|%2d",pro[j]>。
printf（"|\n">。
Myprintf。
for（i=0。
ii++>
{for（j=0。
jj++>
{
if（c[i][j]==-1>
printf（"|%2c",32>。
else
printf（"|%2d",c[i][j]>。
}
printf（"|\n">。
}
Myprintf。
printf（"\n调入队列为:
">。
for（i=0。
ii++>
printf（"%3d",queue[i]>。
printf（"\n缺页次数为：
%6d\n缺页率：
%16.6f",K+1,（float>（K+1>/psize>。
}
//**************************************************************//主函数
//**************************************************************
voidmain（>
{
intsel。
do{
printf（"\t\t\t--------------------------------------\t\t\t">。
printf（"\t\t\t☆☆^-^欢迎进入操作系统界面^-^☆☆\t\t\t">。
printf（"\t\t\t--------------------------------------\t\t\t\n">。
printf（"\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\t\t\t">。
printf（"\t\t\t☆虚拟内存☆\t\t\t">。
printf（"\t\t\t☆--------------------------------☆\t\t\t">。
printf（"\t\t\t☆1、产生随机序列☆\t\t\t">。
printf（"\t\t\t☆--------------------------------☆\t\t\t">。
printf（"\t\t\t☆2、最久未使用（LRU>☆\t\t\t">。
printf（"\t\t\t☆--------------------------------☆\t\t\t">。
printf（"\t\t\t☆3、先进先出（FIFO>☆\t\t\t">。
printf（"\t\t\t☆--------------------------------☆\t\t\t">。
printf（"\t\t\t☆4、最佳置换算法（OPT>☆\t\t\t">。
printf（"\t\t\t☆--------------------------------☆\t\t\t">。
printf（"\t\t\t☆5、三种算法的比较（>☆\t\t\t">。
printf（"\t\t\t☆--------------------------------☆\t\t\t">。
printf（"\t\t\t☆0、退出（Exit>☆\t\t\t">。
printf（"\t\t\t☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆\t\t\t\n">。
printf（"请选择所要执行的操作（0/1/2/3/4/5>:
">。
scanf（"%d",&sel>。
switch（sel>
{
case0:
printf（"\t\t\t^-^再见！
^-^\t\t\t\n">。
system（"pause">。
break。
case1:
build（>。
break。
case2:
printf（"最久未使用算\n">。
LRU（>。
empty（>。
printf（"\n">。
break。
case3:
printf（"先进先出算\n">。
FIFO（>。
empty（>。
printf（"\n">。
break。
case5:
printf（"先进先出算法\n">。
FIFO（>。
empty（>。
printf（"最久未使用算法\n">。
LRU（>。
empty（>。
break。
default:
printf（"请输入正确的选项号！
">。
printf（"\n\n">。
break。
}
}while（sel!
=0>。
}
产生的随机序列：
最近最少使用算法执行结果如下：
先进先出FIFO算法执行结果：
2．总结体会请求页式存储管理的实现原理。
请求页式管理的基本原理是将逻辑地址空间分成大小相同的页，将存储地址空间分块，页和块的大小相等，通过页表进行管理。
页式系统的逻辑地址分为页号和页内位移量。
页表包括页号和块号数据项，它们一一对应。
根据逻辑空间的页号，查找页表对应项找到对应的块号，块号乘以块长，加上位移量就行成存储空间的物理地址。
每个作业的逻辑地址空间是连续的，重定位到内存空间后就不一定连续了。
3.写出这三种页面置换算法的实现思想。
FIFO算法总是淘汰最先调入主存的页面，即淘汰在主存中驻留时间最长的页面，认为驻留时间最长的页不再使用的可能性较大。
LRU算法淘汰的页面是最近一段时间内最久未被访问的那一页，它是基于程序局部性原理来考虑的，认为那些刚被使用过的页面可能还要立即被使用，而那些在较长时间内未被使用的页面可能不会立即使用。
OPT算法，当要调入一页而必须淘汰旧页时，应该淘汰以后不再访问的页，或距现在最长时间后要访问的页面。
4．对不同算法的性能进行评价。
FIFO算法较易实现，对具有线性顺序特征的程序比较适用，而对具有其他特征的程序则效率不高，此算法还可能出现抖动现象LRU算法基于程序的局部性原理，所以适用用大多数程序，此算实现必须维护一个特殊的队列——页面淘汰队列。
OPT算法虽然产生的缺页数最少，然而，却需要预测程序的页面引用串，这是无法预知的，不可能对程序的运行过程做出精确的断言，不过此理论算法可用做衡量各种具体算法的标准。
升级会员 