目录
一、实验目的：
1.存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。
2.本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的技术特点，掌握请求页式存储管理的页面置换算法。
二、实验内容：
（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条指令为第一页（对应虚存地址为[10，19]）；
… …
第310条~第319条指令为第31页（对应虚地址为[310，319]）。
按以上方式，用户指令可组成32页。
（3）计算并输出下述各种算法在不同内存容量下的命中率。
①先进先出的算法（FIFO）；
②最近最少使用算法（LRU)；
③最佳淘汰算法（OPT）先淘汰最不常用的页地址；
④最少访问页面算法（LFU）；
⑤最近最不经常使用算法（Clock）。
其中③、④、⑤为选择内容。
命中率=1-页面失效次数/页地址流长度
在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
三、相关算法原理：
- FIFO:选择在内存驻留「时间最长」的页面进行中置换
- LRU:选择「最长时间没有被访问」的页面进行置换
- OPT:选择在「未来」最长时间不访问的页面进行置
- LFU:当发生缺页中断时，选择「访问次数」最少的那个页面，并将其淘汰
- Clock:把所有的页面都保存在一个类似钟面的「环形链表」中，一个表针指向最老的页面。
当发生缺页中断时，算法首先检查表针指向的页面：
① 如果它的访问位位是 0 就淘汰该页面，并把新的页面插入这个位置，然后把表针后移一个位置。 ② 如果访问位是 1 ，就把表针后移一个位置，重复这个过程直到找到了一个访问位为 0 的页面为止；
-
四、源代码：
#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周期NUR
typedef struct /*页面结构*/
{ int ordernum; //顺序号LFU,LRU
int adr; //指令号OPT
int pn; //页号
int pfn; //页面框架号
int counter; //计数器LFU
int time; //时间LRU
}pl_type;
pl_type pl[total_vp]; //0~32
/*页面线性结构---指令序列需要使用地址*/
typedef struct pfc_struct
/*页面控制结构，调度算法的控制结构*/
{
int pn;
int pfn;
int count; //访问位Clock
struct pfc_struct *next;
}pfc_type;
pfc_type pfc[total_vp],*freepf_head, *busypf_head, *busypf_tail;
int diseffect,a[total_instruction]; /* a[]为指令序列,OPT*/
int page[total_instruction],offset[total_instruction]; /*地址信息*/
//函数预处理
int initialize(int); //初始化freepf
int FIFO(int); //先进先出算法
int LRU(int); //最近最少使用算法
int LFU(int); //最少访问页面算法
int Clock(int); //时钟置换算法（最近最不经常使用算法）
int OPT(int); //最佳淘汰算法，先淘汰最不常用的页地址
int main( )
{
int s,i,j;
srand(10*getpid()); /*由于每次运行时进程号不同，初始化随机数队列的“种子”*/
s=(float)319*rand( )/32767/32767/2+1; /*正态分布*/
printf("\n******Generate 320 random numbers******\n\n");
for(i=0;i<total_instruction;i+=4) /*指令队列*/
{
if(s<0||s>319)
{
printf("When i==%d,Error,s==%d\n",i,s);
exit(0);
}
a[i]=s; /*任选一指令访问点m*/
printf("%d ",a[i]);
a[i+1]=a[i]+1; /*顺序执行一条指令*/
printf("%d ",a[i+1]);
a[i+2]=(float)a[i]*rand( )/32767/32767/2; /*执行前地址指令m*/
printf("%d ",a[i+2]);
a[i+3]=a[i+2]+1; /*顺序执行一条指令*/
printf("%d ",a[i+3]);
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);
}
printf("\n\n******Transfrom into a 32-page address stream******\n");
for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/
{
page[i]=a[i]/10;
offset[i]=a[i]%10;
printf("%d: \t",page[i]); //输出地址所在页面
}
printf("\n\n");
for(i=4;i<=total_vp;i++) /*用户内存工作区从4个页面到32个页面*/
{
printf("--%2d page frames ",i);
FIFO(i); //√
LRU(i); //√
LFU(i); //√
Clock(i); //√
OPT(i); //√
}
return 0;
}
//初始化相关数据结构 total_pf表示内存的块数
int initialize(int total_pf)
{
int i;
diseffect=0; //页面失效次数
for(i=0;i<total_vp;i++)
{
pl[i].pfn=INVALID; /*置页面控制结构中的页号，页面为空*/
pl[i].counter=0; /*页面控制结构中的访问次数为0*/
pl[i].time=-1; /*访问的时间*/
pl[i].ordernum=0; /*访问顺序号设置,查找最先进入*/
}
for(i=0;i<total_pf-1;i++) /*建立pfc[i-1]和pfc[i]之间的链接，形成链表*/
{
pfc[i].next=&pfc[i+1];
pfc[i].pfn=i;
}
pfc[total_pf-1].next=NULL;
pfc[total_pf-1].pfn=total_pf-1;
freepf_head=&pfc[0]; /*空页面队列的头指针为pfc[0]*/
return 0;
}
int FIFO(int total_pf) /*先进先出算法*/
{
int i,j;
pfc_type *p; /*中间变量*/
initialize(total_pf); /*初始化相关页面控制用数据结构*/
busypf_head=busypf_tail=NULL; /*忙页面队列头，队列尾链接*/
for(i=0;i<total_instruction;i++)
{
//printf("%d:",i);
if(pl[page[i]].pfn==INVALID) //页面失效
{
//printf("$");
diseffect+=1; /*失效次数*/
if(freepf_head==NULL) /*无空闲页面*/
{
//printf("&\t");
p=busypf_head->next;
pl[busypf_head->pn].pfn=INVALID;
//printf("@Eliminate: %d@",pl[busypf_head->pn].pn);//被置换页面
freepf_head=busypf_head; /*释放忙页面队列的第一个页面*/
freepf_head->next=NULL; /*表明还是缺页*/
busypf_head=p;
}
p=freepf_head->next;
pl[page[i]].pn=page[i];
freepf_head->pn=page[i];
pl[page[i]].pfn=freepf_head->pfn;
freepf_head->next=NULL; /*使busy的尾为null*/
if(busypf_tail==NULL)
{
//printf("*\t");
busypf_tail=busypf_head=freepf_head;
}
else
{
//printf("<<#>>");
busypf_tail->next=freepf_head;
busypf_tail=freepf_head;
}
//printf("Write->%d",pl[page[i]].pn); //正在执行的页面号
freepf_head=p;
}
//printf("\n");
}
printf("FIFO:%6.4f ",1-(float)diseffect/320);
return 0;
}
int LRU (int total_pf) /*最近最久未使用算法*/
{
int min,orders=0,man,minj,i,j,present_time; /*minj为最小值下标*/
initialize(total_pf);
present_time=0;
for(i=0;i<total_instruction;i++)
{
//printf("%d:",i);
if(pl[page[i]].pfn==INVALID) /*页面失效*/
{
//printf("$");
diseffect++;
orders++;
if(freepf_head==NULL) /*无空闲页面*/
{
//printf("&\t");
min=32767; /*设置最大值*/
man=32767;
for(j=0;j<total_vp;j++) /*找出time的最小值*/
{
if(min>pl[j].time&&pl[j].pfn!=INVALID)
{
min=pl[j].time;
}
}
for(j=0;j<total_vp;j++) /*在time最小的里面找出最先进入页面的*/
{
if(pl[j].time==min&&man>pl[j].ordernum&&pl[j].ordernum!=0)
{
man=pl[j].ordernum;
minj=j;
}
}
freepf_head=&pfc[pl[minj].pfn]; //腾出一个单元
pl[minj].pfn=INVALID;
//printf("@Eliminate: %d@",pl[minj].pn); //要置换的页面号
pl[minj].time=0;
pl[minj].ordernum=0;
freepf_head->next=NULL;
}
pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,改为有效
pl[page[i]].pn=page[i];
//printf("\tWrite->%d",pl[page[i]].pn); //正在执行页面
pl[page[i]].time=present_time;
pl[page[i]].ordernum=orders;
//printf("\t*%d*",pl[page[i]].ordernum); //当前置换顺序号
freepf_head=freepf_head->next; //减少一个free 页面
}
else
{
//printf("#");
present_time++;
pl[page[i]].time=present_time; //命中则增加该单元的访问次数
}
//printf("\n");
}
printf("LRU:%6.4f ",1-(float)diseffect/320);
return 0;
}
int Clock(int total_pf) /*最近未使用算法*/
{
int i,j,dp,cont_flag,old_dp;
int v=total_pf;
initialize(total_pf);
dp=0;
for(j=0;j<total_pf;j++) //初始化设置count=0
{
pfc[j].count=0;
}
for(i=0;i<total_instruction;i++)
{
//printf("%d:",i);
if(pl[page[i]].pfn==INVALID) /*页面失效*/
{
//printf("$");
diseffect++;
if(freepf_head==NULL) /*无空闲页面*/
{
//printf("&\t");
cont_flag=TRUE;
old_dp=dp;
while(cont_flag)
{
if(pfc[dp].count==0&&pl[pfc[dp].pn].pfn!=INVALID)
cont_flag=FALSE;
else
{
dp++;
if(dp==v)
{
dp=0;
//printf("***");
}
if(dp==old_dp)
{
//printf("#");
for(j=0;j<v;j++)
pfc[j].count=0;
}
}
}
freepf_head=&pfc[dp];
//printf("@Eliminate: %d@",pfc[dp].pn); //被置换的页面
pl[pfc[dp].pn].pfn=INVALID;
freepf_head->next=NULL;
pfc[dp].count=1;
}
pl[page[i]].pfn=freepf_head->pfn;
pl[page[i]].pn=page[i];
//printf("\tWrite->%d",pl[page[i]].pn); //显示当前处理页面
freepf_head->pn=page[i];
freepf_head=freepf_head->next;
}
else
pfc[pl[page[i]].pfn].count=1;
//printf("\n");
}
printf("Clock:%6.4f ",1-(float)diseffect/320);
return 0;
}
int OPT(int total_pf) /*最佳置换算法*/
{
int i,j,k,v=total_pf,max,maxpage;
int ver[v],far[v];
//printf("****%d****\n",v);
initialize(total_pf);
for(i=0;i<total_instruction;i++)
{
//printf("%d:",i);
if(pl[page[i]].pfn==INVALID) /*页面失效*/
{
//printf("$");
diseffect++;
if(freepf_head==NULL) //无空闲页面
{
//printf("&");
max=0;
for(j=0;j<v;j++)
{ //ver赋初值
ver[j]=pl[pfc[j].pn].adr;
}
for(j=0;j<v;j++)
{
far[j]=32767; //在此指令之后都没有此页时候，选取在freepf中页号最小的页
}
for(j=0;j<v;j++)
{
for(k=i;k<total_instruction;k++)
{
if(pfc[j].pn==a[k]/10) //寻找此后第一个出现的页的距离
{
far[j]=k-i;
ver[j]=a[k];
//printf("<\n\tPage:%d=%d||Next:%d Value:%d>",pfc[j].pn,a[k]/10,far[j],ver[j]);
break;
}
}
}
for(j=0;j<v;j++)
{
if(far[max]<far[j])
{
max=j; //在此指令后无此页，此处与上32767选出页号
}
}
//printf("@Eliminate:%d@",pfc[max].pn);
freepf_head=&pfc[max];
freepf_head->next=NULL;
pl[freepf_head->pn].pfn=INVALID;
}
pl[page[i]].pn=page[i];
pl[page[i]].adr=i;
//printf("\tWrite->%d",pl[page[i]].pn);
freepf_head->pn=page[i];
pl[page[i]].pfn=freepf_head->pfn;
freepf_head=freepf_head->next;
}
//printf("\n");
}
printf("OPT:%6.4f\n",1-(float)diseffect/320);
return 0;
}
int LFU(int total_pf) /*最不经常使用置换法*/
{
int i,j,min,man,orders=0,minpage;
initialize(total_pf);
for(i=0;i<total_instruction;i++)
{
//printf("%d: ",i);
if(pl[page[i]].pfn==INVALID) //页面失效
{
//printf("$");
diseffect++;
orders++;
if(freepf_head==NULL) //无空闲页面
{
//printf("&\t");
min=32767; /*获取counter的使用用频率最小的内存*/
man=32767;
for(j=0;j<total_vp;j++)
{
if(min>pl[j].counter&&pl[j].pfn!=INVALID)
{
min=pl[j].counter;
}
}
for(j=0;j<total_vp;j++)
{
if(min==pl[j].counter&&man>pl[j].ordernum&&pl[j].ordernum!=0)
{
man=pl[j].ordernum;
minpage=j;
}
}
freepf_head=&pfc[pl[minpage].pfn];
//printf("@Eliminate:%d@",pl[minpage].pn); //要置换的页面号
pl[minpage].pfn=INVALID;
pl[minpage].ordernum=0;
pl[minpage].counter=0;
freepf_head->next=NULL;
}
pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,改为有效
pl[page[i]].pn=page[i];
//printf("\tWrite->%d",pl[page[i]].pn); //正在执行页面
pl[page[i]].counter++;
pl[page[i]].ordernum=orders;
//printf("\t*%d*",pl[page[i]].ordernum); //当前置换顺序号
freepf_head=freepf_head->next; //减少一个free 页面
}
else
{
//printf("#");
pl[page[i]].counter=pl[page[i]].counter+1;
}
//printf("\n");
}
printf("LFU:%6.4f ",1-(float)diseffect/320);
return 0;
}
扫一扫
952
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
