实验五存储管理实验报告

计算机与信息技术学院综合性实验报告

一、实验目的

通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式管理的页面置换算法。

二、实验仪器或设备

微型计算机、Linux操作系统、dev C++

三、总体设计

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]）；

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

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

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

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

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

命中率=1-页面失效次数/页地址流长度

在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。

4、相关定义

(1)数据结构

○1页面类型

typedef struct /*页面结构*/

{

int pn,pfn,time;

}pl_type;

其中pn为页面号，pfn为页帧号，time为访问时间

○2页帧控制结构

struct pfc_struct{ /*页帧控制结构*/

int pn,pfn;

struct pfc_struct *next;

};

typedef struct pfc_struct pfc_type;

pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;

其中pfc_type pfc[total_vp]定义用户进程虚页控制结构

*freepf_head为空闲页帧头的指针

*busypf_head为忙页帧头的指针

*busypf_tail忙页帧尾的指针

(2)函数定义

void initialize(int):初始化函数

void FIFO(int):计算使用FIFO算法时的命中率

void LRU(int):计算使用LRU算法时的命中率

void NRU(int):计算使用NRU算法时的命中率

(3)变量定义

int a[total_instruction]:指令流数组

int diseffect:页面失效次数

int page[total_instruction]:每条指令所属页面号

int offset[total_instruction]:每页装入10条指令后取模运算得出的页内偏移地址

int total_pf:用户进程的内存页面数

四、实验步骤

按照流程图编写代码、并上机调试运行

程序代码：

#include <stdlib.h>

#include <stio.h>

#define TRUE 1

#define FALSE 0

#define INVALID -1

#define total_instruction 320 /*指令流长*/

#define total_vp 32 /*虚页长*/

typedef struct /*页面结构*/

{

int pn,pfn,time;

}pl_type;

pl_type pl[total_vp]; /*页帧结构数组*/

struct pfc_struct{ /*页帧控制结构*/

int pn,pfn;

struct pfc_struct *next;

};

typedef struct pfc_struct pfc_type;

pfc_type pfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;

int diseffect,a[total_instruction];

int page[total_instruction],offset[total_instruction];

void initialize(int);

void FIFO(int);

void LRU(int);

void NRU(int);

int main( )

{

int s,i;

/*由于每次运行时进程号不同，故可用来作为初始化随机数队列的“种子”*/ srand(10*getpid());

s=(float)319*rand( )/RAND_MAX+1;

for(i=0;i<total_instruction;i+=4) /*产生指令队列*/

{

a[i]=s; /*任选一指令访问点m*/

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

a[i+2]=(float)a[i]*rand( )/RAND_MAX; /*执行前地址指令m' */

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

s=(float)(318-a[i+2])*rand( )/RAND_MAX+a[i+2]+2;

}

for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/

{

page[i]=a[i]/10;

offset[i]=a[i]%10;

}

for(i=4;i<=32;i++) /*用户内存工作区从4个页帧到32个页帧*/

{

printf("%2d page frames ",i);

void FIFO(int);

void LRU(int);

void NRU(int);

printf("\n");

}

}

void initialize(int total_pf) /*初始化相关数据结构*/ {

int i;

diseffect=0;

for(i=0;i<total_vp;i++)

{ pl[i].pn=i;

pl[i].pfn=INVALID;

pl[i].time=-1;

}

for(i=0;i<total_pf-1;i++)

{ pfc[i].next=&pfc[i+1];

pfc[i].pfn=i;

} /*建立pfc[i-1]和pfc[i]之间的链接*/

pfc[total_pf-1].next=NULL;

pfc[total_pf-1].pfn=total_pf-1;

freepf_head=&pfc[0]; /*空页面队列的头指针为pfc[0]*/ }

void FIFO(int total_pf) /*先进先出算法*/

int total_pf; /* 用户进程的内存页面数 */ { int i,j;

pfc_type *p, *t;

initialize(total_pf); /* 初始化相关页面控制用数据结构*/ busypf_head=busypf_tail=NULL: /* 忙页面队列头,队列尾链接 */

for(i=0;i=total_instruction;i++)

{ if(p1[page[i]].pfn= =INVALID） /* 页面失效 */

{ disaffect+=1； /* 失效次数 */

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

{ p=busypf_head->next;

p1[busypf_head->pn].pfn=INVALID;

freepf_head=busypf_head; /*释放忙页面队列中的第一个页面*/ freepf_head->next=NULL:

busypf_head=p;

}

p=freepf_head->next; /* 按FIFO方式调新页面入内存页面 */ freepf_head->next=NULL:

freepf_head->pn=page[i];

p1[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)disaffect/320);

}

void LRU (int total_pf) /*最近最久未使用算法*/

int total_pf;

{ int min,minj,i,j,present_time;

initialize(total_pf);

present_time=0;

for(i=0;i<total_instruction;i++)

{ if(p1[page[i]].pfn= =INVALID) /* 页面失效 */ { disaffect++;

if(freepf_head= =NULL) /* 无空闲页面 */ { min=32767;

for(j=0;j<total_vp;j++)

if(min>p1[j].time&&p1[j].pfn !=INVALID)

{ min=p1[j].time;minj=j;

}

freepf_head=&pfc[p1[minj].pfn];

p1[minj].pfn=INVALID;

p1[min].time=-1;

freepf_head->next=NULL;

}

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

p1[page[i]].time=present_time;

freepf_head=freepf_head->next;

}

else

p1[page[i]].time=present_time;

present_time++;

}

printf(“LRU:%6.4f”,1-(flaot)disaffect/320);

}

void NRU(int total_pf) /*最近未使用置换算法*/ int total_pf;

{ int i,j,dp,cont_flag,old_dp;

pfc_type *t;

initialize(total_pf);

dp=0;

for(i=0;i<total_instruction;i++)

{ if(p1[page[i]].pfn= =INVALID) /* 页面失效 */ { diseffect++;

if(freepf_head= =NULL) /* 无空闲页面 */ { cont_flag=TRUE;

old_dp=dp;

while(cont_flag)

if(p1[dp].counter= =0 && p1[dp].pfn!=INVALID)

cont_flag=FLASE;

else

{ dp++;

if(dp= =total_vp)

dp=0;

if(dp= =old_dp)

for(j=0;j<total_vp;j++)

p1[j].counter=0;

}

freepf_head=&pfc[p1[dp].pfn];

p1[dp].pfn=INVALID;

freepf_head->next=NULL:

}

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

freepf_head=freepf_head->next;

}

else

p1[page[i]].counter=1;

if(i%clear_period= =0)

for(j=0;j<total_vp;j++)

p1[j].counter=0;

}

printf(“NUR:%6.4f”,1-(float)disaffect/320);

}

void OPT(total_pf)

int total_pf;

{ int i,j,max,maxpage,d,dist[total_vp];

pfc_type *t;

initialize(total_pf);

for(i=0;i<total_instruction;i++)

{ if(p1[page[i]].pfn= =INVALID)

{ diseffect++;

if(freepf_head= =NULL)

{ for(j=0;j<total_vp;j++)

if(p1[j].pfn !=INVALID)

dist[j]=32767;

else

dist[j]=0;

d=1;

for(j=i+1;j<total_instruction;j++)

{ if(p1[page[j]].pfn!=INVALID)

dist[page[j]]=d;

d++;

}

max=-1;

for(j=0;j<total_vp;j++)

if(max<dist[j])

{ max=dist[j];

maxpage=j;

}

freepf_head=&pfc[p1[maxpage].pfn];

freepf_head->next=NULL;

p1[maxpage].pfn=INVALID;

}

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

freepf_head=freepf_head->next;

}

}

printf(“OPT:%6.4f”,1-(float)disaffect/320);

}

显示结果：

4 page frames FIFO:0.4969 LRU:0.5000 NUR:0.5000

5 page frames FIFO:0.5188 LRU:0.5125 NUR:0.5062

6 page frames FIFO:0.5281 LRU:0.5188 NUR:0.5344

7 page frames FIFO:0.5406 LRU:0.5500 NUR:0.5562

8 page frames FIFO:0.5500 LRU:0.5719 NUR:0.5531

9 page frames FIFO:0.5625 LRU:0.5812 NUR:0.5781

10 page frames FIFO:0.5844 LRU:0.5969 NUR:0.5969

11 page frames FIFO:0.5938 LRU:0.6094 NUR:0.6250

12 page frames FIFO:0.6156 LRU:0.6281 NUR:0.6594

13 page frames FIFO:0.6375 LRU:0.6344 NUR:0.6500

14 page frames FIFO:0.6844 LRU:0.6625 NUR:0.6500

15 page frames FIFO:0.6844 LRU:0.6812 NUR:0.6875

16 page frames FIFO:0.7062 LRU:0.7062 NUR:0.7094

17 page frames FIFO:0.7094 LRU:0.7125 NUR:0.7250

18 page frames FIFO:0.7188 LRU:0.7281 NUR:0.7344

19 page frames FIFO:0.7281 LRU:0.7531 NUR:0.7531

20 page frames FIFO:0.7281 LRU:0.7656 NUR:0.7594

21 page frames FIFO:0.7812 LRU:0.7781 NUR:0.7906

22 page frames FIFO:0.7875 LRU:0.7937 NUR:0.8125

23 page frames FIFO:0.7960 LRU:0.8094 NUR:0.8187

24 page frames FIFO:0.8000 LRU:0.8219 NUR:0.8219

25 page frames FIFO:0.8344 LRU:0.8312 NUR:0.8344

26 page frames FIFO:0.8625 LRU:0.8438 NUR:0.8594

27 page frames FIFO:0.8625 LRU:0.8652 NUR:0.8781

28 page frames FIFO:0.8750 LRU:0.8656 NUR:0.8812

29 page frames FIFO:0.8844 LRU:0.8781 NUR:0.8812

30 page frames FIFO:0.8875 LRU:0.8875 NUR:0.8906

31 page frames FIFO:0.8875 LRU:0.8906 NUR:0.9000

32 page frames FIFO:0.9000 LRU:0.9000 NUR:0.9000

五、结果分析与总结

从上述结果可知，当内存页面数较少（4~5页面）时，5种算法的命中率差别不大，都是50%左右。当内存页面为7~25个页面之间时，5种算法的访问命中率大致在52%至87%之间变化。但是，FIFO算法与OPT算法之间的差别一般在6~10个百分点左右。当内存页面为25~32个页面时，由于用户进程的所有指令基本上都已装入内存，从而命中率已增加较大。从而算法之间的差别不大。

比较上述3种算法，以NUR算法的命中率最高，LRU算法次之，最后是FIFO算法。通过本次综合性实验，我对存储器管理有了更深一步的学习，同时将这几种算法比较分析，提高自己分析问题和解决问题的能力。

教师签名：

年月日

本文来源：https://www.bwwdw.com/article/f2gi.html