操作系统实验报告51025111017陈绪群.docx
《操作系统实验报告51025111017陈绪群.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告51025111017陈绪群.docx（14页珍藏版）》请在冰豆网上搜索。
操作系统实验报告51025111017陈绪群
实验四虚拟内存页面置换算法
学号:
1025111017姓名:
陈绪群任课老师:
骆翔宇
（华侨大学计算机科学与技术学院10网络工程二班）
1．算法思想
（1）问题描述:
设计程序模拟先进先出FIFO，最佳置换OPI和最近最久未使用LRU页面置换算法的工作过程。
假设内存中分配给每个进程的最小物理块数为m，在进程运行过程中要访问的页面个数为n，页面访问序列为P1,…,Pn，分别利用不同的页面置换算法调度进程的页面访问序列，给出页面访问序列的置换过程，计算每种算法缺页次数和缺页率。
（2）算法思想:
1.最佳页面置换算法（OPT：
optimalpagereplacementalgorithm）
这是一种理想情况下的页面置换算法，但实际上是不可能实现的。
该算法的基本思想是：
发生缺页时，有些页面在内存中，其中有一页将很快被访问（也包含紧接着的下一条指令的那页），而其他页面则可能要到10、100或者1000条指令后才会被访问，每个页面都可以用在该页面首次被访问前所要执行的指令数进行标记。
最佳页面置换算法只是简单地规定：
标记最大的页应该被置换。
如果某页在八百万条指令内不会被使用，另一页在600万条指令内不会被使用，则置换前一个页面，从而把因需要调回这一页发生的缺页推到将来，越远越好。
2.LRU（LeastRecentlyUsed）最近最少使用算法
根据页面调入内存后的使用情况进行决策。
该算法选择最近最久未使用的页面予以淘汰。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间t，当须淘汰一个页面时，选择现有页面中其t值最大的，即最近最久未使用的页面予以淘汰。
3.FIFO先进先出页面置换算法
该算法选择在内存中驻留时间最久的页面予以淘汰。
2．程序代码
#include
#include
#include
#include
#include
usingnamespacestd;
intBisearch（vector&data,intx）;//在物理内存中找指定的元素
voidresult_print（intm,intn,vector>&result,vector&PageOrder）;//结果输出
voidinit_result（vector>&result,intm,intn）;//初始保存结果的二维向量
intCalc（vector&PageCount,vector&PageOrder,intindex,intm,intn）;//找到OPI中最长时间不被访问的元素索引
intmax（vector&flag,intm）;//找到LRU中最久未被使用的元素索引
intFIFO（intm,intn,vector&PageOrder,vector&PageCount）;//FIFO算法实现
intOPI（intm,intn,vector&PageOrder,vector&PageCount）;//OPI算法实现
intLRU（intm,intn,vector&PageOrder,vector&PageCount）;//LRU算法实现
intmain（）{
intm,n,i,witch;
freopen（"test1.txt","r",stdin）;//文件重定向
cout<<"输入最小物理块数m:
";//初始化
cin>>m;
cout<cout<<"输入页面个数n:
";
cin>>n;
cout<vectorPageOrder（n,-1）;//请求页面顺序
vectorPageCount（m,-1）;//物理页面
cout<<"输入页面序列:
";
for（i=0;icin>>PageOrder[i];
cout<}
cout<cout<<"算法选择说明:
"<cout<cout<<"请输入算法选择witch:
";//算法选择
while（cin>>witch）{
cout<switch（witch）{
case1:
FIFO（m,n,PageOrder,PageCount）;
cout<<"请输入算法选择witch:
";
break;
case2:
OPI（m,n,PageOrder,PageCount）;
cout<<"请输入算法选择witch:
";
break;
case3:
LRU（m,n,PageOrder,PageCount）;
cout<<"请输入算法选择witch:
";
break;
case-1:
cout<<"即将退出程序...."<return0;
default:
cout<<"输入出错,请重新输入所要选择的算法:
";
break;
}
}
return0;
}
//==================================初始保存结果的二维向量=========================================
voidinit_result（vector>&result,intm,intn）{
inti;
for（i=0;iresult[i].resize（n,-1）;
}
}
//=================================FIFO============================================================
intFIFO（intm,intn,vector&PageOrder,vector&PageCount）{
intLockPage=0;//缺页次数
doubleLackPageRate=0;//缺页率
inti,j,flag=0;
vector>result（m）;//结果保存向量
init_result（result,m,n）;//结果保存向量初始化
if（n<=m）{
cout<<"缺页次数为"<return0;
}else{
for（i=0;iPageCount[i]=PageOrder[i];
for（j=i;jresult[i][j]=PageOrder[i];
}
}
LockPage=m;
//FIFO算法核心
for（i=m;iif（Bisearch（PageCount,PageOrder[i]）==-1）{
LockPage++;
PageCount[flag%m]=PageOrder[i];
flag++;
for（j=0;jresult[j][i]=PageCount[j];
}
}
}
LackPageRate=（1.0*LockPage）/n;
}
//结果输出
cout<<"FIFO结果输出:
"<result_print（m,n,result,PageOrder）;
cout<<"缺页次数:
"<"<return0;
}
//=================================在物理内存中找指定的元素======================================
intBisearch（vector&data,intx）{
inti,size=data.size（）;
for（i=0;iif（data[i]==x）returni;
}
return-1;
}
//=================================结果输出======================================================
voidresult_print（intm,intn,vector>&result,vector&PageOrder）{
inti,j;
//输出请求序列
for（i=0;icout<（1）<<""<（1）<<"";
}
cout<//输出交换结果
for（i=0;ifor（j=0;jif（result[i][j]!
=-1）{
cout<}else{
cout<}
}
cout<}
}
//==================================OPI=====================================================
intOPI（intm,intn,vector&PageOrder,vector&PageCount）{
intLockPage=0;//缺页次数
doubleLackPageRate=0;//缺页率
inti,j;
vector>result（m）;
init_result（result,m,n）;
if（n<=m）{
cout<<"缺页次数为"<return0;
}else{
for（i=0;iPageCount[i]=PageOrder[i];
for（j=i;jresult[i][j]=PageOrder[i];
}
}
intindex;
LockPage=m;//缺页数
//OPI算法核心
for（i=m;iif（Bisearch（PageCount,PageOrder[i]）==-1）{//如果没找到
LockPage++;
index=Calc（PageCount,PageOrder,i,m,n）;
PageCount[index]=PageOrder[i];
for（j=0;jresult[j][i]=PageCount[j];
}
}
}
LackPageRate=（1.0*LockPage）/n;
}
//结果输出
cout<<"OPI结果输出:
"<result_print（m,n,result,PageOrder）;
cout<<"缺页次数:
"<"<return0;
}
//============================================找到OPI中最长时间不被访问的元素索引===============================
intCalc（vector&PageCount,vector&PageOrder,intindex,intm,intn）{
inti,j,max=0,maxIndex=0;
vectorflag（m,n+m）;
//找到对应的后面出现的最近索引
for（i=0;ifor（j=index;jif（PageCount[i]==PageOrder[j]）{
flag[i]=j;
break;
}
}
}
max=flag[0];
for（i=0;iif（flag[i]>=max）{
max=flag[i];
maxIndex=i;
}
}
returnmaxIndex;
}
//=================================LRU算法实现==========================================================
intLRU（intm,intn,vector&PageOrder,vector&PageCount）{
intLockPage=0;//缺页次数
doubleLackPageRate=0;//缺页率
inti,j;
vectorflag（m,0）;
vector>result（m）;
init_result（result,m,n）;
if（n<=m）{
cout<<"缺页次数为"<return0;
}else{
for（i=0;iPageCount[i]=PageOrder[i];
flag[i]=flag[i]+1;
for（j=i;jresult[i][j]=PageOrder[i];
}
}
intindex,findex;
LockPage=m;
//LRU算法核心
for（i=m;ifindex=Bisearch（PageCount,PageOrder[i]）;
if（findex==-1）{//如果没找到
LockPage++;
index=max（flag,m）;
PageCount[index]=PageOrder[i];
flag[index]=0;
for（j=0;jresult[j][i]=PageCount[j];
if（j!
=index）{
flag[j]=flag[j]+1;
}
}
}else{
for（intz=0;zif（z!
=findex）
flag[z]=flag[z]+1;
else
flag[z]=0;
}
}
}
LackPageRate=（1.0*LockPage）/n;
}
//结果输出
cout<<"LRU结果输出:
"<result_print（m,n,result,PageOrder）;
cout<<"缺页次数:
"<"<return0;
}
//===========================================找到LRU中最久未被使用的元素索引========================
intmax（vector&flag,intm）{
inti,max=flag[0],maxIndex=0;
for（i=0;iif（flag[i]>max）{
max=flag[i];
maxIndex=i;
}
}
returnmaxIndex;
}
3．程序结果
上述算法实现的结果：
输入：
输入最小物理块数m:
3
输入页面个数n:
20
输入页面序列:
70120304230321201701
算法选择说明:
1-FIFO,2-OPI,3-LRU,-1-exit
输出：
请输入算法选择witch:
1
FIFO结果输出:
70120304230321201701
777222444000777
00033322211100
1110003332221
缺页次数:
15缺页率:
0.75
请输入算法选择witch:
2
OPI结果输出:
70120304230321201701
777222227
00004000
1133311
缺页次数:
9缺页率:
0.45
请输入算法选择witch:
3
LRU结果输出:
70120304230321201701
777224440111
00000033300
1133222227
缺页次数:
12缺页率:
0.6
请输入算法选择witch:
-1
即将退出程序....
Pressanykeytocontinue
实验截图：
升级会员 