山东大学操作系统实验七.docx

山东大学操作系统实验七.docx

《山东大学操作系统实验七.docx》由会员分享，可在线阅读，更多相关《山东大学操作系统实验七.docx（17页珍藏版）》请在冰豆网上搜索。

山东大学操作系统实验七

软件学院操作系统实验报告

实验题目：

实验七、内存页面置换算法实验

学号：

201100300124

日期：

2013年05月31日

班级：

5班姓名：

韩俊晓

Email：

hanjunxiao188@

实验目的：

加深对于存储管理的了解，掌握虚拟存储器的实现原理；观察和了解重要的页面置换算法和置换过程。

练习模拟算法的编程技巧，锻炼分析试验数据的能力。

实验要求：

请在以上示例实验程序中补充“增强二次机会”等置换算法的模拟程序。

输入不同的内存页面引用串和实存帧数，观察并分析其页面置换效果和性能，并将其与LRU和FIFO算法进行比较。

改进以上示例实验程序，使之能够随机的产生内存页面引用串，以便能动态的观测各种置换算法的性能。

硬件环境：

实验室计算机

软件环境：

Ubuntu08.4－Linux操作系统

BASH_VERSION='3.2.33

（1）-release

gccversion4.1.2

gedit2.18.2

OpenOffice2.3

实验步骤：

1.实验说明：

1.示例实验程序中模拟两种置换算法：

LRU算法和FIFO算法

2.能对两种算法给定任意序列不同的页面引用串和任意帧实内存块数的组合测试，显示页置换的过程。

3.能统计和报告不同置换算法情况下依次淘汰的页号、缺页次数（页错误数）和缺页率。

比较两种置换算法在给定条件下的优劣。

4.为了能方便的扩充页面置换算法，更好的描述置换过程，示例实验程序采用了C++语言用Replace类描述了置换算法及其属性。

2.调试过程：

1）建立vmrp.cc程序，将代码写到程序中；

2）再建立以下名为vmrp.h的C语言头文件：

#include

#include

#include

usingnamespacestd;

classReplace{

public:

Replace（）;

~Replace（）;

voidInitSpace（char*MethodName）;//初始化页号记录

voidReport（void）;//报告算法执行情况

voidFifo（void）;//先进先出算法

voidLru（void）;//最近最旧未用算法

voidClock（void）;//时钟（二次机会）置换算法

voidEclock（void）;//增强二次机会置换算法

voidLfu（void）;//最不经常使用置换算法

voidMfu（void）;//最经常使用置换算法

private:

int*ReferencePage;//存放要访问到的页号

int*EliminatePage;//存放淘汰页号

int*PageFrames;//存放当前正在实存中的页号

intPageNumber;//访问页数

intFrameNumber;//实存帧数

intFaultNumber;//失败页数

int*Referencebit;//引用位

int*count;

int*Modifybit;//修改位

};

3）建立以下项目管理文件Makefile

head=vmrp.h

srcs=vmrp.cc

objs=vmrp.o

opts=-w-g-c

all:

vmrp

vmrp:

$（objs）

g++$（objs）-ovmrp

vmrp.o:

$（srcs）$（head）

g++$（opts）$（srcs）

clean:

rmvmrp*.o

4）输入make命令编译连接生成可执行的vmrp程序

$gmake

g++-g-cvmrp.ccvmrp.h

g++vmrp.o-ovmrp

5）执行程序

实验代码：

#include"vmrp.h"

Replace:

:

Replace（）{

inti;

//设定总得访问页数,并分配相应的引用页号和淘汰页号记录数组空间

cout<<"Pleaseinputpagenumbers:

";

cin>>PageNumber;//存放要访问到的页号

ReferencePage=newint[sizeof（int）*PageNumber];//访问页数

EliminatePage=newint[sizeof（int）*PageNumber];//存放淘汰页号

cout<<"Pleaseinputreferencepagestring:

";

for（i=0;i

cin>>ReferencePage[i];

cout<<"Pleaseinputpageframes:

";

cin>>FrameNumber;//实存帧数

PageFrames=newint[sizeof（int）*FrameNumber];//存放当前正在实存中的页号

Referencebit=newint[sizeof（int）*FrameNumber];//引用位

count=newint[sizeof（int）*FrameNumber];

Modifybit=newint[sizeof（int）*FrameNumber];//修改位

}

Replace:

:

~Replace（）{

}

voidReplace:

:

InitSpace（char*MethodName）

{

inti;

cout<

FaultNumber=0;//失败页数

//引用还未开始,-1表示无引用页

for（i=0;i

EliminatePage[i]=-1;//淘汰页号初始都设为-1

for（i=0;i

PageFrames[i]=-1;//存放当前正在实存中的页号

Referencebit[i]=0;//未被使用引用位设置为0

count[i]=0;//计数

Modifybit[i]=0;//修改位初始为0

}

}

//分析统计选择的算法对于当前输入的页面走向的性能

voidReplace:

:

Report（void）{

//报告淘汰页顺序

cout<

";

for（inti=0;EliminatePage[i]!

=-1;i++）cout<

//报告缺页数和缺页率

cout<

cout<

cout<<"Rateofpagefaults="<<100*（float）FaultNumber/（float）PageNumber<<"%"<

}

//最近最旧未用置换算法

voidReplace:

:

Lru（void）

{

inti,j,k,l,next;

InitSpace（"LRU"）;//初始化页号记录

//循环装入引用页

for（k=0,l=0;k

next=ReferencePage[k];

//检测引用页当前是否已在实存

for（i=0;i

if（next==PageFrames[i]）{//与当前正在实存中的页号比较

//引用页已在实存将其调整到页记录栈顶

next=PageFrames[i];

for（j=i;j>0;j--）PageFrames[j]=PageFrames[j-1];

PageFrames[0]=next;

break;

}

}

if（PageFrames[0]==next）{

//如果引用页已放栈顶，则为不缺页，报告当前内存页号

for（j=0;j

if（PageFrames[j]>=0）cout<

cout<

continue;//继续装入下一页

}

else

//如果引用页还未放栈顶，则为缺页，缺页数加1

FaultNumber++;

//栈底页号记入淘汰页数组中

EliminatePage[l]=PageFrames[FrameNumber-1];

//向下压栈

for（j=FrameNumber-1;j>0;j--）PageFrames[j]=PageFrames[j-1];

PageFrames[0]=next;//引用页放栈顶

//报告当前实存中页号

for（j=0;j

if（PageFrames[j]>=0）cout<

//报告当前淘汰的页号

if（EliminatePage[l]>=0）

cout<<"->"<

else

cout<

}

//分析统计选择的算法对于当前引用的页面走向的性能

Report（）;

}

//先进先出置换算法

voidReplace:

:

Fifo（void）{

inti,j,k,l,next;

InitSpace（"FIFO"）;

//循环装入引用页

for（k=0,j=l=0;k

next=ReferencePage[k];

//如果引用页已在实存中，报告实存页号

for（i=0;i

if（i

for（i=0;i

cout<

continue;//继续引用下一页

}

//引用页不在实存中，缺页数加1

FaultNumber++;

//最先入页号记入淘汰页数组

EliminatePage[l]=PageFrames[j];

PageFrames[j]=next;//引用页号放最先入页号处

j=（j+1）%FrameNumber;//最先入页号循环下移

//报告当前实存页号和淘汰页号

for（i=0;i

if（PageFrames[i]>=0）cout<

if（EliminatePage[l]>=0）

cout<<"->"<

else

cout<

}

Report（）;

}

//时钟（二次机会）置换算法

voidReplace:

:

Clock（void）

{

intj,i,k,l,next;

InitSpace（"Clock"）;

for（k=0,j=l=0;k

next=ReferencePage[k];

for（i=0;i

//检测引用页当前是否已在实存

if（next==PageFrames[i]）{

Referencebit[i]=1;//引用位设置为1

break;

}

if（i

for（i=0;i

cout<

continue;

}

if（Referencebit[j]==1）{//如果引用位为1

Referencebit[j]==0;//在判断之后，重新设置成0

}

EliminatePage[l]=PageFrames[j];//最先入页号记入淘汰页数组

PageFrames[j]=next;//引用页号放最先入页号处

Referencebit[j]=1;//引用位设置为1

FaultNumber++;//缺页数加1

j=（j+1）%FrameNumber;//最先入页号循环下移

for（i=0;i

if（PageFrames[i]>=0）cout<

if（EliminatePage[l]>=0）

cout<<"->"<

else

cout<

}

Report（）;

}

//增强二次机会置换算法

voidReplace:

:

Eclock（void）

{

intj,i,k,l,next;

InitSpace（"EClock"）;

for（k=0,j=l=0;k

next=ReferencePage[k];

//循环装入引用页

for（i=0;i

//检测引用页当前是否已在实存

if（next==PageFrames[i]）{

Referencebit[i]=1;//引用位设置为1

count[i]++;

//如果被引用了两次，就把修改位设置成1

if（count[i]%2==0）

Modifybit[i]=0;//修改位设置为0

else

Modifybit[i]=1;

break;

}

if（i

for（i=0;i

cout<

continue;

}

if（Referencebit[j]==1）{

Referencebit[j]==0;

}

if（Modifybit[j]==1）{

Modifybit[j]=0;

}

intmin=10*Referencebit[j]+Modifybit[j];

intindex=j;

for（i=0;i

if（10*Referencebit[i]+Modifybit[i]

min=10*Referencebit[i]+Modifybit[i];

index=i;

}

}

EliminatePage[l]=PageFrames[index];

PageFrames[index]=next;

Referencebit[index]=0;

Modifybit[index]=1;

count[index]=0;

FaultNumber++;//引用页不在实存中，缺页数加1

j=（j+1）%FrameNumber;//最先入页号循环下移

for（i=0;i

if（PageFrames[i]>=0）cout<

if（EliminatePage[l]>=0）

cout<<"->"<

else

cout<

}

Report（）;

}

//最不经常使用置换算法

voidReplace:

:

Lfu（void）

{

intj,i,k,l,next;

InitSpace（"Lfu"）;

for（k=0,j=l=0;k

next=ReferencePage[k];

for（i=0;i

if（next==PageFrames[i]）{

count[i]++;//记录使用次数

break;

}

if（i

for（i=0;i

cout<

continue;

}

FaultNumber++;

intmin=count[0];

intindex=0;

for（i=0;i

if（count[i]

min=count[i];

index=i;

}

}

EliminatePage[l]=PageFrames[index];//最不经常使用的页号记入淘汰页数组

PageFrames[index]=next;

count[index]=1;

for（i=0;i

if（PageFrames[i]>=0）cout<

if（EliminatePage[l]>=0）

cout<<"->"<

else

cout<

}

Report（）;

}

//最经常使用置换算法

voidReplace:

:

Mfu（void）

{

intj,i,k,l,next;

InitSpace（"Mfu"）;

for（i=0;i

count[i]=1;

for（k=0,j=l=0;k

next=ReferencePage[k];

for（i=0;i

if（next==PageFrames[i]）{

count[i]++;

break;

}

if（i

for（i=0;i

cout<

continue;

}

FaultNumber++;

intmax=count[0];

intindex=0;

for（i=0;i

if（count[i]>max）{

max=count[i];

index=i;

}

}

EliminatePage[l]=PageFrames[index];

PageFrames[index]=next;

count[index]=0;

for（i=0;i

if（PageFrames[i]>=0）cout<

if（EliminatePage[l]>=0）

cout<<"->"<

else

cout<

}

Report（）;

}

intmain（intargc,char*argv[]）{

Replace*vmpr=newReplace（）;

vmpr->Lru（）;

vmpr->Fifo（）;

vmpr->Clock（）;

vmpr->Eclock（）;

vmpr->Lfu（）;

vmpr->Mfu（）;

return0;

}