实验3虚拟存储器管理.docx

实验3虚拟存储器管理.docx

《实验3虚拟存储器管理.docx》由会员分享，可在线阅读，更多相关《实验3虚拟存储器管理.docx（17页珍藏版）》请在冰豆网上搜索。

实验3虚拟存储器管理

淮海工学院计算机科学系

实验报告书

课程名：

《操作系统原理》

题目：

实验三虚拟存储器管理

班级：

Z软件52

学号：

**********

******

1、实验目的与要求

本实验模拟请求页式虚存管理系统的页面置换情况。

实验程序能模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。

要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。

并通过为该进程分配不同的实页数，来比较几种算法的稳定性。

2、实验内容或题目

本实验要求使用C/C++语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。

其中虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。

要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。

程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。

实验说明：

（1）设计中虚页和实页的表示

本设计利用C/C++/Java语言的结构体来描述虚页和实页的结构。

pn

pfn

time

pn

pfn

next

虚页结构实页结构

在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。

pfn代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。

time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。

在实页结构中中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。

pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。

next是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。

（2）关于缺页次数的统计

为计算命中率，需要统计在20次的虚页访问中命中的次数。

为此，程序应设置一个计数器count，来统计虚页命中发生的次数。

每当所访问的虚页的pfn项值不为-1，表示此虚页已被装入某实页内，此虚页被命中，count加1。

最终命中率=count/20*100%。

（3）LRU算法中“最近最久未用”页面的确定

为了能找到“最近最久未用”的虚页面，程序中可引入一个时间计数器countime，每当要访问一个虚页面时，countime的值加1，然后将所要访问的虚页的time项值设置为增值后的当前countime值，表示该虚页的最后一次被访问时间。

当LRU算法需要置换时，从所有已分配实页的虚页中找出time值为最小的虚页就是“最近最久未用”的虚页面，应该将它置换出去。

（4）算法中实页的组织

因为能分配的实页数n是在程序运行时由用户动态指派的，所以应使用链表组织动态产生的多个实页。

为了调度算法实现的方便，可以考虑引入free和busy两个链表：

free链表用于组织未分配出去的实页，首指针为free_head，初始时n个实页都处于free链表中；busy链表用于组织已分配出去的实页，首指针为busy_head，尾指针为busy_tail，初始值都为null。

当所要访问的一个虚页不在实页中时，将产生缺页中断。

此时若free链表不为空，就取下链表首指针所指的实页，并分配给该虚页。

若free链表为空，则说明n个实页已全部分配出去，此时应进行页面置换：

对于FIFO算法要将busy_head所指的实页从busy链表中取下，分配给该虚页，然后再将该实页插入到busy链表尾部；对于LRU算法则要从所有已分配实页的虚页中找出time值为最小的虚页，将该虚页从装载它的那个实页中置换出去，并在该实页中装入当前正要访问的虚页。

3、实验步骤

（1）理解好相关实验说明。

（2）根据实验说明，画出相应的程序流程图。

（3）按照程序流程图，用C/C++/Java语言编程并实现。

4、流程图

5、源代码与测试数据与实验结果（可以抓图粘贴）

#include"iostream.h"

constintDataMax=100;

constintBlockNum=10;

intDataShow[BlockNum][DataMax];//用于存储要显示的数组

boolDataShowEnable[BlockNum][DataMax];//用于存储数组中的数据是否需要显示

//intData[DataMax]={4,3,2,1,4,3,5,4,3,2,1,5,6,2,3,7,1,2,6,1};//测试数据

//intN=20;//输入页面个数

intData[DataMax];//保存数据

intBlock[BlockNum];//物理块

intcount[BlockNum];//计数器

intN;//页面个数

intM;//最小物理块数

intChangeTimes;

voidDataInput（）;//输入数据的函数

voidDataOutput（）;

voidFIFO（）;//FIFO函数

voidOptimal（）;//Optimal函数

voidLRU（）;//LRU函数

///*

intmain（intargc,char*argv[]）

{

DataInput（）;//DataInput（）;

//FIFO（）;

//Optimal（）;

//LRU（）;

//return0;

intmenu;

while（true）

{

cout<

cout<<"*菜单选择*"<

cout<<"*******************************************************"<

cout<<"*1-FIFO*"<

cout<<"*2-Optimal*"<

cout<<"*3-LRU*"<

cout<<"*0-EXIT*"<

cout<<"*******************************************************"<

cin>>menu;

switch（menu）

{

case1:

FIFO（）;break;

case2:

Optimal（）;break;

case3:

LRU（）;break;

default:

break;

}

if（menu!

=1&&menu!

=2&&menu!

=3）break;

}

}

//*/

voidDataInput（）

{

cout<<"请输入最小物理块数：

";

cin>>M;

while（M>BlockNum）//大于数据个数

{

cout<<"物理块数超过预定值，请重新输入：

";

cin>>M;

}

cout<<"请输入页面的个数：

";

cin>>N;

while（N>DataMax）//大于数据个数

{

cout<<"页面个数超过预定值，请重新输入：

";

cin>>N;

}

cout<<"请输入页面访问序列：

"<

for（inti=0;i

cin>>Data[i];

}

voidDataOutput（）

{

inti,j;

for（i=0;i

{

cout<

}

cout<

for（j=0;j

{

cout<<"";

for（i=0;i

{

if（DataShowEnable[j][i]）

cout<

else

cout<<"";

}

cout<

}

cout<<"缺页次数:

"<

cout<<"缺页率:

"<

}

voidFIFO（）

{

inti,j;

boolfind;

intpoint;

inttemp;//临时变量

ChangeTimes=0;

for（j=0;j

for（i=0;i

DataShowEnable[j][i]=false;//初始化为false，表示没有要显示的数据

for（i=0;i

{

count[i]=0;//大于等于BlockNum，表示块中没有数据，或需被替换掉

//所以经这样初始化（321），每次替换>=3的块，替换后计数值置1，

//同时其它的块计数值加1，成了（132），见下面先进先出程序段

}

for（i=0;i

{

//增加count

for（j=0;j

count[j]++;

find=false;//表示块中有没有该数据

for（j=0;j

{

if（Block[j]==Data[i]）

{

find=true;

}

}

if（find）continue;//块中有该数据，判断下一个数据

//块中没有该数据

ChangeTimes++;//缺页次数++

if（（i+1）>M）//因为i是从0开始记，而M指的是个数，从1开始，所以i+1

{

//获得要替换的块指针

temp=0;

for（j=0;j

{

if（temp

{

temp=count[j];

point=j;//获得离的最远的指针

}

}

}

elsepoint=i;

//替换

Block[point]=Data[i];

count[point]=0;//更新计数值

//保存要显示的数据

for（j=0;j

{

DataShow[j][i]=Block[j];

DataShowEnable[i

（j<=i?

j:

i）:

j][i]=true;//设置显示数据

}

}

//输出信息

cout<

cout<<"FIFO=>"<

DataOutput（）;

}

voidOptimal（）

{

inti,j,k;

boolfind;

intpoint;

inttemp;//临时变量，比较离的最远的时候用

ChangeTimes=0;

for（j=0;j

for（i=0;i

DataShowEnable[j][i]=false;//初始化为false，表示没有要显示的数据

//for（i=0;i

//{

//count[i]=0;//

//}

for（i=0;i

{

find=false;//表示块中有没有该数据

for（j=0;j

{

if（Block[j]==Data[i]）

find=true;

}

if（find）continue;//块中有该数据，判断下一个数据

//块中没有该数据，最优算法

ChangeTimes++;//缺页次数++

for（j=0;j

{

//找到下一个值的位置

find=false;

for（k=i;k

{

if（Block[j]==Data[k]）

{

find=true;

count[j]=k;

break;

}

}

if（!

find）count[j]=N;

}

if（（i+1）>M）//因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1

{

//获得要替换的块指针

temp=0;

for（j=0;j

{

if（temp

{

temp=count[j];

point=j;//获得离的最远的指针

}

}

}

elsepoint=i;

//替换

Block[point]=Data[i];

//保存要显示的数据

for（j=0;j

{

DataShow[j][i]=Block[j];

DataShowEnable[i

（j<=i?

j:

i）:

j][i]=true;//设置显示数据

}

}

//输出信息

cout<

cout<<"Optimal=>"<

DataOutput（）;

}

voidLRU（）

{

inti,j;

boolfind;

intpoint;

inttemp;//临时变量

ChangeTimes=0;

for（j=0;j

for（i=0;i

DataShowEnable[j][i]=false;//初始化为false，表示没有要显示的数据

for（i=0;i

{

count[i]=0;

}

for（i=0;i

{

//增加count

for（j=0;j

count[j]++;

find=false;//表示块中有没有该数据

for（j=0;j

{

if（Block[j]==Data[i]）

{

count[j]=0;

find=true;

}

}

if（find）continue;//块中有该数据，判断下一个数据

//块中没有该数据

ChangeTimes++;//缺页次数++

if（（i+1）>M）//因为i是从0开始记，而BlockNum指的是个数，从1开始，所以i+1

{

//获得要替换的块指针

temp=0;

for（j=0;j

{

if（temp

{

temp=count[j];

point=j;//获得离的最远的指针

}

}

}

elsepoint=i;

//替换

Block[point]=Data[i];

count[point]=0;

//保存要显示的数据

for（j=0;j

{

DataShow[j][i]=Block[j];

DataShowEnable[i

（j<=i?

j:

i）:

j][i]=true;//设置显示数据

}

}

//输出信息

cout<

cout<<"LRU=>"<

DataOutput（）;

}

6、分析与思考

比较不同实页数下的页面命中率，FIFO和LRU两种置换算法的稳定性方面可以得出何种结论？

答：

先进先出（FIFO）算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。

该算法实现简单只需把一个进程已调入内存的页面，按先后次序链接成一个队列，并设置一个指针，称为替换指针，使它总是指向最老的页面。

但该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如，含有全局变量、常用函数、例程等的页面，FIFO算法并不能保证这些页面不被淘汰。

FIFO置换算法性能之所以较差，是因为它所依据的条件是各个页面调入内存的时间，而页面调入的先后并不能反映页面的使用情况。

最近最久未使用（LRU）置换算法，是根据页面调入内存后的使用情况进行决策的。

由于无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的近似，因此，LRU置换算法是选择最近最久未使用的页面予以淘汰。

该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t,，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。

最佳（OPT）页面置换算法是所有算法中产生页错误率最低的，而且绝对没有Belady异常的问题。

它会置换最长时间不会使用的页。

最佳页面（OPT）置换算法，是根据最长时间不会使用的页来决策的。

这就意味着，需要注意内存中的页面和页面的距离了。

因此OPT算法是选择最久未使用的页面进行淘汰的。

该算法赋予内存中每个页面一个访问字段，用来记录距离此处的最近页面的距离，这样通过比较，就能把最久未使用的页面淘汰掉。

7、实验心得与体会

这次实验，通过请求页式虚存管理中对页面置换算法的模拟，加深了对于虚拟存储技术的特点的理解，并且加深了对请求页式虚存管理的页面调度算法的理解。

最佳（Optimal）置换算法，选择“以后用不再使用的”或“在最长未来时间内不再被访问”的页面被置换，使用OPT算法通常可以保证获得最低的缺页率；先进先出（FIFO）页面置换算法，选择进入内存最早的页面被置换，实现简单，功能较差；最近最近未使用（LRU）置换算法，无法预测各页面将来的使用情况，只能利用“最近的过去”作为“最近的将来”的相似，即选择最近最久未使用的页面予以淘汰。

通过这次实验，更加加深熟悉了OPT，FIFO，LRU三种页面分配和置换算法的过程。