综合性实验报告
专业 年级 班级：
一、实验目的
1.学习常见的4种页面置换算法：最佳置换算法（OPT），先进先出页面置换算法（FIFO），最近最久未使用页面算法（LRU），最少使用置换算法（LFU）。
2.编写函数并计算输出上述各种算法的命中率。
二、总体设计（设计原理、设计方案及流程等）
设计原理：OPT页面置换算法
OPT所选择被淘汰的页面是已调入内存，且在以后永不使用的，或是在最长时间内不再被访问的页面。因此如何找出这样的页面是该算法的关键。可为每个页面设置一个步长变量，其初值为一足够大的数，对于不在内存的页面，将其值重置为零，对于位于内存的页面，其值重置为当前访问页面与之后首次出现该页面时两者之间的距离，因此该值越大表示该页是在最长时间内不再被访问的页面，可以选择其作为换出页面。
FIFO页面置换算法
FIFO总是选择最先进入内存的页面予以淘汰，因此可设置一个先进先出的忙页帧队列，新调入内存的页面挂在该队列的尾部，而当无空闲页帧时，可从该队列首部取下一个页帧作为空闲页帧，进而调入所需页面。
LRU页面置换算法
LRU是根据页面调入内存后的使用情况进行决策的，它利用“最近的过去”作为“最近的将来”的近似，选择最近最久未使用的页面予以淘汰。该算法主要借助于页面结构中的访问时间time来实现，time记录了一个页面上次的访问时间，因此，当须淘汰一个页面时，选择处于内存的页面中其time值最小的页面，即最近最久未使用的页面予以淘汰。
LFU页面置换算法
LFU要求为每个页面配置一个计数器（即页面结构中的counter），一旦某页被访问，则将其计数器的值加1，在需要选择一页置换时，则将选择其计数器值最小的页面，即内存中访问次数最少的页面进行淘汰。
设计流程：
1.通过随机数产生一个指令序列，共320条指令。
2.指令序列变换成页地址流
3.计算并输出下述各种算法在不同内存容量下的命中率。
4.在主函数中生成要求的指令序列，并将其转换成页地址流；在不同的内存容量下调用上述函数使其计算并输出相应的命中率。
三、实验步骤（包括主要步骤、代码分析等）
主要代码：
1.页面结构
typedef struct{
int pn, pfn, counter, time;
} pl_type ;
pl_type pl[total_vp];
其中pn为页面号（页号），pfn为页帧号（物理块号），counter为一个周期内访问该页面的次数，time为访问时间；pl[total_vp]为页面结构数组，由于共有320条指令，每页可装入10条指令，因此虚页长total_vp的值为32。
将此结构封装到Pahg.h文件中。
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[total_vp]定义用户进程的页帧控制结构数组，在该实验中，用户内存工作区是动态变化的，最多可达到用户进程的虚页数目，即32个物理块。
*freepf_head为空闲页帧头的指针
*busypf_head为忙页帧头的指针
*busypf_tail忙页帧尾的指针
讲此结构封装到PageControl.h头文件中。
3.主要函数
(1) void initialize(int): 初始化函数
该函数主要对页面结构数组pl和页帧结构数组pfc进行初始化，如置页面结构中的页面号pn，初始化页帧号pfn为空，访问次数counter为0，访问时间time为-1；同样对页帧数组进行初始化，形成一个空闲页帧队列。
(2) void OPT(int): 计算使用最佳页面算法时的命中率
(3) void FIFO(int): 计算使用先进先出页面置换算法时的命中率
(4) void LRU(int): 计算使用最近最久未使用页面置换算法时的命中率
(5) void LFU(int): 计算使用最少使用置换算法时的命中率
void 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++)
{
if(pl[page[i]].pfn==INVALID) /*页面失效*/
{
diseffect=diseffect+1;
if(freepf_head==NULL) /*无空闲页帧*/
{
p=busypf_head->next;
pl[busypf_head->pn].pfn=INVALID; //将忙页帧队首页面作为换出页面
freepf_head=busypf_head;
freepf_head->next=NULL;
busypf_head=p; //忙页帧头指针后移
}
p=freepf_head->next; //有空闲页帧
freepf_head->next=NULL;
freepf_head->pn=page[i]; /* 将所需页面调入空闲页帧 */
pl[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)diseffect/320);
}
void LRU(int total_pf) /*最近最久未使用页面置换算法*/
{
int i,j;
int min,minj,present_time;
initialize(total_pf);
present_time=0;
for(i=0;i<total_instruction;i++)
{
if(pl[page[i]].pfn==INVALID) /*页面失效*/
{
diseffect++;
if(freepf_head==NULL) /*无空闲页帧*/
{
min=32767;
for(j=0;j<total_vp;j++) /*找出位于内存且time值最小的页面作为置换页面*/ {
if(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=NULL;
}
pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,改为有效
pl[page[i]].time=present_time; //修改页面的访问时间
freepf_head=freepf_head->next; //减少一个free 页面
}
else
pl[page[i]].time=present_time; //命中则修改该单元的访问时间
present_time++;
}
printf("LRU:%6.4f ",1-(float)diseffect/320);
}
void OPT(int total_pf) /* 最佳页面置换算法 */
{
int i,j,max,maxpage,d,dist[total_vp];
initialize(total_pf);
for(i=0;i<total_instruction;i++)
{
if(pl[page[i]].pfn==INVALID) /*页面失效*/
{
diseffect++;
if(freepf_head==NULL) /*无空闲页面*/
{
for(j=0;j<total_vp;j++)
{
if(pl[j].pfn!=INVALID)//所有位于内存页面的距离变量赋一足够大的数
dist[j]=32767;
else //不在内存的页面该变量则置为0
dist[j]=0;
}
d=1;
/* 对于位于内存且在当前访问页面之后将再次被访问的页面，dist重置为当 前页 面与之后首次出现该页面时两者之间的距离 */
for(j=i+1;j<total_instruction;j++)
{
if(pl[page[j]].pfn!=INVALID && dist[page[j]]==32767)
dist[page[j]]=d;
d++;
}
max=-1;
//查找dist变量值最大的页面作为换出页面
for(j=0;j<total_vp;j++)
{
if(max<dist[j]){
max=dist[j];
maxpage=j;
}
}
freepf_head=&pfc[pl[maxpage].pfn]; //腾出一个单元
freepf_head->next=NULL;
pl[maxpage].pfn=INVALID;
}
pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,改为有效
freepf_head=freepf_head->next; //减少一个free 页面
}
}
printf("OPT:%6.4f ",1-(float)diseffect/320);
}
void LFU(int total_pf) /* 最少使用页面置换算法 */
{
int i,j,min,minpage;
initialize(total_pf);
for(i=0;i<total_instruction;i++)
{
if(pl[page[i]].pfn==INVALID) //页面失效
{
diseffect++;
if(freepf_head==NULL) //无空闲页帧
{
min=32767;
for(j=0;j<total_vp;j++)
{ //查找位于内存且访问次数最少的页面作为换出页面
if(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=NULL;}
pl[page[i]].pfn=freepf_head->pfn; //有空闲页面,改为有效
pl[page[i]].counter++; //增加页面访问次数
freepf_head=freepf_head->next; //减少一个free 页}
else
pl[page[i]].counter++; //命中增加页面访问次数}
printf("LFU:%6.4f ",1-(float)diseffect/320);}
将上述函数写成头文件的格式封装在Memory.h头文件中，由主函数main调用使用。
运行结果
打开linux虚拟机，用vim编辑器打开代码进行修改和调整。用g++编译器进行编译运,如图所示：
四、结果分析与总结
由实验结果可知opt算法可保证获得最低的缺页率，但是由于目前还无法预知一个进程在内存的若干的页面中，哪一个页面是未来最长时间内不被访问的，因而该算法在实际应用中无法实现。Fifo算法有时候比较差，因为它所依据的条件是各个界面调入内存的时间，而页面调入的先后顺序不能反映页面的使用情况。LRU算法置换算法虽然是一种比较好的置换算法，但是在实际中需要用到寄存器和栈的硬件支持，LFC算法选择在最近时期使用最少的页面作为淘汰页，效率有时候很高。
教师签名：
年 月 日
第二篇：题目：页面置换算法
#include<iostream>
using namespace std;
int wk=0,count=0,num=0;
char s[100]={NULL},b[10]={NULL}; void FIFO()
{
int i,j; int m=0; for(i=0;i<wk;i++) b[i]=s[i]; for(j=wk;j<num;j++) { for(i=0;i<wk;i++) { } if(s[j]==b[i]) break; if(i==wk) { b[m]=s[j]; m++; count++;
} } m=m%wk; } cout<<count<<endl;
void LRU() {
int i,k,j,t,b; char *a=new char [wk]; int *time=new int [wk]; count=0; for(i=0;i<wk;i++) { } while(i<num) { b=1; for(j=0;j<wk;j++) if(s[i]==a[j]) //已有元素 { a[i]=s[i]; time[i]=wk-i;
if(time[j]==1) //一个元素连续出现 { } else { t=time[j]; time[j]=1; //最近访问的 b=0; for(k=0;k<wk;k++) if(!((k==j)||(time[k]>t))) //在j原来时间之后的b=0; break; 不变
} time[k]++; break; } if(b==1) //没有元素，需替换 { for(j=0;j<wk;j++) if(time[j]==wk) //最久元素 {
} } time[j]=1; a[j]=s[i]; //替换 count++; for(k=0;k<wk;k++) if(k!=j) time[k]++; break; } i++; cout<<count<<endl; }
int main()
{
cout<<"输入物块号："; cin>>wk;
while(cin>>s[num]) {
} } if(s[num]=='#') break; num++; if(num<=wk) count=0; else { FIFO(); LRU(); } return 0;