请求调页存储管理方式的模拟NRU.docx

请求调页存储管理方式的模拟NRU.docx

《请求调页存储管理方式的模拟NRU.docx》由会员分享，可在线阅读，更多相关《请求调页存储管理方式的模拟NRU.docx（7页珍藏版）》请在冰豆网上搜索。

请求调页存储管理方式的模拟NRU

请求调页存储管理方式的模拟NRU

 #include  

#include  

#include  

#ifndef _UNISTD_H 

#define _UNISTD_H 

#include  

#include  

#endif 

 #define TRUE 1 

#define FALSE 0 

#define INVALID -1 

#define NULL 0 

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

#define total_vp 32 /*虚页长*/ 

#define clear_period 50 /*清0周期*/ 

 typedef struct /*页面结构*/ 

{ 

int pn,pfn,counter,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]; 

intinitialize（int）;

intNUR（int）

int main（ ） 

{ 

 int s,i,j; 

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

s=（float）319*rand（ ）/32767/32767/2+1; // 

for（i=0;i

{ 

if（s<0||s>319） 

 { 

printf（"When i==%d,Error,s==%d\n",i,s）; 

 exit（0）;

 } 

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

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

 a[i+2]=（float）a[i]*rand（ ）/32767/32767/2; /*执行前地址指令m' */ 

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

 s=（float）（318-a[i+2]）*rand（ ）/32767/32767/2+a[i+2]+2; 

if（（a[i+2]>318）||（s>319）） 

 printf（"a[%d+2],a number which is :

%d and s==%d\n",i,a[i+2],s）; 

 } 

for （i=0;i

{

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

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

} 

for（i=4;i<=32;i++） /*用户内存工作区从4个页面到32个页面*/ 

{ 

printf（"---%2d page frames---\n",i）; 

NUR（i）; 

 }  

return 0; 

} 

 int initialize（total_pf） /*初始化相关数据结构*/ 

int total_pf; /*用户进程的内存页面数*/ 

{int i; 

diseffect=0; 

for（i=0;i

{ 

pl[i].pn=i; 

 pl[i].pfn=INVALID; /*置页面控制结构中的页号，页面为空*/ 

 pl[i].counter=0; 

 pl[i].time=-1; /*页面控制结构中的访问次数为0，时间为-1*/ 

} 

for（i=0;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]*/ 

return 0; 

} 

int NUR（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

{ 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） 

 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; 

 } 

else 

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

 if（i%clear_period==0） 

for（j=0;j

pl[j].counter=0; 

} 

printf（"NUR:

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

 return 0; 

} 

1．设计目的

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

2．设计内容

1）假设每个页面中可存放10条指令，分配给作业的内存块数为4。

2）用C语言模拟一个作业的执行过程，该作业共有320条指令，即它的地址空间为32页，目前它的所有页都还未调入内存。

在模拟过程中，如果所访问的指令已在内存，则显示其物理地址，并转下一条指令。

如果所访问的指令还未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。

如果4个内存块均已装入该作业，则需进行页面置换，最后显示其物理地址，并转下一条指令。

在所有320指令执行完毕后，请计算并显示作业运行过程中发生的缺页率。

3）置换算法：

最近最不经常使用（NRU）算法。

提示:

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

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

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

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

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

具体的实施方法是：

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

②顺序执行一条指令，即执行地址为m+1的指令；

③在前地址[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页。

（3）计算最近最不经常使用（NRU）算法在不同内存容量下的命中率。

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