操作系统 实验4 存储管理.

1、实验目的

存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。

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

2、实验指导

（1）通过随机数产生一个指令序列，共320条指令。指令的地址按下述原则生成： ①50%的指令是顺序执行的；

②50%的指令是均匀分布在前地址部分； ③50%的指令是均匀分布在后地址部分。 具体的实施方法是：

①在 [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条指令为第一页（对应虚存地址为[10，19]）； … …

第310条~第319条指令为第31页（对应虚地址为[310，319]）。 按以上方式，用户指令可组成32页。

（3）计算并输出下述各种算法在不同内存容量下的命中率。 ①先进先出的算法（FIFO）； ②最近最少使用算法（LRR)；

③最佳淘汰算法（OPT）先淘汰最不常用的页地址； ④最少访问页面算法（LFR）； ⑤最近最不经常使用算法（NUR）。 其中③和④为选择内容。

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

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

随机数产生办法，Linux或UNIX系统提供函数strand()和rand(),分别进行初始化和产生随机数。例如： strand ();

语句可初始化一个随机数； a[0]=10*rand()/65535*319+1; a[1]=10*rand()/65535*a[0];

语句可用来产生a[0]与a[1]中的随机数。

[实验内容]

<任务>

设计一个虚拟存储区和内存工作区,并使用下列算法计算访问命中率.

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

（2） 最近最少使用的算法（LRU） （3） 最佳淘汰算法(OPT) （4） 最少访问页面算法(LFU) （5） 最近最不经常使用算法(NUR)

命中率=(1-页面失效次数)/页地址流长度 <程序设计〉

本实验的程序设计基本上按照实验内容进行。即首先用srand()和rand()函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。相关定义如下： 1 数据结构

(1)页面类型 typedef struct{

int pn,pfn,counter,time; }pl-type;

其中pn 为页号,pfn为面号, counter为一个周期内访问该页面的次数, time为访问时间. (2) 页面控制结构 pfc-struct{

int pn,pfn;

struct pfc_struct *next; }

typedef struct pfc_struct pfc_type;

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

其中pfc[total_vp]定义用户进程虚页控制结构, *freepf_head为空页面头的指针, *busypf_head为忙页面头的指针, *busypf_tail为忙页面尾的指针. 2．函数定义

（1）Void initialize( ):初始化函数,给每个相关的页面赋值. （2）Void FIFO( ):计算使用FIFO算法时的命中率. （3）Void LRU( ):计算使用LRU算法时的命中率. （4）Void OPT( ):计算使用OPT算法时的命中率. （5）Void LFU( ):计算使用LFU算法时的命中率. （6）Void NUR( ):计算使用NUR算法时的命中率. 3.变量定义

(1)int a[total_instruction]: 指令流数据组.

(2)int page[total_instruction]: 每条指令所属的页号.

(3)int offset[total_instruction]: 每页装入10条指令后取模运算页号偏移值. (4)int total_pf: 用户进程的内存页面数. (5)int disaffect: 页面失效次数. 4.程序参考源码及结果 <程序>

#include #include #include

#define TRUE 1 #define FALSE 0 #define INVALID -1 #define NUL 0

#define total_instruction 320 /*指令流长*/ #define total_vp 32 /*虚页长*/ #define clear_period 50 /*清零周期*/

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]; void initialize(); void FIFO(); void LRU();

void OPT(); void LFU(); void NUR();

int main() {

int S,i;

srand((int)getpid());

S=(int)rand()%390;

for(i=0;ia[i]=S; /* a[i+1]=a[i]+1; /* a[i+2]=(int)rand()%390; /* a[i+3]=a[i+2]+1; /* S=(int)rand()%390; }

for(i=0;ipage[i]=a[i]/10; offset[i]=a[i]%10; }

for(i=4;i<=32;i++) /*页面*/ {

printf(\"%2d page frames\ FIFO(i); LRU(i); OPT(i); LFU(i); NUR(i);

printf(\"\\n\"); }

return 0; }

void FIFO(total_pf) /*FIFO(First int total_pf; /*{

int i;

pfc_type *p, *t;

initialize(total_pf); /*产生指令队列*/ 任选一指令访问点*/ 顺序执行一条指令*/ 执行前地址指令m’*/

执行后地址指令*/ 将指令序列变换成页地址流*/ 用户内存工作区从4个页面到32个in First out)ALGORITHM*/ 用户进程的内存页面数*/ 初始化相关页面控制用数据结构*/

busypf_head=busypf_tail=NUL; /*忙页面队列头，对列尾链接*/ for(i=0;iif(pl[page[i]].pfn==INVALID) /*页面失效*/ {

diseffect+=1; /*失效次数*/ if(freepf_head==NUL) /*无空闲页面*/ {

p=busypf_head->next;

pl[busypf_head->pn].pfn=INVALID; /*释放忙页面队列中的第一个页面*/

freepf_head=busypf_head; freepf_head->next=NUL; busypf_head=p; }

p=freepf_head->next; /*按方式调新页面入内存页面*/ freepf_head->next=NUL; freepf_head->pn=page[i];

pl[page[i]].pfn=freepf_head->pfn; if(busypf_tail==NUL)

busypf_head=busypf_tail=freepf_head; else {

busypf_tail->next=freepf_head; busypf_tail=freepf_head; }

freepf_head=p; } }

printf(\"FIFO:%6.4F\}

void LRU(total_pf) int total_pf; {

int min,minj,i,j,present_time;

initialize(total_pf);present_time=0; for(i=0;iif(pl[page[i]].pfn==INVALID) /*页面失效*/ {

diseffect++;

if(freepf_head==NUL) /*无空闲页面*/ {

min=32767;

for(j=0;jif(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=NUL; }

pl[page[i]].pfn=freepf_head->pfn; pl[page[i]].time=present_time; freepf_head=freepf_head->next; } else

pl[page[i]].time=present_time; present_time++; }

printf(\"LRU:%6.4f\ }

void 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;iif(pl[page[i]].pfn==INVALID) /*页面失效*/ {

diseffect++;

if(freepf_head==NUL) /*无空闲页面*/ {

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;jfreepf_head=&pfc[pl[dp].pfn]; pl[dp].pfn=INVALID; freepf_head->next=NUL; }

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;jprintf(\"NUR:%6.4f\ }

void OPT(total_pf) /*OPT(Optimal Replacement)ALGORITHM*/ int total_pf; {

int i,j,max,maxpage,d,dist[total_vp]; pfc_type *t;

initialize(total_pf);

for(i=0;iif(pl[page[i]].pfn==INVALID) {

diseffect++; if(freepf_head==NUL) {

for(j=0;jdist[j]=0;

d=1;

for(j=i+1;jif(pl[page[j]].pfn!=INVALID) dist[page[j]]=d; d++; }

max=-1;

for(j=0;jmax=dist[j];maxpage=j;}

freepf_head=&pfc[pl[maxpage].pfn]; freepf_head->next=NUL; pl[maxpage].pfn=INVALID; }

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

printf(\"OPT:%6.4f\ }

void LFU(total_pf) /*LFU(leat Frequently Used) ALGORITHM*/ int total_pf; {

int i,j,min,minpage; pfc_type *t;

initialize(total_pf);

for(i=0;iif (pl[page[i]].pfn==INVALID) {

diseffect++;

if(freepf_head==NUL) {

min=32767;

for(j=0;jif(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=NUL; }

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

else

pl[page[i]].counter++; }

printf(\"LFU:%6.4f\ }

void initialize(total_pf) /*初始化相关数据结构*/ int total_pf; /*用户进程的内存页面数*/ {

int i;

diseffect=0;

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

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

for(i=1;ipfc[i-1].next=&pfc[i];pfc[i-1].pfn=i-1;/*建立pfc[i-1]和pfc[i]之间的连接*/ }

pfc[total_pf-1].next=NUL;pfc[total_pf-1].pfn=total_pf-1; freepf_head=&pfc[0]; /*页面队列的头指针为pfc[0]*/ } <结果：〉截图在下面空白处

<分析1>

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

比较上述5种算法，以 算法的命中率最高， 算法次之，再就是 算法，其次是 算法。就本问题，在15页之前， 的命中率比 算法的高。 <分析2>

从结果可以看出，FIFO的命中率竟然比OPT的还高。至于为什么，请探讨。