0303130缪广东.docx

0303130缪广东.docx

《0303130缪广东.docx》由会员分享，可在线阅读，更多相关《0303130缪广东.docx（20页珍藏版）》请在冰豆网上搜索。

0303130缪广东

目录

一、设计目的1

二、设计内容1

三、设计原理1

四、算法实现2

五、流程图3

六、源程序7

七、运行示例及结果分析12

八、心得体会15

九、参考资料16

模拟请求页式管理

1、设计目的

1.通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点。

2.通过对页面、页表、地址转换和页面置换过程的模拟，加深对请求调页系统的原理和实现过程的理解。

3.掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。

2、设计内容

计算并输出下述各种算法在不同内存容量下的命中率。

1.先进先出的算法（FIFO）；

2.最近最久未使用算法（LUR）；

3.最佳访问算法（Optimal）；

命中率＝１－页面失效次数／页地址流长度

三、设计原理

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

指令的地址按下述原则生成：

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

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

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

具体的实施方法是：

①在[0，319]的指令地址之间随机选取一起点m

②顺序执行一条指令

③在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’

④顺序执行一条指令，其地址为m’+1

⑤在后地址[m’+2，319]中随机选取一条指令并执行

⑥重复步骤②~⑤，直到执行320次指令

2.将指令序列变换为页地址流

设：

①页面大小为1K；

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

③用户虚存容量为32K。

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

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

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

┇

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

按以上方式，用户指令可组成32页。

4、算法实现

1.数据结构

structpage{//页面结构体

intpage_num;//页面序号

inttime;//上次访问时间

intflag;//页面是否在内存中的标识

intmemory_num;//页面在内存中的序号

structpage*next;//指向下一页面的指针

};

2.常量与全局变量

#defineMAX_INSTRUCTION320//指令流的长度为320

#defineMAX_PAGE32//虚存中页的长度为32

interror_num;//页面失效计数器

intorder[MAX_INSTRUCTION];//随机指令序列数组

intpnum[MAX_INSTRUCTION];//指令对应的页面号

3.函数

intInit（int）;//初始化函数

intFIFO（int）;//先进先出算法函数

intLUR（int）;//最近最久未使用算法函数

intOptimal（int）;//最佳访问算法函数

五、流程图

六、源程序

#include

#include

#include

#defineMAX_INSTRUCTION320//指令流的长度为320

#defineMAX_PAGE32//虚存中页的长度为32

structpage{//页面结构体

intpage_num;//页面序号

inttime;//上次访问时间

intflag;//页面是否在内存中的标识

intmemory_num;//页面在内存中的序号

structpage*next;//指向下一页面的指针

};

structpagep[MAX_PAGE],//页面数组

*free_head,//指向内存中空闲页面的头指针

*in_head,//指向内存中忙碌页面的头指针

*in_tail;//指向内存中忙碌页面的尾指针

intInit（int）;//函数声明

intFIFO（int）;

intLUR（int）;

intOptimal（int）;

interror_num;//页面失效计数器

intorder[MAX_INSTRUCTION];//随机指令序列数组

intpnum[MAX_INSTRUCTION];//指令对应的页面号

//主函数

intmain（）{

intn,i;

srand（（unsigned）time（NULL））;//使得种子为一个不固定的数

printf（"******************|随机产生指令序列|*********************\n"）;

printf（"---------------------------------------------------------\n"）;

n=（int）（（float）（MAX_INSTRUCTION-1）*（rand（）/（RAND_MAX+1.0）））;//随机选取一条指令起点m

for（i=0;i

{

order[i]=n;

order[i+1]=order[i]+1;//顺序执行一条指令

order[i+2]=（int）（（float）order[i]*（rand（）/（RAND_MAX+1.0）））;//随机选取并执行指令m'

order[i+3]=order[i+2]+1;//顺序执行一条指令

printf（"|%6d\t%12d\t%12d\t%12d\t|\n",order[i],order[i+1],order[i+2],order[i+3]）;

n=（int）（（float）（MAX_INSTRUCTION-1-order[i+2]-2）*（rand（）/（RAND_MAX+1.0）））+order[i+2]+2;

}

printf（"---------------------------------------------------------\n"）;

for（i=0;i

pnum[i]=order[i]/10;

printf（"\n***********不同内存容量下各种置换算法的命中率************\n"）;

printf（"---------------------------------------------------------\n"）;

printf（"\tPage\tFIFO\tLUR\tOptimal|\n"）;

for（i=4;i<=32;i++）//内存中不同页数对应的各个置换算法的命中率

{

printf（"|页数：

%3d\t",i）;

FIFO（i）;

LUR（i）;

Optimal（i）;

printf（"\n"）;

}

printf（"---------------------------------------------------------\n"）;

return0;

}

intInit（intcurrent_num）{//初始化函数

inti;

error_num=0;

for（i=0;i

{

p[i].page_num=i;

p[i].time=-1;

p[i].flag=-1;

}

for（i=0;i

{

p[i].next=&p[i+1];

p[i].memory_num=i;

}

p[current_num-1].next=NULL;

p[current_num-1].memory_num=current_num-1;

free_head=&p[0];//初始化闲页面的头指针

in_head=in_tail=NULL;//初始化忙碌页面的头尾指针

return0;

}

intFIFO（intcurrent_num）{//先进先出算法

inti;

page*q;

Init（current_num）;

for（i=0;i

{

if（p[pnum[i]].flag==-1）//页面不在内存中

{

error_num++;

if（free_head==NULL）//没有空闲页面

{

q=in_head->next;//保留忙碌头指针的下一个页面

p[in_head->page_num].flag=-1;//释放忙碌头指针

free_head=in_head;//忙碌头指针成为空闲头指针

free_head->next=NULL;

in_head=q;//忙碌头指针指向原头指针的下一页面

}

q=free_head->next;//保留空闲头指针的下一个页面

free_head->next=NULL;

free_head->page_num=pnum[i];//将空闲头指针的页面序号置为当前页号

p[pnum[i]].memory_num=free_head->memory_num;//将当前页面放入内存

p[pnum[i]].flag=1;//修改标识

if（in_head==NULL&&in_tail==NULL）//如果为第一条指令对应的页面

in_head=in_tail=free_head;

else

{

in_tail->next=free_head;//修改忙碌尾指针

in_tail=free_head;

}

free_head=q;//修改空闲头指针

}

}

printf（"%6.4f\t",1-（float）error_num/320）;//计算并输出命中率

return0;

}

intLUR（intcurrent_num）{//最近最久未使用算法

inti,j,min_time,min_pnum,current_time=0;

Init（current_num）;

for（i=0;i

{

if（p[pnum[i]].flag==-1）//页面不在内存中

{

error_num++;

if（free_head==NULL）//没有空闲页面

{

min_time=400;

for（j=0;j

if（p[j].time

=-1）

{

min_time=p[j].time;

min_pnum=j;

}

}

free_head=&p[p[min_pnum].memory_num];//释放上次访问时间最小的页面并修改相应的值

p[min_pnum].flag=-1;

p[min_pnum].time=-1;

free_head->next=NULL;

}

p[pnum[i]].flag=1;//将当前页面放入内存并修改相应的值

p[pnum[i]].memory_num=free_head->memory_num;

p[pnum[i]].time=current_time;

free_head=free_head->next;//空闲头指针指向下一页面

}

else

p[pnum[i]].time=current_time;//如果页面在内存中则更新其访问时间

current_time++;//时间递增

}

printf（"%6.4f",1-（float）error_num/320）;//计算并输出命中率

return0;

}

intOptimal（intcurrent_num）//最佳访问算法

{

inti,j,max_dis,max_num,d,dis[MAX_PAGE];//页面就上次访问的距离数组

Init（current_num）;

for（i=0;i

{

if（p[pnum[i]].flag==-1）//页面不在内存中

{

error_num++;

if（free_head==NULL）//没有空闲页面

{

for（j=0;j

{

if（p[j].flag!

=-1）

dis[j]=400;//将在内存中的页面的距离值置为400

else

dis[j]=0;//将不在内存中的页面的距离值置为0

}

d=1;

for（j=i+1;j

{//查找当前页面后所有页面在内存中且距离值置为400的页面并更新距离值

if（p[pnum[j]].flag!

=-1&&dis[pnum[j]]==400）

{

dis[pnum[j]]=d;

d++;

}

}

max_dis=-1;

for（j=0;j

{

if（max_dis

{

max_dis=dis[j];

max_num=j;

}

}//将距离值最大的页面释放并修改相应的值

free_head=&p[p[max_num].memory_num];

free_head->next=NULL;

p[max_num].flag=-1;

}//将当前指令对应的页面放入内存并修改相应的值

p[pnum[i]].memory_num=free_head->memory_num;

p[pnum[i]].flag=1;

free_head=free_head->next;//空闲头指针指向下一页面

}

}

printf（"%6.4f\t|",1-（float）error_num/320）;//计算并输出命中率

return0;

}

7、运行示例及结果分析

1.

运行结果

图2.1随机指令序列

（1）

图2.2随机指令序列

（2）

图2.3在不同内存容量下各个算法的命中率

2.结果分析

通过查阅资料了解到从理论上讲，三种页面替换算法的命中率高低顺序是Optimal>LUR>FIFO。

但是通过对实验数据结果的观察分析可以得到，Optimal算法的命中率明显高于LUR算法和FIFO算法的命中率，而LUR算法和FIFO算法两者的命中率十分接近，LUR算法的命中率只是略高于FIFO算法的命中率，当内存页面数较低时更是出现LUR算法的命中率低于FIFO算法的命中率的情况。

通过对程序的分析得出原因是由于指令流产生的方式为：

50%的指令是顺序执的，25%的指令是均匀分布在前地址部分，25%的指令是均匀分布在后地址部分。

这样的指令流产生方式可能存在局限性。

同时，指令的数量只有320条，不能较准确的得到理想结果。

并且当内存页数越大时三种页面置换算法的命中率都为接近0.9000。

八、心得体会

在刚开始选择课程设计的题目时，由于比较喜欢算法方面的知识，于是选择了页面置换算法的命中率计算这一课题。

在设计初期，对于FIFO,LUR,Optimal三种算法的实现还不太了解。

了解的程度只是局限于上课时老师讲授的在几页的环境下的页面置换和命中率计算，而这次课程设计是要求使用程序代码来实现。

于是经过自己查阅资料和参考网络上的算法程序，终于完成了三种算法的实现以及其页面置换的原理和命中率的计算。

首先，题目要求通过随机数来产生320条指令序列，由于对C语言的随机数产生函数不是很了解，在经过查阅资料后学会了通过srand（）函数和rand（）函数来产生随机数。

其次是将指令序列转换为页地址流，根据题目要求将每条指令除以10得到的数即为其对应的页面序号。

最后，通过流程图来设计FIFO,LUR,Optimal算法的实现代码。

FIFO算法置换页面的原则是先进先出，即当内存中没有空闲页面时将替换掉最早放入内存的页面。

LUR算法置换页面的原则是最近最久未使用，即当内存中没有空闲页面时将替换掉内存中最近没有访问的页面。

Optimal算法置换页面的原则是最佳访问，即当内存中没有空闲页面时，通过计算内存中的页面下次访问时的位置距离当前指令的距离，将替换掉距离最大的页面。

通过本次课程设计的分析设计过程，我对请求页式存储管理的页面置换算法有了更为深刻的理解，并通过编写程序实现了FIFO,LUR,Optimal算法以及对三种算法对应的命中率进行了计算和比较。

九、参考资料

[1].汤小丹，梁红兵，哲凤屏，汤子瀛．计算机操作系统（第三版）．西安电子科技大学出版社，2007039199