虚拟内存页面置换算法实验报告

虚拟内存页面置换算法实验报告（通用5篇）

篇1：虚拟内存页面置换算法实验报告

软

件

学

院

上

机

实

验

报

告

课程名称：

操作系统原理

实验项目：

虚拟内存页面置换算法

实

验

室：

地狱 018

姓

名 :

死神

学

号：

专业班级 :

实验时间：

2015/12 ／ 13

实验成绩 评阅教师

一、

实验目得及要求

通过这次实验，加深对虚拟内存页面置换概念得理解,进一步掌握先进先出 FIFＯ、最佳置换ＯPI 与最近最久未使用ＬRU 页面置换算法得实现方法。结合 Lｉｎux 得内层得分析方法查瞧内存得分配过程及 linuｘ keｒnel 得内存管理机制 二、实验性质

设计性 三、实验学时

学时 四、实验环境

实验环境１、实验环境：

C 与Ｃ++程序设计学习与实验系统 2、知识准备:（１）使用 Linuｘ得基本命令；(2）了解 Liｎｕx vｍｓtat、freｅ、toｐ等命令查瞧ｌinuｘ系统得内存分配情况；（3）

掌握虚拟内存页面置换算法 FＩＦO 等基本算法理论。

五、

实验内容及步骤

假设有ｎ个进程分别在 T1, … ,Ｔｎ时刻到达系统，它们需要得服务时间分别为S1，… ,Sｎ。分别采用先来先服务 FCＦS 与短作业优先 SJF 进程调度算法进行调度，计算每个进程得完成时间、周转时间与带权周转时间,并且统计 n 个进程得平均周转时间与平均带权周转时间。

步骤

通过已知最小物理块数、页面个数、页面访问序列、及采用置换方式可以得出页面置换得缺页次数与缺页率，及每次缺页时物理块中存储。

１．输入得形式

ﻩinｔ

PagｅOrder［MａxNumbｅr]；//页面序列 ｉｎt

ＰaｇeNｕm，LacｋNum=０,BlockNｕｍ;／／页面个数，缺页次数,最小物理块数 2、输出得形式 doubｌe

LackPaｇｅRａte／/缺页率 缺页个数 每次缺页时物理块中存储

程序所能达到得功能 模拟先进先出 FＩFO、最佳置换 OPＩ与最近最久未使用 LRＵ页面置换算法得工作过程.假设内存中分配给每个进程得最小物理块数为ｍ，在进程运行过程中要访问得页面个数为 n，页面访问序列为Ｐ1, …，Ｐn,分别利用不同得页面置换算法调度进程得页面访问序列，给出页面访问序列得置换过程，计算每种算法缺页次数与缺页率。测试数据,包括正确得输入及其输出结果与含有错误得输入及其输出结果。

程序中用到得所有抽象数据类型得定义、主程序得流程以及各程序模块之间得层次（调用)关系.inｔ

PagｅOrdeｒ[MaxNumｂer］;//页面序列 int

ＰａgeCoｕnt[MaxＮｕmｂer]={0｝；//计算内存内数据离下一次出现得距离 int

PａｇeNum,LackNuｍ＝0，ＢｌｏcｋNum;//页面个数,缺页次数,最小物理块数 douｂｌｅ

LaｃkPａｇeRaｔe＝0； bool ｆｏｕnd＝ｆａlsｅ;

六、实验数据及结果分析

运行截图：

图６、1

图６、2

图６、3 七、实验总结

这次试验,让我加深了对虚拟内存页面置换算法得理解，进一步掌握先进先出 FIFO、最佳置换 OＰI 与最近最久未使用 LＲU 页面置换算法得实现方法。熟悉 Linuｘ需要经过大量得实验、改进与思考，在编写代码得过程中遇到了一些问题要积极面对并通过讨论上网或者问老师解决。通过这次试验我了解了虚拟内存置换算法得一些知识,就是我对于所学习得专业知识得到了更好得巩固与提升。

附录 源程序清单 ＃iｎclude ＜iｏｓｔｒeam> using namespace ｓｔｄ;#ｄｅｆinｅ ＭａxNumbｅr 100 void OＰI（int

PａgeOｒdｅｒ[MaxNuｍber］,iｎt

PａｇeCoｕnt［MａxＮumber]，ﻩ

int

PagｅＮｕm,ｉnｔ LackNum，int ＢlockNum，double

LacｋＰａgｅＲate,bｏol ｆound）

{

ｉnt moｄｕle［MaxNumber]；

iｎt sｕm＝0；

int i，j，k,ｍ;

fｏr(i=0;i

｛

moduｌe［ｉ］=ＰaｇeＯｒder[i］；

;＋＋ｍuｓﻩﻩ)++ｊ；i＝

cｏuｔ<〈module[j］<〈”

＂;

；ldne<〈tｕocﻩ

｝

LackNuｍ=ＢｌoｃkNum；

foｒ(i=BlockNuｍ；i〈ＰageNum；i+＋）

｛

foｕnd=false;

fｏr（j=0;ｊ<ＢlockＮｕｍ；j＋+）//遍历已存储,判断就是否缺页

｛

ﻩ ﻩﻩ

ｉf（module[ｊ]==ＰａgｅOrder［ｉ］)

{

ﻩﻩ

foｕnd=true;

ﻩ

ﻩ

breaｋ;

ﻩ

｝

ﻩﻩ ｝

ﻩ

if（found==faｌse)//缺页,选择替换

{

ﻩ

ｆor（j＝０；ｊ〈ＢlockＮｕm；j+＋）

/／计算内存内数据离下一次出现得距离

｛

PａgｅCｏｕnt［ｊ]=０;

ｆoｒ(k=i＋１；k

｛

ﻩﻩﻩ ﻩ

ﻩ

iｆ（module[j］!＝PageＯｒder[k])

ﻩﻩ

PageCｏunt［j]++；

ﻩ

esleﻩ

；kaｅrｂﻩ

｝

ﻩ

}

;］０[tｎuｏCegaP=xａm ｔnｉﻩ

iｎt kｉnｄ=0；

值大最出找/／）+＋j;muNkcolB〈j；0=j（rofﻩ

{

ﻩ

if（PａｇeＣoｕｎｔ[j］>ｍax）

ﻩ

｛

ﻩﻩ

；]j[tnuoＣｅgaP＝xamﻩﻩ ﻩ

ﻩ

kiｎｄ＝j；

ﻩ

｝

ﻩ

｝

module［kiｎd］=PａgｅOrder［i]；

ﻩ

LackNum++；）++ｍ;3

；”

”＜<］ｍ［elｕdom<〈tuocﻩﻩ

ﻩ；lｄｎｅ＜

ﻩ

｝

LａｃkPａgeRate＝（LackＮuｍ＊1、0)／PageNum；

cｏut〈〈“该算法缺页次数为：＂＜〈LackNum<＜eｎdｌ；

coｕt＜<”该算法缺页率为：＂〈＜LackPａｇｅRａte*100＜〈＇％”〈〈enｄl;｝ /＊＊＊＊＊＊*＊**＊＊***＊*＊＊**＊＊***＊***先进先出置换算法＊＊*＊*＊*＊＊＊＊**＊*＊＊＊＊＊＊*＊＊＊＊**＊＊*＊＊*＊*＊/ vｏid FIFO(int

PagｅOrｄeｒ[MａxNｕmber],int

PａｇｅCounｔ［ＭaｘNuｍber］，egaPkｃaＬ

eｌbuod ,muNkcolB ｔni，mｕNｋcaL tni，muNｅｇａP

tniﻩＲate，booｌ ｆound)｛

int module[ＭａxNumber］;

iｎt sum=0；

int ｉ，j，ｍ;

for(ｉ=0;ｉ〈BlocｋＮum；ｉ+＋）//将内存填满

{

modｕlｅ［ｉ］＝PageOrｄeｒ［ｉ］；

；++musﻩﻩ

PagｅCoｕnt[i]=３-i;）++j；ｉ=＜ｊ；0=ｊ（roｆﻩ

couｔ<<ｍｏdule[j]<<＂

“；

ｃout<＜enｄl;

}

LackNuｍ=BlockNum；

foｒ（i＝BlocｋNｕm；i〈PａgeＮuｍ;i++）

｛

fouｎｄ=fａlse；

ｆor（ｊ=0；j〈ＢlockNuｍ;j++)/／遍历已存储，判断就是否缺页

{

ﻩ

ｉf(module［j]==ＰａgeOrder[i］)

ﻩ

{

ﻩ

；eurt=dｎuofﻩﻩ ﻩ

breａk;

}

}

if（found==falｓｅ)//缺页，选择替换

｛

ﻩ

；]0［tnuoCｅgaＰ＝xam ｔｎiﻩ

ｉnｔ ｋind=０；

值大最出找//）＋+ｊ;muNkcolB〈ｊ；０=j（rｏfﻩ

｛

ﻩ

ｉf(PａgeCoｕnt［j]＞max）

｛

;］ｊ[tnuoCegａP=xａmﻩﻩ ﻩﻩ

kiｎd=j；

｝

ﻩﻩﻩ

}

ﻩ

foｒ(inｔ k＝0;k＜BlocｋＮuｍ；ｋ++）／/不就是最大值，则要+1

ﻩ

{

ﻩ

ﻩ

ｉf（k！=kind)

PagｅCｏunt［k]++；

ﻩ

｝

ﻩ

moｄuｌe［kｉｎd］=PageOｒder［i］；

PageＣouｎt［kiｎd]=０；// 替换之后已经查询得次数改为0

LackNum++;

ﻩ

ｆor（m=０； m〈3；m++）

ﻩ

;”

”<〈］m[eludｏm〈

;ldne〈〈ｔuocﻩﻩ ｝

ﻩ ｝ ﻩ

LａｃkPageＲate=（ＬackNｕm*１、0）/ＰagｅNuｍ；

cout〈〈“该算法缺页次数为：”<＜LackNuｍ<

cｏuｔ＜<”该算法缺页率为:＂<

PaｇeＯrdｅr[MaxＮumbｅｒ]，int

PａｇeCoｕnｔ［ＭaxNumｂｅr］，ｅｇaPｋcａL

elｂuod，muＮkｃｏlB tni,mｕNkcaL tni,muNegaＰ

tniﻩﻩＲate,bool found){

int moｄuｌe[MａxNuｍｂer］；

inｔ sum＝0;

int i，j,m;

for（ｉ=0；i＜BｌockNum；i＋+)//将内存填满

{

moduｌe[ｉ]=PaｇeOｒdeｒ[i];

ﻩ

sｕm++；

ＰageCouｎt［i］=3—i；)＋+ｊ；i=＜j；0=j(roｆﻩ

cout〈〈mｏdule[j]〈〈”

”;

;ldne〈<ｔuocﻩﻩ

｝

LａckＮum＝ＢｌockＮuｍ;

foｒ(ｉ=ＢlｏｃｋＮｕm；ｉ

｛

ｆouｎd=ｆaｌse;

fｏｒ（j=０；j＜BlockNum；j++)/／遍历已存储,判断就是否缺页

{

ﻩ

if(module［j]==PageOｒder［i］）

ﻩﻩ

｛

ﻩ

fｏund=truｅ；

ＰagｅCｏuｎt［ｊ]=０；//查询后，更改次数

ﻩﻩ

ｆor（iｎｔ k=0;k〈BlockＮuｍ；k++）

ﻩ

{

ﻩﻩ ﻩﻩ）j=！k（fiﻩﻩ

ＰａgeCｏuｎｔ[ｋ］+＋；

ﻩ

}

ﻩ

bｒｅａｋ;

ﻩ

｝

ﻩ

}

ﻩ

if(ｆounｄ＝=falsｅ）／／缺页,选择替换

｛

ﻩ

；］０[tnuoCegａP=ｘam tniﻩﻩ

iｎt kind=0；

值大最出找／/）＋＋j；mｕNkcｏｌB

ﻩﻩ)xaｍ〉]j［tnuoＣｅgaP（ｆｉﻩﻩ

{

ﻩ

ﻩ;]j[tnuoCegａP=xamﻩ

ﻩﻩ

kiｎd=ｊ;

｝

ﻩ ｝

ﻩﻩ

for（int k=0；k

｛

ﻩ

ｉf(k！=ｋind）

PagｅCounｔ［ｋ]+＋；

ﻩﻩ

｝

ﻩ

mｏdule[kind]＝PageOrder［i］;

PageCoｕnt[ｋiｎｄ]＝0；// 替换之后未查询得次数改为0

;++ｍｕNkcaLﻩﻩ

for（m＝0； ｍ<3;ｍ++）

ﻩ

coｕt〈

”；

ﻩ;ldne<〈ｔｕｏcﻩ ｝

ﻩ } ﻩ

LackPagｅRate=(LackＮｕm*1、0)/PaｇeNｕm;

ｃoｕｔ<〈“该算法缺页次数为:＂＜

couｔ〈＜”该算法缺页率为：”〈＜LackPａgeRate＊100〈＜“%’＜＜ｅｎdl;} int main（）

{

iｎt

PageＯｒｄer［MaｘNumｂer]；//页面序列

inｔ

PaｇeCoｕnt[ＭａxＮumｂｅｒ]＝｛0｝;/／计算内存内数据离下一次出现得距离

inｔ

PagｅＮum，ＬackNuｍ＝0，BlocｋNum;//页面个数,缺页次数，最小物理块数

;0=etaＲegaPkcａL

eｌｂuoｄﻩ bool foｕｎd=false;

;3ecoｉhc,2eｃoihc,０=１ecoiｈc tniﻩ

ｉnt i=０；）０==1ecoihc（eliｈｗﻩ ｛

；”:入输新重:１,入输不:0；据数入输新重否是就“〈〈tｕocﻩ cｉｎ〉>chioｃe2；

if（ｃhｉoｃｅ2==１）

｛ﻩ

couｔ<＜”请输入页面个数:”；

;muNegａＰ >>nicﻩ;“数块理物小最入输请”〈〈tuoｃﻩ ；muNｋcolB>>niｃﻩ cｏut<〈”请输入页面序列：”<

for（i=０;ｉ〈ＰaｇｅNｕｍ；i++）

;]ｉ[ｒedrOegａP>〉nicﻩ ｝ﻩ;”：ＵRL-3，IＰO—2，ＯFIF-1：法算择选请＂<

iｆ（chiocｅ3==1)

ｃｏlB，muNkcaL,muNeｇaP，tnuoCｅgａP,reｄｒＯｅgaＰ(OＦIＦﻩkNｕm，LackPageRａte，founｄ);

eｌse

｛

ｉｆ（chioｃe3==2）

ｃｏｌB ,muNkcaＬ，muＮｅgａP,tnuｏＣｅｇaＰ，ｒedｒOegaP（IPOﻩｋNum，LaｃkＰageRａｔe, fｏｕnd)；

esｌeﻩ

，ｍｕNkcolB ,muＮｋcaL，mｕＮegaP，tｎuoCegａP,redrOｅgａP(UＲＬﻩLackPaｇｅRａｔe，ｆound）;

｝ ＊＊＊***＊＊*＊*＊****＊＊****＊＊*＊＊＊*＊*＊＊＊**＊“〈＜tｕｏcﻩ******＊*＊***＊＊***＊＊*＊＊*＊＊***”<＜endｌ；

;＂束结：１，续继:0:束结是就还续继择选请"＜ｃhｉoｃe１;

｝ ｝

篇2：虚拟内存页面置换算法实验报告

实验报告

班级：计科姓名：张华敏学号：

0902班

0909090814

FIFU算法

一，实验内容：

编写一段程序来模拟页面置换算法中的FIFU算法的实现 二，算法设计：

设置一个产生随机数的函数rand()产生随机数来模拟程序所需访问的页面的标号，如果页面需要被访问则把页面中的一个标志位设为in表示他已经被调入内存，如果再次需要访问此页面是只需检查此页面的标志位是否为in就可判断它是否已经存在在内存中了，如果已经存在则可直接使用，如果不存在则需调入，在调入新页面是先检查内存空间是否已满，如果未满则直接调入，如果已经满了则需选择一个页面将其调出，调出时就把页面的标志位设为out。选择页面的规则是：将进入内存时间最久的页面调出去，为了达到这一目的，在页面中设置一个计数器，每当有新页面调入内存时则将内存中已经存在的页面计数器自动加一，调出页面时就选择那个计数器最大值的页面，调出后重新将计数器设为零。三，遇到的问题及解决方案：

在做此实验时遇到了一些小问题,如在C语言中函数名定义为export()则会报错。在调用有返回值的函数是如果直接int s=use(pag)则会运行出错,要先分开写如：int s,s=use(pag).四，源代码 头文件.cpp #include #include

int t;//全局变量，用来盛放rand()函数产生的随机数

enum boolean{in,out};//定义一个枚举类型 /////////如果把in，out换成 true,false则会处错误

typedef struct { int num;//页面编号 char content;//页面内容

enum boolean flog;//判断此页面是否页调入，调入为true,否则为false;int count;//页面计数器

int usebit;//使用位，被使用过值为1，否则为0 }page;

FIFU.cpp #include #include #include #include“头文件.cpp”

int capacity=3;//设置内存最多可以容纳的页面数

void initialize(page p[])//初始化页面函数 { for(int i=0;i<5;i++)//初始化页面，页面内容分别为小写字母 abcde,计数器全部为0 {p[i].num=i;p[i].content=i+97;p[i].flog=out;p[i].count=0;} }

int use(page p[]){ t=rand()%5;//产生一个0-5的随机数，if(p[t].flog==in){ printf(“tt%d页面命中n”,t);//for(int i=0;i<5;i++)//调入此页面后其他以在内存中存在的页面计数器加1 // { // if(p[i].flog==in)// p[i].count++;// } return(1);} else return(0);}

void import(page p[])//调入页面的函数 { /* int t=rand()%5;//产生一个0-5的随机数，if(p[t].flog==in)printf(“tt%d页面命中n”,t);*/ // if(p[t].flog==out)//如果此页面未被调入内存则立即调入 p[t].flog=in;capacity--;//调入后内存空间减少一叶

for(int i=0;i<5;i++)//调入此页面后其他以在内存中存在的页面计数器加1 { if(p[i].flog==in&&p[i].num!=t)p[i].count++;} printf(“页面%d被调入内存n”,t);}

void port(page p[])//调出页面的函数，，，，，，，，，，，如果函数名定义为export则处错误 { int x=0,y;//x用来暂时存放计数器 中的最大值，y存放此页面的页面号 for(int i=0;i<5;i++)//寻找计数器值最大的 页面 { if(p[i].count>x){ x=p[i].count;y=i;} }

p[y].flog=out;//修改调入符号 p[y].count=0;capacity++;//调入后内存空间增加一叶 printf(“ttt页面%d被调出内存n”,y);}

main(){ int s;long t3,t1,t2;page pag[5];//定义五个页面，，，，，，，，，，，如果这个定义在子函数之前那么不用通过参数 子函数便可以直接访问 t3=time(NULL);initialize(pag);do { t1=time(NULL);s=use(pag);//，，，，，，，，，，，，，，如果这里写成int s=use(pag)则会运行出错

//printf(“s=%d capacity=%dn”,s,capacity);if(capacity>0&&s==0)import(pag);else { if(capacity==0&&s==0){ port(pag);import(pag);} } t2=time(NULL);while(t2-t1<1){ t2=time(NULL);} }while(t2-t3<20);system(“pause”);}

五，测试结果：

LFU算法

一,实验内容：

编写一段程序来模拟页面置换算法中的LFU算法的实现 二,算法设计：

设置一个产生随机数的函数rand()产生随机数来模拟程序所需访问的页面的标号，如果页面需要被访问则把页面中的一个标志位设为in表示他已经被调入内存，如果再次需要访问此页面是只需检查此页面的标志位是否为in就可判断它是否已经存在在内存中了，如果已经存在则可直接使用，如果不存在则需调入，在调入新页面是先检查内存空间是否已满，如果未满则直接调入，如果已经满了则需选择一个页面将其调出，调出时就把页面的标志位设为out。选择页面的规则是：将最近一段时间未被访问过的页面调出。为了达到这一目的在页面中设置一个标志位，如果页面在近期只要被访问过则将该标志位设置为1（默认为0），在选择调出页面时只需将标志位为0的页面调出即可。三,遇到的问题及解决方案： 未遇到什么问题

四,实验感悟：

遇到问题后上网查资料和有效,及时查不到自己想要的但是也可从相关结果中获得启发给自己灵感来想到解决问题的方法.四，源代码

FLU.cpp #include #include #include #include“头文件.cpp”

int capacity=3;

//设置内存最多可以容纳的页面数

void initialize(page p[])

//初始化页面函数

{

for(int i=0;i<5;i++)

//初始化页面，页面内容分别为小写字母 abcde,计数器全部为0

{p[i].num=i;

p[i].content=i+97;

p[i].flog=out;

p[i].count=0;

p[i].usebit=0;

}

}

int use(page p[]){

t=rand()%5;

//产生一个0-5的随机数，if(p[t].flog==in)

{

printf(“tt%d页面命中n”,t);

p[t].usebit=1;

//for(int i=0;i<5;i++)//调入此页面后其他以在内存中存在的页面计数器加1

//

{

//

if(p[i].flog==in)

//

p[i].count++;

//

}

return(1);

}

else

return(0);

}

void import(page p[])//调入页面的函数

{

int t=rand()%5;

//产生一个0-5的随机数，//if(p[t].flog==in)

// {

//

printf(“tt%d页面命中n”,t);

//

p[t].usebit=1;

// }

// if(p[t].flog==out)

//如果此页面未被调入内存则立即调入

p[t].flog=in;

capacity--;

//调入后内存空间减少一叶

for(int i=0;i<5;i++)//调入此页面后其他以在内存中存在的页面计数器加1

{

if(p[i].flog==in&&p[i].num!=t)

p[i].count++;

}

printf(“页面%d被调入内存n”,t);

}

void port(page p[])

//调出页面的函数

////////////////////////////////如果函数名定义为export则处错误

{

int x=0,y;//x用来暂时存放计数器 中的最大值，y存放此页面的页面号

int z=-1;

//用来判断近期是否有未被访问过的页面

int g=0;

for(int i=0;i<5;i++)//寻找计数器值最大的 页面

{

if(p[i].count>x)

{

x=p[i].count;

y=i;

}

}

for(int i=0;i<5;i++)

{

if(p[i].flog==in&&p[i].usebit==0)

{

z=i;

g++;

}

}

if(z==-1||g==3)//如果所有页面均为1则按照FIFO算法置换页面 //如果g=3则表明页面使用位全为零，此时也按照FIFO算法置换页面

{

p[y].flog=out;//修改调入符号

p[y].count=0;

capacity++;

//调入后内存空间增加一叶

p[y].usebit=0;

for(int i=0;i<5;i++)//将所有页面置0

p[i].usebit=0;

printf(“ttt页面%d被调出内存n”,y);

}

else

//如果有页面为0则将此页面置换出来

{

p[z].flog=out;//修改调入符号

p[z].count=0;

capacity++;

//调入后内存空间增加一叶

printf(“ttt页面%d被调出内存n”,z);

}

}

main(){

int s;

long t3,t1,t2;

page pag[5];//定义五个页面

///////////////////如果这个定义在子函数之前那么不用通过参数 子函数便可以直接访问

t3=time(NULL);

initialize(pag);

do

{

t1=time(NULL);

s=use(pag);

if(capacity>0&&s==0)

import(pag);

else

{

if(capacity==0&&s==0)

{

port(pag);

import(pag);

}

}

t2=time(NULL);

while(t2-t1<1)

{

t2=time(NULL);

}

}while(t2-t3<20);

system(“pause”);}

六,实验结果

总结

篇3：虚拟内存页面置换算法实验报告

姓名

学号

系

计算机

任课教师

指导教师

评阅教师

实验地点

综合楼B102

实验时间

2012-9-26

实验课表现

出勤和个人表现Q1(15+15（组长评分）=30分)

得分：

实验

总分

(Q1+Q2+Q3+Q4)

实验完成情况Q2(45分(组长与教师评分的加权平均))

得分：

实验编号与实验名称：

实验七、常用页面置换算法模拟实验

实验目的：

通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。

实验内容及要求（详见实验讲义与实验指导书）：

要求：

1）要求用你熟悉的程序设计语言编写和调试一个页面置换模拟程序；要求在主函数中测试。

2）实验报告中必须包括：设计思想、数据定义（包括详细说明）、处理流程（详细算法描述和算法流程图）、源代码、运行结果、体会等部分。

3）必须模拟本实验内容中提到的算法中的至少2种页面置换算法。

4）

比较不同页面置换算法的效率

内容：编写一个程序，使用以下页面置换算法中的某2种分别模拟一个分页系统，并统计同一个页面访问序列情况下不同页面置换算法引发的缺页中断次数。

1、第二次机会算法（Second

Chance）

2、最近最少使用算法（Least

Recently

Used，LRU）

3、最不常用算法（Not

Frequently

Used，NFU）

4、最近未使用算法（Not

Recently

Used，NRU）

5、时钟页面置换算法

6、老化算法（aging）

页框的数量固定为4，虚拟页面数为8。实验输入为访问页面序列，比如0，1，3，2，7，1

实验用到的软件（：）

DevC++,Visio

实验内容及关键步骤（代码）Q3（15分）

得分：

流程图：输入页面访问序列

取访问的页号

查页表

是否缺页？

是

置缺页标志flag为’*’

按算法不同淘汰一页面

调入所访问的页面

否

FIFO算法流程图

LRU算法流程图：

函数关系解释图：

实现结果：

图1

图2

代码：

#include

#include

#define

MEMORY_SIZE

/*物理块数*/

#define

PROESS_SIZE

/*页面号引用串个数*/#include

#include

/*全局变量*/

int

mSIZE=4;

int

pSIZE=8;

static

int

memery[4]={0};

/*物理块中的页号*/

static

int

page[8]={0};

/*页面号引用串*/

static

int

temp[8][4]={0};

/*辅助数组*/

/*置换算法函数*/

void

FIFO();

void

LRU();

void

OPT();

void

designBy();

/*辅助函数*/

void

print(unsigned

int

t);

/*主函数*/

int

main()

{

int

i,k,code;

designBy();

system(“color

0A“);

puts(“请依次输入页面号(8个)：“);

for(i=0;i

scanf(“%1d“,&page[i]);

system(“cls“);

system(“color

0E“);

do{

puts(“输入的页面号引用串为：“);

for(k=0;k<=(pSIZE-1)/20;k++)

{

for(i=20*k;(i

{

if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))

printf(“%d＼n“,page[i]);

else

printf(“%d

“,page[i]);

}

}

printf(“*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*＼n“);

printf(“*

请选择页面置换算法：＼t＼t＼t

*＼n“);

printf(“*

-----------------------------------------

*＼n“);

printf(“*

1.先进先出(FIFO)

2.最近最久未使用(LRU)

*＼n“);

printf(“*

3.退出

*＼n“);

printf(“*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*＼n“);

printf(“请选择操作：[

]＼b＼b“);

scanf(“%d“,&code);

switch(code)

{

case

1:

FIFO();

break;

case

2:

LRU();

break;

case

3:

system(“cls“);

system(“color

0A“);

exit(0);

default:

printf(“输入错误，请重新输入：“);

}

printf(“按任意键重新选择置换算法：>>>“);

getch();

system(“cls“);

}while

(code!=3);

getch();

}

void

print(unsigned

int

t)

{

int

i,j,k,l;

int

flag;

for(k=0;k<=(pSIZE-1)/20;k++)

{

for(i=20*k;(i

{

if(((i+1)%20==0)||(((i+1)%20)&&(i==pSIZE-1)))

printf(“%d＼n“,page[i]);

else

printf(“%d

“,page[i]);

}

for(j=0;j

{

for(i=20*k;(i{

if(i>=j)

printf(“

|%d|“,temp[i][j]);

else

printf(“

|

|“);

}

for(i=mSIZE+20*k;(i

{

for(flag=0,l=0;l

if(temp[i][l]==temp[i-1][l])

flag++;

if(flag==mSIZE)/*页面在物理块中*/

printf(“

“);

else

printf(“

|%d|“,temp[i][j]);

}

/*每行显示20个*/

if(i%20==0)

continue;

printf(“＼n“);

}

}

printf(“----------------------------------------＼n“);

printf(“缺页次数：%d＼t＼t“,t+mSIZE);

printf(“缺页率：%d/%d＼n“,t+mSIZE,pSIZE);

printf(“置换次数：%d＼t＼t“,t);

printf(“访问命中率：%d%%＼n“,(pSIZE-(t+mSIZE))*100/pSIZE);

printf(“----------------------------------------＼n“);

}

/*先进先出页面置换算法*/

void

FIFO()

{

int

memery[10]={0};

int

time[10]={0};

/*记录进入物理块的时间*/

int

i,j,k,m;

int

max=0;

/*记录换出页*/

int

count=0;

/*记录置换次数*/

/*前mSIZE个数直接放入*/

for(i=0;i

{

memery[i]=page[i];

time[i]=i;

for(j=0;j

temp[i][j]=memery[j];

}

for(i=mSIZE;i

{

/*判断新页面号是否在物理块中*/

for(j=0,k=0;j

{

if(memery[j]!=page[i])

k++;

}

if(k==mSIZE)

/*如果不在物理块中*/

{

count++;

/*计算换出页*/

max=time[0]

for(m=2;m

if(time[m]

max=m;

memery[max]=page[i];

time[max]=i;

/*记录该页进入物理块的时间*/

for(j=0;j

temp[i][j]=memery[j];

}

else

{

for(j=0;j

temp[i][j]=memery[j];

}

}

print(count);

}

/*最近最久未使用置换算法*/

void

LRU()

{

int

memery[10]={0};

int

flag[10]={0};

/*记录页面的访问时间*/

int

i,j,k,m;

int

max=0;

/*记录换出页*/

int

count=0;

/*记录置换次数*/

/*前mSIZE个数直接放入*/

for(i=0;i

{

memery[i]=page[i];

flag[i]=i;

for(j=0;j

temp[i][j]=memery[j];

}

for(i=mSIZE;i

{

/*判断新页面号是否在物理块中*/

for(j=0,k=0;j

{

if(memery[j]!=page[i])

k++;

else

flag[j]=i;

/*刷新该页的访问时间*/

}

if(k==mSIZE)

/*如果不在物理块中*/

{

count++;

/*计算换出页*/

max=flag[0]

for(m=2;m

if(flag[m]

max=m;

memery[max]=page[i];

flag[max]=i;

/*记录该页的访问时间*/

for(j=0;j

temp[i][j]=memery[j];

}

else

{

for(j=0;j

temp[i][j]=memery[j];

}

}

//

compute();

print(count);

}

/*显示设计者信息*/

void

designBy()

{

printf(“┏━━━━━━━━━━━━━━━━━━━━━━━━━┓＼n“);

printf(“┃㊣

实验七：页面置换算法

㊣┃＼n“);

printf(“┃

学号：1001010042

┃＼n“);

printf(“┃

姓名：黄浩全

4.9.9.0>┃＼n“);

printf(“┣━━━━━━━━━━━━━━━━━━━━━━━━━┫＼n“);

}

实验过程中遇到的问题解决办法与实验体会Q4（需手写，10分）

得分：

1、在FIFO算法可以很容易用数组实现，而LRU算法可以用数组实现，不过用结构体会更明显简单。结构体成员变量可以记录页号进入的时间，和最近使用的记录。相对比数组更容易理解和实现。

2:首先，FIFO（先进先出）算法和LRU（最近未使用算法）两者之间，FIFO算法明显会比LRU容易理解，而且比LRU算法较容易实现，但在性能方面，LRU的确在优化方面做的比较理想。再且在考虑页框和页表号之间的问题用代码可以容易模拟，但是真是在物理内存块中是如何实现，那确实是很难以理解，需要真正理解到内存内部的知识才知道这两个算法是怎么实现的。

评阅教师特殊评语：

评阅教师：

日

篇4：虚拟内存页面置换算法实验报告

一、实验目的

通过实验加强对虚拟存储管理中页面置换算法的理解和掌握。

二、实验内容

编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法。

三、实验要求

1、任意给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。

2、分配给该作业一定的物理块（如3块、4块等）。

3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。

4、每访问一个页面均需给出内存中的内容（内存中的页面号），若有淘汰还需给出淘汰的页面号。

5、通过给出特殊的页面访问顺序，分配不同的物理块，利用FIFO算法计算其缺页率，进一步理解Belady现象。

6、（附加）实现CLOCK置换算法，修改位可在确定页面号时直接任意给出。

程序代码（java）

package wcm4;

import java.util.LinkedList;import java.util.Scanner;

public class Test {

/**

* @param args

*/ LinkedList ll=new LinkedList();int a;int leng;int[] all={1,2,5,7,5,7,1,4,3,5,6,4,3,2,1,5,2};//int[] free=new int[all.length];

Object o=new Integer(a);public static void main(String[] args){

public void begin(){ System.out.println(“请选择测试类型：”);System.out.println(“1 OPT;2 FiFO;3 LRU;4 CLOCK;5退出”);

} public void need(){ System.out.println(“请输入分配给该作业的物理块数：”);Scanner sc=new Scanner(System.in);leng=sc.nextInt();Scanner sc=new Scanner(System.in);int choose=sc.nextInt();while(choose!=5){

} switch(choose){ case 1:this.opt();break;case 2:this.fifo();break;case 3:this.lru();break;case 4:this.clock();break;} System.out.println(“请选择测试类型：”);System.out.println(“1 OPT;2 FiFO;3 LRU;4 CLOCK;5退出”);sc=new Scanner(System.in);choose=sc.nextInt();// TODO Auto-generated method stub Test t=new Test();t.begin();

}

}

public void fifo(){ ll=new LinkedList();this.need();

int a=0;for(int i=0;i

o=all[i];if(!ll.contains(o)){

} if(ll.size()

} ll.add(o);o=ll.poll();a++;else{ o=null;} this.print();} System.out.println(“FIFO的缺页率为：”);System.out.println(a);System.out.println(“——”);System.out.println(all.length);

} public void opt(){//最佳置换算法

//leng=0;ll=new LinkedList();this.need();int a=0;//int temp=0;//int[] b=new int[leng];

for(int i=0;i

int[] b=new int[leng];o=all[i];if(!ll.contains(o)){ if(ll.size()

ll.add(o);

}

o=null;} else{ for(int j=i;j

Object o1=new Integer(all[j]);

}

for(int k=0;k

}

if(ll.get(k).equals(o1)){

}

if(b[k]==0){

b[k]=j;//待替换的页在以后第一次出现的位置

} } if(b[leng-1]==0){

o=ll.set(leng-1, o);a++;} else{ int temp=0;

}

for(int m=0;m

if(b[m]==0){ temp=m;break;}

else if(b[m]>b[temp]){ }

temp=m;

}

o=ll.set(temp, o);//替换以后离得最远的 a++;} else{ } o=null;this.print();} System.out.println(“OPT的缺页率为：”);System.out.println(a);System.out.println(“——”);System.out.println(all.length);

public void lru(){//最近最久未使用

}

public void clock(){//简单clock

ll=new LinkedList();this.need();int a=0;int[] b=new int[leng];for(int i=0;i

o=all[i];if(!ll.contains(o)){

if(ll.size()o=all[i];if(!ll.contains(o)){

if(ll.size()

} ll.add(o);o=ll.poll();a++;} else{ ll.add(o);ll.remove(o);o=null;} this.print();} System.out.println(“OPT的缺页率为：”);System.out.println(a);System.out.println(“——”);System.out.println(all.length);

}

} else{

for(int j=0;j<=ll.size();j++){

if(b[j%ll.size()]==0){

}

}

}

else{ int temp1=j%ll.size();

}

o=ll.set(temp1, o);

b[temp1]=0;//改变该位的标记位 break;

b[j%ll.size()]=1;a++;} else{ int temp=ll.indexOf(o);//找到该位

b[temp]=0;o=null;} this.print();System.out.println(“标记位为：”);for(int k=0;k

public void print(){ Object[] op=ll.toArray();for(int i=0;i

篇5：虚拟内存页面置换算法实验报告

此安全设置确定关闭系统时是否清除虚拟内存页面文件，

虚拟内存支持在内存页面未使用时使用系统页面文件将其交换到磁盘。在正在运行的系统上，此页面文件由操作系统以独占方式打开，并且受到很好的保护。但是，配置为允许启动到其他操作系统的系统可能要确保在此系统关闭时清除系统页面文件。这可确保可能会进入页面文件的进程内存中的敏感信息不会被设法通过直接访问页面文件的未经授权用户使用。

启用此策略会在干净关机时清除系统页面文件。如果启用此安全选项，在便携式计算机系统上禁用休眠时，休眠文件(hiberfil.sys)也会被清零。

设置步骤如下：

1)运行：gpedit.msc进入组策略对象编辑器，

2)如图依次打开如下内容：“计算机配置”---“Windows 设置”---“安全设置”---“本地策略”---“安全选项”---“关机：清除虚拟内存页面”。

3)右击“属性”点击“已启用”。

4)确定，这样设置就ok了。

对于没有组策略的同志解决方案如下：

1.win+r运行regedit。

2.浏览到

“HKEY_LOCAL_MACHINE/SYSTEM/CurrentControl/SetControlSession/ ManagerMemory /Management”，然后在右边的列表中双击“ClearPageFileAtShutdown”。

3.在弹出的“编辑DWORD”值对话框中改为1.