操作系统实验报告6页面置换算法模拟.docx
《操作系统实验报告6页面置换算法模拟.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告6页面置换算法模拟.docx（21页珍藏版）》请在冰豆网上搜索。
操作系统实验报告6页面置换算法模拟
操作系统实验报告6-页面置换算法模拟
实验报告
2013/2014学年第1学期,
课程名称操作系统原理实验名称实验6:
页面置换算法模拟
20131210实验时间年月日指导单位软件工程系指导教师杨健
学生姓名班级学号
计算机软件与服务外包学院（系）软件工程系专业
实验名称实验1:
Linux操作、使用、编程与进程创建指导教师杨健实验类型实验实验学时2实验时间2013.12.10一、实验目的
1（通过模拟实现几种基本页面置换的算法，了解虚拟存储技术的特点。
2（掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想，并至少用三种算法来模拟实现。
3（通过对几种置换算法页面的比较，来对比他们的优缺点，并通过比较更换频率来对比它们的效率。
二、实验环境（实验设备）
Windows2000
VisualStudio
三、实验内容
设计一个虚拟存储区和内存工作区，并使用下述算法来模拟实现页面的置换:
1.先进先出的算法（FIFO）
2.最近最久未使用算法（LRU）
3.最佳置换算法（OPT）
实验分析
在进程运行过程中，若其所访问的页面不存在内存而需要把它们调入内存，但内存已无空闲时，为了保证该进程能够正常运行，系统必须从内存中调出一页程序或数据送磁盘的对换区中。
但应调出哪个页面，需根据一定的算法来确定，算法的好坏，直接影响到系统的性能。
一个好的页面置换算法，应该有较低的页面更换频率。
1
假设分给一作业的物理块数为3，页面数为20个。
页面号为（20个）:
7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，11（先进先出（FIFO）置换算法的思路
该算法总是淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。
该算法实现简单，只需把一个进程已调入内存的页面，按照先后次序连接成一个队列，并设置一个替换指针，使它总指向最老的页面。
2（最近久未使用（LRU）置换算法的思路
最近久未使用置换算法的替换规则，是根据页面调入内存后的使用情况来进行决策的。
该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间，当需淘汰一个页面的时候选择现有页面中其时间值最大的进
行淘汰。
3.最佳（OPT）置换算法的思路
其所选择的被淘汰的页面，奖是以后不使用的，或者是在未来时间内不再被访问的页面，采用最佳算法，通常可保证获得最低的缺页率。
4（FIFO页面置换算法
当需要访问一个新的页面时，首先调用findExist（i）函数来查看物理块中是否就有这个页面，若要查看的页面物理块中就有，则调用display函数直接显示，不需要替换页面;如果要查看的页面物理块中没有，就需要寻找空闲物理块放入，若存在有空闲物理块，则将页面放入;若没有空
2
闲物理块，则调用findReplace函数替换页面。
并将物理块中所有页面timer++。
5（LRU页面置换算法
当需要访问一个新的页面，首先调用findExist（i）函数查看物理块中是否就有这个页面。
6.OPT页面置换算法
当需要访问一个新的页面，首先调用findExist（i）函数来查看物理块中是否有这个页面。
7（寻找置换页面函数findReplace比较三个物理块中的时间标记timer，找到时间最久的。
代码
#include
#include
#include
#defineBLOCK_MAX_SIZE20//最?
大洙?
物?
理え?
块é大洙?
小?
enum{FIFO=1,LRU,OPT};
structnode_page{
intaddress;//指?
令?
地?
址?
intpage_num;//页?
面?
号?
intnext_order;//下?
一?
次?
访?
问ê的?
次?
序ò
}*page;
3
//物?
理え?
块é定?
义?
typedefstructBlockNode{
intpage_index;//page数簓组哩?
的?
下?
标括?
structBlockNode*next;
}BlockNode;
struct{
intlength;//当獭?
前?
物?
理え?
块é长?
度è
intmiss_flag;//缺ø?
页?
标括?
志?
，?
若?
为a1，?
则ò缺ø?
页?
intmiss_count;//缺ø?
页?
次?
数簓
BlockNode*front;
BlockNode*rear;
}Block;
//本?
程ë序ò中D全?
局?
变?
量?
名?
均õ由?
两?
个?
单蹋?
词洙?
组哩?
成é，?
且ò开a头?
字?
母?
大洙?
写′
intBlockSize=5;//物?
理え?
块é大洙?
小?
intPageCount=200;//页?
面?
总哩?
数簓
intPageSize=1024;//页?
面?
大洙?
小?
intAddrRange=8*1024;//访?
问ê地?
址?
范?
围?
intget_num（intdown,intup）//得?
到?
一?
个?
down~up之?
间?
的?
整?
数簓
{
intnum;
4
charstr[111];
while
（1）{
fgets（str,111*sizeof（int）,stdin）;
num=atoi（str）;//把?
字?
符?
串?
中D的?
数簓字?
转羇换?
为a整?
数簓
if（num>=down&&num<=up）
break;
printf（"输?
入?
范?
围?
有瓺误ó,请?
重?
新?
输?
入?
:
"）;
}//while
returnnum;
}
voidinit_block（）//构1造ë一?
个?
空?
的?
物?
理え?
块é队ó列
{
Block.rear=Block.front=（BlockNode*）malloc（sizeof（BlockNode））;
if（!
Block.front）{
printf（"内ö存?
分?
配?
失骸?
败悒?
\n"）;
exit（0）;
}
Block.length=0;
Block.miss_count=0;
Block.rear->next=NULL;
}
voidenqueue（intpage_index）//入?
队ó
5
{
BlockNode*node=（BlockNode*）malloc（sizeof（BlockNode））;
if（!
node）{
printf（"内ö存?
分?
配?
失骸?
败悒?
\n"）;
exit（0）;
}
node->page_index=page_index;
node->next=NULL;
Block.length++;
Block.rear->next=node;
Block.rear=node;
}
voiddequeue（）//出?
队ó
{
BlockNode*node;
node=Block.front->next;
Block.front->next=node->next;
if（node==Block.rear）
Block.rear=Block.front;
free（node）;
Block.length--;
6
}
voidclear_block（）//清?
空?
物?
理え?
块é
{
while（Block.rear=Block.front->next）{
Block.front->next=Block.rear->next;
free（Block.rear）;
Block.length--;
}
Block.rear=Block.front;
Block.length=0;
Block.miss_count=0;
}
voiddestroy_block（）//销ö毁õ物?
理え?
块é
{
while（Block.rear=Block.front）{
Block.front=Block.front->next;
free（Block.rear）;
}
free（page）;
}
voidinit_page（）//初?
始?
化ˉ页?
面?
系μ列
7
{
inti,j;
srand（time（NULL））;//用?
当獭?
前?
系μ统?
时骸?
间?
来ぁ?
初?
始?
化ˉ随?
机ö种?
子哩?
page=（structnode_page*）malloc（PageCount*sizeof（structnode_page））;
for（i=0;ipage[i].address=rand（）%AddrRange;
page[i].page_num=page[i].address/PageSize;
}
for（i=0;ifor（j=i+1;jif（page[i].page_num==page[j].page_num）{
page[i].next_order=j;
break;
}//if
}//for
if（j==PageCount）//说μ明ôpage[i]以?
后ó都?
不?
会á再õ访?
问ê
page[i].next_order=PageCount;
}//for
}
voidprint_page（）//打洙?
印?
页?
面?
系μ列
{
inti;
8
printf（"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"）;
printf（"页?
面?
系μ列为a:
阰\n"）;
for（i=0;iprintf（"[%-2d,%-4d]",page[i].page_num,page[i].address%PageSize）;
if（（i+1）%5==0）{
printf（"\n"）;
}//if
}
printf（"\n"）;
}
voidFIFO_Replace（intpage_index）//FIFO置?
换?
{
BlockNode*node;
if（!
Block.length）{
enqueue（page_index）;
Block.miss_flag=0;
return;
}
node=Block.front;
while（node=node->next）{
if（page[node->page_index].page_num==page[page_index].page_num）{
9
Block.miss_flag=0;
return;
}
}
if（Block.lengthenqueue（page_index）;
Block.miss_flag=0;
return;
}
dequeue（）;
enqueue（page_index）;
Block.miss_flag=1;
Block.miss_count++;
}
voidLRU_Replace（intpage_index）//LRU置?
换?
{
BlockNode*node,*last_node;
if（!
Block.length）{
enqueue（page_index）;
Block.miss_flag=0;
return;
}
10
last_node=node=Block.front;
while（node=node->next）{
if（page[node->page_index].page_num==page[page_index].page_num）{
last_node->next=node->next;
Block.length--;
if（node==Block.rear）
Block.rear=last_node;
enqueue（node->page_index）;
free（node）;
Block.miss_flag=0;
return;
}
last_node=node;
}
if（Block.lengthenqueue（page_index）;
Block.miss_flag=0;
return;
}
dequeue（）;
enqueue（page_index）;
Block.miss_flag=1;
11
Block.miss_count++;
}
voidOPT_Replace（intpage_index）//OPT置?
换?
{
BlockNode*node;
BlockNode*max_node,*max_node_last;
if（!
Block.length）{
enqueue（page_index）;
Block.miss_flag=0;
return;
}
node=Block.front;
while（node=node->next）{
if（page[node->page_index].page_num==page[page_index].page_num）{
node->page_index=page_index;
Block.miss_flag=0;
return;
}
}
if（Block.lengthenqueue（page_index）;
12
Block.miss_flag=0;
return;
}
node=Block.front;
max_node=node->next;
while（node=node->next）{//寻?
找òBlock中Dnext_order值μ最?
大洙?
的?
节ö点?
if（page[max_node->page_index].next_orderpage_index].next_order）
max_node=node;
}
node=Block.front;
max_node_last=node;
while（node=node->next）{//寻?
找òBlock中Dnext_order值μ最?
大洙?
的?
节ö点?
的?
上?
一?
个?
节ö点?
if（node==max_node）
break;
max_node_last=node;
}
max_node_last->next=max_node->next;
Block.length--;
if（max_node==Block.rear）
Block.rear=max_node_last;
free（max_node）;
enqueue（page_index）;
13
Block.miss_flag=1;
Block.miss_count++;
}
voidpage_replace（intnum）
{
inti,j;
BlockNode*node;
charstr[3][5]={"FIFO","LRU","OPT"};
printf（"======================%s=========================\n",str[num-1]）;
printf（"页?
面?
号?
*"）;
for（i=0;iprintf（""）;
printf（"*是?
否?
缺ø?
页?
*\n"）;
printf（"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"）;
for（i=0;iprintf（"%-4d*",page[i].page_num）;
if（num==FIFO）
FIFO_Replace（i）;
elseif（num==LRU）
LRU_Replace（i）;
elseif（num==OPT）
14
OPT_Replace（i）;
node=Block.front;
while（node=node->next）
printf（"%-2d",page[node->page_index].page_num）;
for（j=Block.length;jprintf（""）;
printf（"*%s*\n\n",（Block.miss_flag==1?
"Yes":
"No"））;
}
printf（"\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"）;
printf（"缺ø?
页?
数簓:
%d,缺ø?
页?
率
ê:
%%%.2f\n\n",Block.miss_count,（float）Block.miss_count/PageCount*100）;
printf（"按恪?
回?
车μ键?
继ë续?
!
\n\n"）;
getchar（）;
}
voidconfige（）//程ë序ò设Θ?
置?
{
intnum;
while
（1）{
printf（"\n***************************************************\n"）;
printf（"*程ë序ò设Θ?
置?
*\n"）;
printf（"***************************************************\n"）;
printf（"*1,设Θ?
置?
物?
理え?
块é大洙?
小?
（默?
认?
5）*\n"）;
15
printf（"*2,设Θ?
置?
访?
问ê地?
址?
范?
围?
（默?
认?
8K）*\n"）;
printf（"*3,设Θ?
置?
页?
面?
大洙?
小?
（默?
认?
1K）*\n"）;
printf（"*4,设Θ?
置?
页?
面?
总哩?
数簓（默?
认?
200）*\n"）;
printf（"*5,显?
示?
各ô项?
设Θ?
置?
值μ*\n"）;
printf（"*6,返う?
回?
*\n"）;
printf（"***************************************************\n"）;
printf（"请?
输?
入?
您ö的?
选?
择?
:
"）;
num=get_num（1,6）;
if（num==6）
break;
if（num==1）{
printf（"请?
输?
入?
物?
理え?
块é大洙?
小?
（1~%d）:
",BLOCK_MAX_SIZE）;
BlockSize=get_num（1,BLOCK_MAX_SIZE）;
printf（"设Θ?
置?
成é功|!
\n\n"）;
}//if
elseif（num==2）{
printf（"请?
输?
入?
访?
问ê地?
址?
范?
围?
（1~%d）K:
",999）;
AddrRange=get_num（1,999）*1024;
printf（"设Θ?
置?
成é功|!
\n\n"）;
}//elseif
elseif（num==3）{
printf（"请?
输?
入?
页?
面?
大洙?
小?
（1~%d）K:
",AddrRange/1024）;
16
PageSize=get_num（1,AddrRange/1024）*1024;
printf（"设Θ?
置?
成é功|!
\n\n"）;
}//elseif
elseif（num==4）{
printf（"请?
输?
入?
页?
面?
总哩?
数簓（1~%d）:
",32767）;
PageCount=get_num（1,32767）;
printf（"设Θ?
置?
成é功|!
\n\n"）;
}//elseif
elseif（num==5）{
printf（"---------------------------------------------------\n"）;
printf（"*当獭?
前?
物?
理え?
块é大洙?
小?
:
%d\n",BlockSize）;
printf（"*当獭?
前?
访?
问ê地?
址?
范?
围?
:
%dK\n",AddrRange/1024）;
printf（"*当獭?
前?
页?
面?
大洙?
小?
:
%dK\n",PageSize/1024）;
printf（"*当獭?
前?
页?
面?
总哩?
数簓%d\n",PageCount）;
printf（"---------------------------------------------------\n"）;
}
}
free（page）;
init_page（）;
}
voidbegin（）
{
17
intnum;
print_page（）;
while
（1）{
printf（"\n***************************************************\n"）;
printf（"*页?
面?
置?
换?
算?
法ぁ?
*\n"）;
printf（"***************************************************\n"）;
printf（"*1,先è进?
先è出?
置?
换?
算?
法ぁ?
FIFO）*\n"）;
printf（"*2,最?
近?
最?
久?
未′使?
用?
置?
换?
算?
法ぁ?
LRU）*\n"）;
printf（"*3,最?
佳?
置?
换?
算?
法ぁ?
OPT）*\n"）;
printf（"*4,返う?
回?
*\n"）;
printf（"***************************************************\n"）;
printf（"请?
输?
入?
您ö的?
选?
择?
:
"）;
num=get_num（1,4）;
if（num==4）
break;
page_replace（num）;
clear_block（）;
}
free（page）;
init_page（）;
}
18
intmain（）
{
intnum;
init_block（）;
init_page（）;
while
（1）{
printf（"\n***************************************************\n"）;
printf（"*存?
储洹?
器ô管?
理え?
模,拟a系μ统?
*\n"）;
printf（"*********************************
升级会员 