存储管理实验报告

综合性实验报告

专业：网络工程年级：12级班级：网络工程2014—2015学年第一学

一、实验目的

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

页面置换算法是虚拟存储管理实现的关键，通过本次实验理解内存页面调度的机制，在模拟实现FIFO、LRU、OPT、LFU、NUR几种经典页面置换算法的基础上，比较各种置换算法的效率及优缺点，从而了解虚拟存储实现的过程。

二、总体设计

1、编写函数计算并输出下述各种算法的命中率

①OPT页面置换算法

OPT所选择被淘汰的页面是已调入内存，且在以后永不使用的，或是在最长时间内不再被访问的页面。因此如何找出这样的页面是该算法

的关键。可为每个页面设置一个步长变量，其初值为一足够大的数，对

于不在内存的页面，将其值重置为零，对于位于内存的页面，其值重置

为当前访问页面与之后首次出现该页面时两者之间的距离，因此该值越

大表示该页是在最长时间内不再被访问的页面，可以选择其作为换出页

面。

②FIFO页面置换算法

FIFO总是选择最先进入内存的页面予以淘汰，因此可设置一个先进先出的忙页帧队列，新调入内存的页面挂在该队列的尾部，而当无空闲页帧时，可从该队列首部取下一个页帧作为空闲页帧，进而调入所需页面。

③LRU页面置换算法

LRU是根据页面调入内存后的使用情况进行决策的，它利用“最近的过去”作为“最近的将来”的近似，选择最近最久未使用的页面予以淘汰。该算法主要借助于页面结构中的访问时间time来实现，time记录了一个页面上次的访问时间，因此，当须淘汰一个页面时，选择处于内存的页面中其time值最小的页面，即最近最久未使用的页面予以淘汰。

④LFU页面置换算法

LFU要求为每个页面配置一个计数器（即页面结构中的counter），一旦某页被访问，则将其计数器的值加1，在需要选择一页置换时，则将选择其计数器值最小的页面，即内存中访问次数最少的页面进行淘汰。

⑤NUR页面置换算法

NUR要求为每个页面设置一位访问位（该访问位仍可使用页面结构中的counter表示），当某页被访问时，其访问位counter置为1。需要进行页面置换时，置换算法从替换指针开始（初始时指向第一个页面）顺序检查处于内存中的各个页面，如果其访问位为0，就选择该页换出，

否则替换指针下移继续向下查找。如果内存中的所有页面扫描完毕未找

到访问位为0的页面，则将替换指针重新指向第一个页面，同时将内存

中所有页面的访问位置0，当开始下一轮扫描时，便一定能找到counter

为0的页面。

2、在主函数中生成要求的指令序列，并将其转换成页地址流；在不同的内存容量下调用上述函数使其计算并输出相应的命中率。

三、实验步骤（包括主要步骤、代码分析等）

主要步骤：

、通过随机数产生一个指令序列，共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. OPT最佳置换算法：先淘汰最不常用的页地址；

D. NUR最近未使用置换算法；

E. LFU最少使用置换算法。

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

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

代码分析：

1、主函数main.cpp的代码：

#include

#include

#include

#include

#include

#include

using namespace std;

#define INVALID -1

const int TOTAL_INSTRUCTION(320); const int TOTAL_VP(32);

const int CLEAR_PERIOD(50);

#include "Page.h"

#include "PageControl.h"

#include "Memory.h"

int main()

{

int i;

CMemory a;

for(i=4;i<=32;i++)

{

cout<

a.OPT(i);

a.FIFO(i);

a.LRU(i);

cout<<"\n";

}

return 0;

}

2、主函数中用到的头文件”Page.h”,”PageControl.h”,”Memory.h”的代码：

Page.h:

#ifndef _PAGE_H

#define _PAGE_H

class CPage//页面结构

{

public:

int m_nPageNumber,//页面号

m_nPageFaceNumber,//页帧号

m_nCounter,//一个周期内访问该页面的次数

m_nTime;//访问时间

};

#endif

PageControl.h:

#ifndef _PAGECONTROL_H

#define _PAGECONTROL_H

class CPageControl//页帧控制结构

{

public:

int m_nPageNumber,m_nPageFaceNumber;

class CPageControl * m_pNext;

};

#endif

Memory.h:

#ifndef _MEMORY_H

#define _MEMORY_H

class CMemory

{

public:

CMemory();

void initialize(const int nTotal_pf);

void OPT(const int nTotal_pf);

void FIFO(const int nTotal_pf);

void LRU(const int nTotal_pf);

private:

vector _vDiscPages;

vector _vMemoryPages;

CPageControl *_pFreepf_head,*_pBusypf_head,*_pBusypf_tail;

vector _vMain,_vPage,_vOffset;

int _nDiseffect;

};

CMemory::CMemory():_vDiscPages(TOTAL_VP),

_vMemoryPages(TOTAL_VP),

_vMain(TOTAL_INSTRUCTION),

_vPage(TOTAL_INSTRUCTION),

_vOffset(TOTAL_INSTRUCTION)

{

int S,i,nRand;

srand(getpid()*10);

nRand=rand()%32767;

S=(float)319*nRand/32767+1;

for(i=0;i

{

_vMain[i]=S;

_vMain[i+1]=_vMain[i]+1;

nRand=rand()%32767;

_vMain[i+2]=(float)_vMain[i]*nRand/32767;

_vMain[i+3]=_vMain[i+2]+1;

nRand=rand()%32767;

S=(float)nRand *(318-_vMain[i+2])/32767+_vMain[i+2]+2;

}

for(i=0;i

{

_vPage[i]=_vMain[i]/10;

_vOffset[i]=_vMain[i]%10;

_vPage[i]%=32;

}

}

void CMemory::initialize(const int nTotal_pf)

{

int ix;

_nDiseffect=0;

for(ix=0;ix<_vDiscPages.size();ix++)

{

_vDiscPages[ix].m_nPageNumber=ix;

_vDiscPages[ix].m_nPageFaceNumber=INVALID;

_vDiscPages[ix].m_nCounter=0;

_vDiscPages[ix].m_nTime=-1;

}

for(ix=1;ix

{

_vMemoryPages[ix-1].m_pNext=&_vMemoryPages[ix];

_vMemoryPages[ix-1].m_nPageFaceNumber=ix-1;

}

_vMemoryPages[nTotal_pf-1].m_pNext=NULL;

_vMemoryPages[nTotal_pf-1].m_nPageFaceNumber=nTotal_pf-1;

_pFreepf_head=&_vMemoryPages[0];

}

void CMemory::OPT(const int nTotal_pf) /* 最佳页面置换算法*/

{

int i,j,max,maxpage,d,dist[TOTAL_VP];

initialize(nTotal_pf);

for(i=0;i

{

if(_vDiscPages[_vPage[i]].m_nPageFaceNumber==INVALID) /*页面失效*/

{

_nDiseffect++;

if(_pFreepf_head==NULL) /*无空闲页面*/

{

for(j=0;j

{

if(_vDiscPages[j].m_nPageFaceNumber!=INVALID)//所有位于内存页面的距离变量赋一足够大的数

dist[j]=32767;

else //不在内存的页面该变量则置为0

dist[j]=0;

}

d=1;

/* 对于位于内存且在当前访问页面之后将再次被访问的页面，dist重置为当前页面与之后首次出现该页面时两者之间的距离*/

for(j=i+1;j

{

if(_vDiscPages[_vPage[j]].m_nPageFaceNumber!=INVALID && dist[_vPage[j]]==32767)

dist[_vPage[j]]=d;

d++;

}

max=-1;

//查找dist变量值最大的页面作为换出页面

for(j=0;j

{

if(max

max=dist[j];

maxpage=j;

}

}

_pFreepf_head=&_vMemoryPages[_vDiscPages[maxpage].m_nPa geFaceNumber]; //腾出一个单元

_pFreepf_head->m_pNext=NULL;

_vDiscPages[maxpage].m_nPageFaceNumber=INVALID;

}

_vDiscPages[_vPage[i]].m_nPageFaceNumber=_pFreepf_head->m _nPageFaceNumber; //有空闲页面,改为有效

_pFreepf_head=_pFreepf_head->m_pNext; //减少一个free 页面

}

}

cout<<"OPT: "<<1-(float)_nDiseffect/320;

//printf("OPT:%6.4f ",1-(float)diseffect/320);

}

void CMemory::FIFO(const int nTotal_pf)

{

int i;

CPageControl *p;

initialize(nTotal_pf);

_pBusypf_head=_pBusypf_tail=NULL;

for(i=0;i

{

if(_vDiscPages[_vPage[i]].m_nPageFaceNumber==INVALID)

{

_nDiseffect+=1;

if(_pFreepf_head==NULL) //无空闲页面

{

p=_pBusypf_head->m_pNext;

_vDiscPages[_pBusypf_head->m_nPageNumber].m_nPageFaceNumb er=INVALID;

_pFreepf_head=_pBusypf_head;

_pFreepf_head->m_pNext=NULL;

_pBusypf_head=p;

}

p=_pFreepf_head->m_pNext;

_pFreepf_head->m_pNext=NULL;

_pFreepf_head->m_nPageNumber=_vPage[i];

_vDiscPages[_vPage[i]].m_nPageFaceNumber=_pFreepf_head->m_nP

ageFaceNumber;

if(_pBusypf_tail==NULL)

_pBusypf_head=_pBusypf_tail=_pFreepf_head;

else

{

_pBusypf_tail->m_pNext=_pFreepf_head;

_pBusypf_tail=_pFreepf_head;

}

_pFreepf_head=p;

}

}

cout<<"\tFIFO: "<<1-(float)_nDiseffect/320;

}

void CMemory::LRU(const int nTotal_pf)

{

int i,j,nMin,minj,nPresentTime(0);

initialize(nTotal_pf);

for(i=0;i

{

if(_vDiscPages[_vPage[i]].m_nPageFaceNumber==INVALID) {

_nDiseffect++;

if(_pFreepf_head==NULL)

{

nMin=32767;

for(j=0;j

//after the recycle iMin is the number of times

//used of the least used page while minj is its subscribe

if(nMin>_vDiscPages[j].m_nTime&&_vDiscPages[j].m_nPageFaceNu mber!=INVALID)

{

nMin=_vDiscPages[j].m_nTime;

minj=j;

}

_pFreepf_head=&_vMemoryPages[_vDiscPages[minj].m_nPageFaceNu mber];

_vDiscPages[minj].m_nPageFaceNumber=INVALID;

_vDiscPages[minj].m_nTime=-1;

_pFreepf_head->m_pNext=NULL;

}

_vDiscPages[_vPage[i]].m_nPageFaceNumber=_pFreepf_head->m_nP ageFaceNumber;

_vDiscPages[_vPage[i]].m_nTime=nPresentTime;

_pFreepf_head=_pFreepf_head->m_pNext;

}

else

_vDiscPages[_vPage[i]].m_nTime=nPresentTime;

nPresentTime++;

}

cout<<"\tLRU: "<<1-(float)_nDiseffect/320;

}

#endif

四、结果分析与总结

实验运行结果，如图：

总结：

从上述结果可知，随着内存页面数的增加，三种算法的访问命中率逐渐增大。在内存页面数为4~25个页面之间时，三种算法的命中率大致在56%至88%之间变化，但是，OPT算法和其他两种算法之间的差别一般在6~12个百分点左右。在内存页面为25~32个页面时，由于用户进程的所有指令基本上都已装入内存，从而命中率增加较大，各种算法之间的差别不大。

比较上述三种算法，OPT算法的命中率最高，LRU算法和FIFO算法的命中率则较为接近。

教师签名：

年月日