实验三 存储管理.docx

实验三 存储管理.docx

《实验三 存储管理.docx》由会员分享，可在线阅读，更多相关《实验三 存储管理.docx（18页珍藏版）》请在冰点文库上搜索。

实验三存储管理

实验三存储管理

一、实验目的

存储管理的主要功能之一是合理地分配空间。

请求页式管理是一种常用的虚拟存储管理技术。

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

二、实验内容

（1）通过计算不同算法的命中率比较算法的优劣。

同时也考虑了用户内存容量对命中率的影响。

页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。

在本实验中，假定页面大小为1k，用户虚存容量为32k，用户内存容量为4页到32页。

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

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

1）50%的指令是顺序执行的

2）25%的指令是均匀分布在前地址部分

3）25%的指令是均匀分布在后地址部分

B、具体的实施方法是：

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

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

3）在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m’；

4）顺序执行一条指令，地址为m’+1的指令

5）在后地址[m’+2，319]中随机选取一条指令并执行；

6）重复上述步骤1）~5），直到执行320次指令

C、将指令序列变换称为页地址流

在用户虚存中，按每k存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：

第0条~第9条指令为第0页（对应虚存地址为[0，9]）；

第10条~第19条指令为第1页（对应虚存地址为[10，19]）；

。

。

。

。

。

。

第310条~第319条指令为第31页（对应虚存地址为[310，319]）；

按以上方式，用户指令可组成32页。

（1）计算并输出下属算法在不同内存容量下的命中率。

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

2）最近最少使用算法（LRU）；

3）最佳淘汰算法（OPT）；

4）最少访问页面算法（LFR）；

其中3）和4）为选择内容

三、系统框图

四、源程序代码

1．存储管理操作类

packageMemoryManagement;

importjava.util.Random;

publicclassMemoryManage_Operation{

privateString[][]dataStrings=newString[33][4];//数据传递数组

privateint[]Addstream=newint[320];//地址流

privateint[]Addspage=newint[320];//页面流

privateint[]phyBlock=newint[32];//物理块数

privateRandomrandom=newRandom（）;//随机数

privateintblockNum;//内存块数

privateintnpageNum;//缺页数临时变量

privatefloatrate;//缺页率

privateinttempK,tempG,tempF;//临时变量

//产生随机地址流和页面流

publicvoidsetProduceAddstream（）{

inttemp;

for（inti=0;i<320;i+=3）{

temp=random.nextInt（320）%320+0;

Addstream[i]=temp+1;

temp=random.nextInt（320）%（Addstream[i]+1）;

Addstream[i+1]=temp+1;

temp=random.nextInt（320）%（319-Addstream[i+1]）+（Addstream[i+1]+1）;

if（i+2>=320）{

break;

}

Addstream[i+2]=temp;

}

for（inti=0;i<320;i++）{

Addspage[i]=Addstream[i]/10;

}

}

//用户内存及相关数据初始化

privatevoidinitialization（）{

for（inti=0;i<32;i++）

phyBlock[i]=-1;

this.npageNum=0;

this.rate=0;

this.tempK=0;

this.tempG=-1;

this.tempF=-1;

}

//先进先出置换算法

publicvoidFIFO（）

{

int[]time=newint[32];//定义进入内存时间长度数组

intmax;//max表示进入内存时间最久的，即最先进去的

initialization（）;

for（inti=0;i

time[i]=i+1;

for（inti=0;i<320;i++）

{

this.tempK=0;

for（intj=0;j

if（phyBlock[j]==Addspage[i]）{//表示内存中已有当前要调入的页面

this.tempG=j;

break;

}

for（intj=0;j

if（phyBlock[j]==-1）{//用户内存中存在空的物理块

this.tempF=j;

break;

}

if（this.tempG!

=-1）

this.tempG=-1;

else{

if（this.tempF==-1）{//找到最先进入内存的页面

max=time[0];

for（intj=0;j

if（time[j]>max）{

max=time[j];

this.tempK=j;

}

phyBlock[tempK]=Addspage[i];

time[tempK]=0;//该物理块中页面停留时间置零

npageNum++;//缺页数+1

}else{

phyBlock[tempF]=Addspage[i];

time[tempF]=0;

npageNum++;

tempF=-1;

}

}

for（intj=0;j

=-1;j++）

time[j]++;//物理块中现有页面停留时间+1

}

this.rate=1-（float）npageNum/320;

dataStrings[blockNum][1]=this.rate+"";

}

//最近最少使用算法

publicvoidLRU（）{

int[]time=newint[32];

intmax;

initialization（）;

for（inti=0;i

time[i]=i+1;

for（inti=0;i<320;i++）{

tempK=0;

for（intj=0;j

if（phyBlock[j]==Addspage[i]）{

this.tempG=j;

break;

}

for（intj=0;j

if（phyBlock[j]==-1）{

this.tempF=j;

break;

}

if（this.tempG!

=-1）{

time[tempG]=0;

this.tempG=-1;

}else{

if（this.tempF==-1）{

max=time[0];

for（intj=0;j

if（time[j]>max）{

this.tempK=j;

max=time[j];

}

phyBlock[tempK]=Addspage[i];

time[tempK]=0;

npageNum++;

}else{

phyBlock[tempF]=Addspage[i];

time[tempF]=0;

npageNum++;

this.tempF=-1;

}

}

for（intj=0;j

=-1;j++）

time[j]++;

}

this.rate=1-（float）npageNum/320;

dataStrings[blockNum][2]=this.rate+"";

}

//最少访问页面算法

publicvoidLFR（）{

initialization（）;

int[]time_lru=newint[32];

int[]time=newint[32];

intmin,max_lru,t;

for（inti=0;i

time[i]=0;

time_lru[i]=i+1;

}

for（inti=0;i<320;i++）{

this.tempK=0;

t=1;

for（intj=0;j

if（phyBlock[j]==Addspage[i]）{

this.tempG=j;

break;

}

for（intj=0;j

if（phyBlock[j]==-1）{

this.tempF=j;

break;

}

if（this.tempG!

=-1）{

time_lru[tempG]=0;

this.tempG=-1;

}else{

if（this.tempF==-1）{

if（i<=20）{//将最少使用的间隔时间定位个单位

max_lru=time_lru[0];//在未达到“一定时间”的要求时，先采用LRU进行页面置换

for（intj=0;j

if（time_lru[j]>max_lru）{

this.tempK=j;

max_lru=time_lru[j];

}

phyBlock[tempK]=Addspage[i];

time_lru[tempK]=0;

npageNum++;

}else{

for（intj=0;j

for（inth=i-1;h>=i-1;h--）

if（phyBlock[j]==Addspage[h]）

time[j]++;

min=time[0];

for（intj=0;j

if（time[j]

min=time[j];

this.tempK=j;

}

for（intj=0;j

if（time[j]==min）

t++;

if（t>1）{//若使用次数同样少，将次数相同的页面按照LRU进行页面置换

max_lru=time_lru[tempK];

for（intj=0;j

if（time_lru[j]>max_lru）{

this.tempK=j;

max_lru=time_lru[j];

}

}

phyBlock[tempK]=Addspage[i];

time_lru[tempK]=0;

npageNum++;

}

}else{

phyBlock[tempF]=Addspage[i];

time_lru[tempF]=0;

npageNum++;

tempF=-1;

}

}

for（intj=0;j

=-1;j++）

time_lru[j]++;

}

this.rate=1-（float）npageNum/320;

dataStrings[blockNum][3]=this.rate+"";

}

publicintgetBlockNum（）{

returnblockNum;

}

publicvoidsetBlockNum（intblockNum）{

this.blockNum=blockNum;

}

publicString[][]getDataStrings（）{

returndataStrings;

}

publicvoidsetDataStrings（String[][]dataStrings）{

this.dataStrings=dataStrings;

}

}

2．界面类

packageMemoryManagement;

importorg.eclipse.swt.widgets.Display;

importorg.eclipse.swt.widgets.MessageBox;

importorg.eclipse.swt.widgets.Shell;

importorg.eclipse.swt.widgets.Menu;

importorg.eclipse.swt.widgets.TableItem;

importorg.eclipse.swt.SWT;

importorg.eclipse.swt.widgets.MenuItem;

importorg.eclipse.swt.widgets.Table;

importorg.eclipse.swt.widgets.TableColumn;

importorg.eclipse.swt.events.SelectionAdapter;

importorg.eclipse.swt.events.SelectionEvent;

publicclassManageSWT{

protectedShellshell;

privateTabletable;

/**

*Launchtheapplication.

*@paramargs

*/

publicstaticvoidmain（String[]args）{

try{

ManageSWTwindow=newManageSWT（）;

window.open（）;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

/**

*Openthewindow.

*/

publicvoidopen（）{

Displaydisplay=Display.getDefault（）;

createContents（）;

shell.open（）;

shell.layout（）;

while（!

shell.isDisposed（））{

if（!

display.readAndDispatch（））{

display.sleep（）;

}

}

}

/**

*Createcontentsofthewindow.

*/

protectedvoidcreateContents（）{

shell=newShell（）;

shell.setSize（450,300）;

shell.setText（"\u5B58\u50A8\u7BA1\u7406"）;

Menumenu=newMenu（shell,SWT.BAR）;

shell.setMenuBar（menu）;

MenuItemmenuItem=newMenuItem（menu,SWT.NONE）;

menuItem.addSelectionListener（newSelectionAdapter（）{

@Override

publicvoidwidgetSelected（SelectionEvente）{

analysis（）;

}

}）;

menuItem.setText（"\u547D\u4E2D\u7387\u5206\u6790"）;

MenuItemmenuItem_2=newMenuItem（menu,SWT.NONE）;

menuItem_2.addSelectionListener（newSelectionAdapter（）{

@Override

publicvoidwidgetSelected（SelectionEvente）{

shell.dispose（）;

}

}）;

menuItem_2.setText（"\u9000\u51FA"）;

MenuItemmenuItem_1=newMenuItem（menu,SWT.NONE）;

menuItem_1.addSelectionListener（newSelectionAdapter（）{

@Override

publicvoidwidgetSelected（SelectionEvente）{

MessageBoxmessageBox=newMessageBox（shell,SWT.ICON_INFORMATION）;

messageBox.setText（"关于"）;

messageBox.setMessage（"存储管理\n作者：

章进兴\n0941901228"）;

messageBox.open（）;

}

}）;

menuItem_1.setText（"\u5173\u4E8E"）;

table=newTable（shell,SWT.BORDER|SWT.FULL_SELECTION）;

table.setBounds（0,0,434,242）;

table.setHeaderVisible（true）;

table.setLinesVisible（true）;

TableColumntblclmnNewColumn=newTableColumn（table,SWT.NONE）;

tblclmnNewColumn.setWidth（90）;

tblclmnNewColumn.setText（"\u7269\u7406\u5757\u6570"）;

TableColumntblclmnNewColumn_1=newTableColumn（table,SWT.CENTER）;

tblclmnNewColumn_1.setWidth（100）;

tblclmnNewColumn_1.setText（"\u5148\u8FDB\u5148\u51FA\u7684\u7B97\u6CD5"）;

TableColumntblclmnNewColumn_2=newTableColumn（table,SWT.CENTER）;

tblclmnNewColumn_2.setWidth（110）;

tblclmnNewColumn_2.setText（"\u6700\u8FD1\u6700\u5C11\u4F7F\u7528\u7B97\u6CD5"）;

TableColumntblclmnLfu=newTableColumn（table,SWT.CENTER）;

tblclmnLfu.setWidth（110）;

tblclmnLfu.setText（"\u6700\u5C11\u8BBF\u95EE\u9875\u9762\u7B97\u6CD5"）;

}

publicvoidanalysis（）{

table.removeAll（）;

MemoryManage_OperationmOperation=newMemoryManage_Operation（）;

mOperation.setProduceAddstream（）;

String[][]tempStrings=