操作系统存储管理实验报告.docx

操作系统存储管理实验报告.docx

《操作系统存储管理实验报告.docx》由会员分享，可在线阅读，更多相关《操作系统存储管理实验报告.docx（14页珍藏版）》请在冰豆网上搜索。

操作系统存储管理实验报告

操作系统实验报告

学号

姓名

年级

2003

班级

填实际班级

机号：

学院机房

时间

4.6-4.13

/4.7-4.14

指导教师

成绩

一、实验题目：

存储管理（该实验为综合性实验，共用8个学时）

二、实验要求：

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

其地址按下述原则生成：

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

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

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

具体的实施方法是：

A.在[0，319]的指令地址之间随机选取一起点M；

B.顺序执行一条指令，即执行地址为M+1的指令；

C.在前地址[0，M+1]中随机选取一条指令并执行，该指令的地址为M’；

D.顺序执行一条指令，其地址为M’+1；

E.在后地址[M’+2，319]中随机选取一条指令并执行；

F.重复A—E，直到执行320次指令。

2、指令序列变换成页地址流，设：

①页面大小为1K；

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

③用户虚存容量为32K。

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

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

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

…………

第310条～第319条指令为第31页（对应虚存地址为[310，319]）；

3、计算并输出下述各种算法（可任选三个）在不同内存容量下的命中率。

A.FIFO先进先出置换算法；

B.LRU最近最久未使用置换算法；

C.OPT最佳置换算法。

D.NUR最近未使用置换算法。

E.LFU最少使用置换算法。

三、总的设计思想、环境语言、工具等

总的设计思想：

1、编写函数计算并输出下述各种算法的命中率

1OPT页面置换算法

OPT所选择被淘汰的页面是已调入内存，且在以后永不使用的，或是在最长时间内不再被访问的页面。

因此如何找出这样的页面是该算法的关键。

可为每个页面设置一个步长变量，其初值为一足够大的数，对于不在内存的页面，将其值重置为零，对于位于内存的页面，其值重置为当前访问页面与之后首次出现该页面时两者之间的距离，因此该值越大表示该页是在最长时间内不再被访问的页面，可以选择其作为换出页面。

2FIFO页面置换算法

FIFO总是选择最先进入内存的页面予以淘汰，因此可设置一个先进先出的忙页帧队列，新调入内存的页面挂在该队列的尾部，而当无空闲页帧时，可从该队列首部取下一个页帧作为空闲页帧，进而调入所需页面。

3LRU页面置换算法

LRU是根据页面调入内存后的使用情况进行决策的，它利用“最近的过去”作为“最近的将来”的近似，选择最近最久未使用的页面予以淘汰。

该算法主要借助于页面结构中的访问时间time来实现，time记录了一个页面上次的访问时间，因此，当须淘汰一个页面时，选择处于内存的页面中其time值最小的页面，即最近最久未使用的页面予以淘汰。

4LFU页面置换算法

LFU要求为每个页面配置一个计数器（即页面结构中的counter），一旦某页被访问，则将其计数器的值加1，在需要选择一页置换时，则将选择其计数器值最小的页面，即内存中访问次数最少的页面进行淘汰。

5NUR页面置换算法

NUR要求为每个页面设置一位访问位（该访问位仍可使用页面结构中的counter表示），当某页被访问时，其访问位counter置为1。

需要进行页面置换时，置换算法从替换指针开始（初始时指向第一个页面）顺序检查处于内存中的各个页面，如果其访问位为0，就选择该页换出，否则替换指针下移继续向下查找。

如果内存中的所有页面扫描完毕未找到访问位为0的页面，则将替换指针重新指向第一个页面，同时将内存中所有页面的访问位置0，当开始下一轮扫描时，便一定能找到counter为0的页面。

2、在主函数中生成要求的指令序列，并将其转换成页地址流；在不同的内存容量下调用上述函数使其计算并输出相应的命中率。

环境语言：

Linux下的GNU编译环境

四、数据结构与模块说明

程序中用到的数据结构、类型定义及主要的函数原型如下：

1、数据结构

（1）页面结构

typedefstruct{

intpn,pfn,counter,time;

}pl_type;

pl_typepl[total_vp];

其中pn为页面号（页号），pfn为页帧号（物理块号），counter为一个周期内访问该页面的次数，time为访问时间；pl[total_vp]为页面结构数组，由于共有320条指令，每页可装入10条指令，因此虚页长total_vp的值为32。

（2）页帧控制结构

structpfc_struct{

intpn,pfn;

structpfc_struct*next;

};

typedefstructpfc_structpfc_type;

pfc_typepfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;

其中pfc[total_vp]定义用户进程的页帧控制结构数组，在该实验中，用户内存工作区是动态变化的，最多可达到用户进程的虚页数目，即32个物理块。

*freepf_head为空闲页帧头的指针

*busypf_head为忙页帧头的指针

*busypf_tail忙页帧尾的指针

2、变量定义

（1）inta[total_instruction]:

指令流数组

（2）intdiseffect:

页面失效次数

（3）intpage[total_instruction]:

每条指令所属页面号

（4）intoffset[total_instruction]:

每页装入10条指令后取模运算得出的页内偏移地址

（5）inttotal_pf:

用户进程的内存页帧数

3、主要函数

（1）voidinitialize（int）:

初始化函数

该函数主要对页面结构数组pl和页帧结构数组pfc进行初始化，如置页面结构中的页面号pn，初始化页帧号pfn为空，访问次数counter为0，访问时间time为-1；同样对页帧数组进行初始化，形成一个空闲页帧队列。

（2）voidOPT（int）:

计算使用最佳页面算法时的命中率

（3）voidFIFO（int）:

计算使用先进先出页面置换算法时的命中率

（4）voidLRU（int）:

计算使用最近最久未使用页面置换算法时的命中率

（5）voidLFU（int）:

计算使用最少使用置换算法时的命中率

（6）voidNUR（int）:

计算使用最近未使用置换算法时的命中率

五、主要算法的设计与实现

voidFIFO（inttotal_pf）/*先进先出页面置换算法*/

{

inti,j;

pfc_type*p;

initialize（total_pf）;

busypf_head=busypf_tail=NULL;

for（i=0;i

{

if（pl[page[i]].pfn==INVALID）/*页面失效*/

{

diseffect=diseffect+1;

if（freepf_head==NULL）/*无空闲页帧*/

{

p=busypf_head->next;

pl[busypf_head->pn].pfn=INVALID;//将忙页帧队首页面作为换出页面

freepf_head=busypf_head;

freepf_head->next=NULL;

busypf_head=p;//忙页帧头指针后移

}

p=freepf_head->next;//有空闲页帧

freepf_head->next=NULL;

freepf_head->pn=page[i];/*将所需页面调入空闲页帧*/

pl[page[i]].pfn=freepf_head->pfn;

if（busypf_tail==NULL）/*若忙页帧队列为空，则将其头尾指针都指向刚调入页面所在的页帧*/

busypf_head=busypf_tail=freepf_head;

else{//否则，将刚调入页面所在的页帧挂在忙页帧队列尾部

busypf_tail->next=freepf_head;

busypf_tail=freepf_head;

}

freepf_head=p;//空闲页帧头指针后移

}

}

printf（"FIFO:

%6.4f",1-（float）diseffect/320）;

}

voidLRU（inttotal_pf）/*最近最久未使用页面置换算法*/

{

inti,j;

intmin,minj,present_time;

initialize（total_pf）;

present_time=0;

for（i=0;i

{

if（pl[page[i]].pfn==INVALID）/*页面失效*/

{

diseffect++;

if（freepf_head==NULL）/*无空闲页帧*/

{

min=32767;

for（j=0;j

if（min>pl[j].time&&pl[j].pfn!

=INVALID）

{

min=pl[j].time;

minj=j;

}

}

freepf_head=&pfc[pl[minj].pfn];//腾出一个单元

pl[minj].pfn=INVALID;

pl[minj].time=-1;

freepf_head->next=NULL;

}

pl[page[i]].pfn=freepf_head->pfn;//有空闲页面,改为有效

pl[page[i]].time=present_time;//修改页面的访问时间

freepf_head=freepf_head->next;//减少一个free页面

}

else

pl[page[i]].time=present_time;//命中则修改该单元的访问时间

present_time++;

}

printf（"LRU:

%6.4f",1-（float）diseffect/320）;

}

voidNUR（inttotal_pf）/*最近未使用页面置换算法*/

{

inti,j,dp,cont_flag,old_dp;

initialize（total_pf）;

dp=0;

for（i=0;i

{

if（pl[page[i]].pfn==INVALID）/*页面失效*/

{

diseffect++;

if（freepf_head==NULL）/*无空闲页帧*/

{

cont_flag=TRUE;

old_dp=dp;

while（cont_flag）

{

if（pl[dp].counter==0&&pl[dp].pfn!

=INVALID）

cont_flag=FALSE;//找到位于内存且未被访问的页面

else

{

dp++;

if（dp==total_vp）dp=0;//将替换指针重新指向第一个页面

if（dp==old_dp）

{/*若内存中所有页面扫描完毕未找到访问位为0的页面，将内存中所有页面的访问位置0*/

for（j=0;j

pl[j].counter=0;

}

}

}

freepf_head=&pfc[pl[dp].pfn];//腾出一个单元

pl[dp].pfn=INVALID;

freepf_head->next=NULL;

}

pl[page[i]].pfn=freepf_head->pfn;//有空闲页面,改为有效

freepf_head=freepf_head->next;//减少一个free页面

}

else

pl[page[i]].counter=1;//命中则将访问位置1

if（i%clear_period==0）//清零周期到，将所有访问位清零

{

for（j=0;j

pl[j].counter=0;

}

}

printf（"NUR:

%6.4f",1-（float）diseffect/320）;

}

voidOPT（inttotal_pf）/*最佳页面置换算法*/

{

inti,j,max,maxpage,d,dist[total_vp];

initialize（total_pf）;

for（i=0;i

{

if（pl[page[i]].pfn==INVALID）/*页面失效*/

{

diseffect++;

if（freepf_head==NULL）/*无空闲页面*/

{

for（j=0;j

{

if（pl[j].pfn!

=INVALID）//所有位于内存页面的距离变量赋一足够大的数

dist[j]=32767;

else//不在内存的页面该变量则置为0

dist[j]=0;

}

d=1;

/*对于位于内存且在当前访问页面之后将再次被访问的页面，dist重置为当前页面与之后首次出现该页面时两者之间的距离*/

for（j=i+1;j

{

if（pl[page[j]].pfn!

=INVALID&&dist[page[j]]==32767）

dist[page[j]]=d;

d++;

}

max=-1;

//查找dist变量值最大的页面作为换出页面

for（j=0;j

{

if（max

max=dist[j];

maxpage=j;

}

}

freepf_head=&pfc[pl[maxpage].pfn];//腾出一个单元

freepf_head->next=NULL;

pl[maxpage].pfn=INVALID;

}

pl[page[i]].pfn=freepf_head->pfn;//有空闲页面,改为有效

freepf_head=freepf_head->next;//减少一个free页面

}

}

printf（"OPT:

%6.4f",1-（float）diseffect/320）;

}

voidLFU（inttotal_pf）/*最少使用页面置换算法*/

{

inti,j,min,minpage;

initialize（total_pf）;

for（i=0;i

{

if（pl[page[i]].pfn==INVALID）//页面失效

{

diseffect++;

if（freepf_head==NULL）//无空闲页帧

{

min=32767;

for（j=0;j

{//查找位于内存且访问次数最少的页面作为换出页面

if（min>pl[j].counter&&pl[j].pfn!

=INVALID）

{

min=pl[j].counter;

minpage=j;

}

pl[j].counter=0;

}

freepf_head=&pfc[pl[minpage].pfn];//腾出一个单元

pl[minpage].pfn=INVALID;

freepf_head->next=NULL;

}

pl[page[i]].pfn=freepf_head->pfn;//有空闲页面,改为有效

pl[page[i]].counter++;//增加页面访问次数

freepf_head=freepf_head->next;//减少一个free页面

}

else

pl[page[i]].counter++;//命中增加页面访问次数

}

printf（"LFU:

%6.4f",1-（float）diseffect/320）;

}

六、源程序

见电子稿（文件名ymzh.c）;

七、运行结果

本实验的运行结果如下图所示（以OPT、FIFO、LRU为例）：

从上述结果可知，随着内存页面数的增加，三种算法的访问命中率逐渐增大。

在内存页面数为4~25个页面之间时，三种算法的命中率大致在56%至88%之间变化，但是，OPT算法和其他两种算法之间的差别一般在6~12个百分点左右。

在内存页面为25~32个页面时，由于用户进程的所有指令基本上都已装入内存，从而命中率增加较大，各种算法之间的差别不大。

比较上述三种算法，OPT算法的命中率最高，LRU算法和FIFO算法的命中率则较为接近。

八、自我评析与总结

（可参考以下内容：

）

1．总的自我打分。

2．你认为你完成的作业哪些地方做得比较好或比较出色。

3．差距与局限，什么地方做得不太好，或什么地方可以做得更好，进一步的工作。

4．从本作业得到的收获。

对编写与调试过程中经验教训的总结。

5．完成本题的其他方法。

6．对实验题的评价和改进意见。

九、参考文献

1．《计算机操作系统教程系统解答与实验指导》第2版，张尧学编著，清华大学出版社，2000年出版

2．《计算机操作系统》修订版，汤子瀛等编著，西安电子科技大学出版社，2003年6月出版

十、教师评语：