操作系统的课设报告.docx
《操作系统的课设报告.docx》由会员分享，可在线阅读，更多相关《操作系统的课设报告.docx（24页珍藏版）》请在冰豆网上搜索。
操作系统的课设报告
目录
1．引言1
1.1编写目的1
1.2设计内容1
1.3设计原理1
1.3.1先进先出算法（FIFO）1
1.3.2最优置换算法（OPT）1
1.3.3最近最久未使用算法（LRU）2
1.4运行环境2
2．设计方案3
2.1模块划分3
2.3模块调用关系图3
2.4模块流程图3
2.4.1主函数流程图3
2.4.2FIFO函数流程图4
2.4.3LRU函数流程图5
2.4.4OPT函数流程图5
3．源代码6
3.1程序代码6
4．测试结果16
4.1页面选择测试16
4.2应用算法选择测试16
5．总结18
6．程序使用说明书19
7．参考文献19
1．引言
1.1编写目的
在MicrosoftVisualC++6.0的环境下用C++语言编写程序，实现操作系统中页面在内存与外存中如何置换的问题。
1.2设计内容
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程,并计算访问命中率。
设计要求：
主界面以灵活选择某算法，且以下算法都要实现
1、先进先出算法（FIFO）
2、最近最久未使用算法（LRU）
3、最佳置换算法（OPT）
1.3设计原理
1.3.1先进先出算法（FIFO）
最简单的页面置换算法是先入先出（FIFO）法。
这种算法的实质是，总是选择在主存中停留时间最长（即最老）的一页置换，即先进入内存的页，先退出内存。
理由是：
最早调入内存的页，其不再被使用的可能性比刚调入内存的可能性大。
建立一个FIFO队列，收容所有在内存中的页。
被置换页面总是在队列头上进行。
当一个页面被放入内存时，就把它插在队尾上。
这种算法只是在按线性顺序访问地址空间时才是理想的，否则效率不高。
因为那些常被访问的页，往往在主存中也停留得最久，结果它们因变“老”而不得不被置换出去。
FIFO的另一个缺点是，它有一种异常现象，即在增加存储块的情况下，反而使缺页中断率增加了。
当然，导致这种异常现象的页面走向实际上是很少见的。
1.3.2最优置换算法（OPT）
最优置换（OptimalReplacement）是在理论上提出的一种算法。
其实质是：
当调入新的一页而必须预先置换某个老页时，所选择的老页应是将来不再被使用，或者是在最远的将来才被访问。
采用这种页面置换算法，保证有最少的缺页率。
但是最优页面置换算法的实现是困难的，因为它需要人们预先就知道一个进程整个运行过程中页面走向的全部情况。
不过，这个算法可用来衡量（如通过模拟实验分析或理论分析）其他算法的优劣。
1.3.3最近最久未使用算法（LRU）
FIFO算法和OPT算法之间的主要差别是，FIFO算法利用页面进入内存后的时间长短作为置换依据，而OPT算法的依据是将来使用页面的时间。
如果以最近的过去作为不久将来的近似，那么就可以把过去最长一段时间里不曾被使用的页面置换掉。
它的实质是，当需要置换一页时，选择在最近一段时间里最久没有使用过的页面予以置换。
这种算法就称为最久未使用算法（LeastRecentlyUsed，LRU）。
LRU算法是与每个页面最后使用的时间有关的。
当必须置换一个页面时，LRU算法选择过去一段时间里最久未被使用的页面。
LRU算法是经常采用的页面置换算法，并被认为是相当好的，但是存在如何实现它的问题。
LRU算法需要实际硬件的支持。
其问题是怎么确定最后使用时间的顺序，对此有两种可行的办法：
（1）计数器。
最简单的情况是使每个页表项对应一个使用时间字段，并给CPU增加一个逻辑时钟或计数器。
每次存储访问，该时钟都加1。
每当访问一个页面时，时钟寄存器的内容就被复制到相应页表项的使用时间字段中。
这样我们就可以始终保留着每个页面最后访问的“时间”。
在置换页面时，选择该时间值最小的页面。
这样做，不仅要查页表，而且当页表改变时（因CPU调度）要维护这个页表中的时间，还要考虑到时钟值溢出的问题。
（2）栈。
用一个栈保留页号。
每当访问一个页面时，就把它从栈中取出放在栈顶上。
这样一来，栈顶总是放有目前使用最多的页，而栈底放着目前最少使用的页。
由于要从栈的中间移走一项，所以要用具有头尾指针的双向链连起来。
在最坏的情况下，移走一页并把它放在栈顶上需要改动6个指针。
每次修改都要有开销，但需要置换哪个页面却可直接得到，用不着查找，因为尾指针指向栈底，其中有被置换页。
因实现LRU算法必须有大量硬件支持，还需要一定的软件开销。
所以实际实现的都是一种简单有效的LRU近似算法。
一种LRU近似算法是最近未使用算法（NotRecentlyUsed，NUR）。
它在存储分块表的每一表项中增加一个引用位，操作系统定期地将它们置为0。
当某一页被访问时，由硬件将该位置1。
过一段时间后，通过检查这些位可以确定哪些页使用过，哪些页自上次置0后还未使用过。
就可把该位是0的页淘汰出去，因为在最近一段时间里它未被访问过。
1.4运行环境
操作系统：
WindowsXP
编程环境：
MicrosoftVisualC++6.0
2．设计方案
2.1模块划分
主界面：
设置页面产生算法选择界面和页面置换算法选择界面；
子界面：
页面产生算法分为两个界面，分别是随机产生算法和自己输入产生算法。
页面置换算法分为三个子界面，分别是先进先出算法界面、最近最久未使用算法界面、最佳置换算法界面。
2.3模块调用关系图
图2—1
2.4模块流程图
2.4.1主函数流程图
图2—2
2.4.2FIFO函数流程图
图2—3
2.4.3LRU函数流程图
图2—4
2.4.4OPT函数流程图
图2—5
3．源代码
3.1程序代码
#include
#include
#include
#defineBsize3
#definePsize12
#include
usingnamespacestd;
intQString[Psize];
intNum=0;
structpageInfor
{
intcontent;//页面号
inttimer;//被访问标记
};
classYZ_replace
{
public:
YZ_replace（）;//构造函数
~YZ_replace（）;//析构函数
intfindSpace（）;//查找是否有空闲内存
intfindExist（intcurpage）;//查找内存中是否有该页面
intfindReplace（）;//查找应予置换的页面
voidFIFO（）;//FIFO算法
voidOPT（）;
voidBlockClear（）;//BLOCK恢复
voidinitia1（intstring[]）;//初始化
pageInfor*block;//物理块
pageInfor*page;//页面号串
intmemory_state[Bsize][Psize];
ints;
private:
};
voidP_String（intQString[]）//随机产生页面的各个数
{
inti;
srand（（unsigned）time（NULL））;
for（i=0;i{
QString[i]=rand（）*9/RAND_MAX+1;
}
cout<<"页面走向：
";
for（i=0;i{
cout<}
cout<}
YZ_replace:
:
YZ_replace（）//构造函数初始化Block，
{
s=0;
block=newpageInfor[Bsize];
for（inti=0;i{
block[i].content=-1;
block[i].timer=0;
}
}
voidYZ_replace:
:
initia1（intQString[]）//用于初始化页
{
intj;
page=newpageInfor[Psize];
for（inti=0;i{
page[i].content=QString[i];
page[i].timer=0;
}
for（i=0;ifor（j=0;jmemory_state[j][i]=0;
}
YZ_replace:
:
~YZ_replace（）
{
s=0;
}
intYZ_replace:
:
findSpace（）//查找是否有空闲内存
{
for（inti=0;iif（block[i].content==-1）
returni;//找到空闲内存，
return-1;
}
intYZ_replace:
:
findExist（intcurpage）//查找内存中是否有该页面
{
for（inti=0;iif（block[i].content==page[curpage].content）//找到内存中有该页面，返回BLOCK中位置
returni;
return-1;
}
intYZ_replace:
:
findReplace（）//查找先进先出算法中应予置换的页面
{
intpos=0;
for（inti=0;iif（block[i].timer>=block[pos].timer）//找到应予置换页面，返回BLOCK中位置
pos=i;
returnpos;
}
voidYZ_replace:
:
FIFO（）//先进先出核心算法
{
intexist,space,position;
for（inti=0;i{
exist=findExist（i）;
if（exist!
=-1）//内存中有该页面
{
for（intb=0;b{
memory_state[b][i]=memory_state[b][i-1];
}
s++;//记录命中数的变量加1
}
else
{
space=findSpace（）;
if（space!
=-1）//内存中有空闲
{
for（intb=0;b{
memory_state[b][i]=memory_state[b][i-1];//将第一列的数组复制到第二列
}
block[space]=page[i];
memory_state[space][i]=block[space].content;
}
else//内存中没有空闲
{
for（intb=0;b{
memory_state[b][i]=memory_state[b][i-1];
}
position=findReplace（）;//找到要置换的位置
block[position]=page[i];
memory_state[position][i]=block[position].content;
}
}
for（intj=0;jblock[j].timer++;//BLOCK中所有页面TIMER++
}
}
voidYZ_replace:
:
BlockClear（）//BLOCK恢复
{
for（inti=0;i{
block[i].content=-1;
block[i].timer=0;
}
}
typedefstructpage
{
intnum;/*记录页面号*/
inttime;/*记录调入内存时间*/
}Page;/*页面逻辑结构，结构为方便算法实现设计*/
Pageb[Bsize];
Pagecall[Bsize];/*内存单元数*/
intc[Bsize][Psize];/*暂保存内存当前的状态：
缓冲区*/
intqueue[100];/*记录调入队列*/
intK;/*调入队列计数变量*/
voidInitL（Page*b,intc[Bsize][Psize]）/*初始化内存单元、缓冲区*/
{
inti,j;
for（i=0;i{
b[i].num=-1;
b[i].time=Psize-i-1;
}
for（i=0;ifor（j=0;jc[i][j]=-1;
}
intGetMax（Page*b）/*取得在内存中停留最久的页面,默认状态下为最早调入的页面*/
{
inti;
intmax=-1;
inttag=0;
for（i=0;i{
if（b[i].time>max）
{
max=b[i].time;
tag=i;
}
}
returntag;
}
intEquation（intfold,Page*b）/*判断页面是否已在内存中*/
{
inti;
for（i=0;i{
if（fold==b[i].num）
returni;
}
return-1;
}
voidLru（intfold,Page*b）/*LRU算法*/
{
inti;
intval;
val=Equation（fold,b）;
if（val>=0）
{
b[val].time=0;
for（i=0;iif（i!
=val）
b[i].time++;
}
else
{
queue[++K]=fold;/*记录调入页面*/
val=GetMax（b）;
b[val].num=fold;
b[val].time=0;
for（i=0;iif（i!
=val）
b[i].time++;
}
}
/*以下是最佳置换算法*/
voidYZ_replace:
:
OPT（）
{
intexist,space,position;
for（inti=0;i{
exist=findExist（i）;
if（exist!
=-1）//内存中存在该页面，此时即为命中
{
for（intb=0;b{
memory_state[b][i]=memory_state[b][i-1];
}
s++;//命中次数加1
}
else//内存中不存在该页面
{
space=findSpace（）;//查找是否有空闲内存
if（space!
=-1）//有空闲内存
{
for（intb=0;b{
memory_state[b][i]=memory_state[b][i-1];
}
block[space]=page[i];//页面调入内存
memory_state[space][i]=block[space].content;
}
else
{
for（intk=0;k{
memory_state[k][i]=memory_state[k][i-1];
for（intj=i;j{
if（block[k].content!
=page[j].content）
{block[k].timer=1000;}//将来不会用，设置TIMER为一个很大数
else
{block[k].timer=j;break;}
}
}
position=findReplace（）;
block[position]=page[i];
memory_state[position][i]=block[position].content;
}
}
}
}
intdecide（stringstr）//判断输入数据是否为整型
{
for（inti=0;i{
if（str[i]<'0'||str[i]>'9'）
{
return0;
break;
}
}
returni;
}
inttrans（stringstr）//将字符串转换成数字
{
intsum=0;
for（inti=0;isum=sum+（str[i]-'0'）*pow（10,str.size（）-i-1）;
returnsum;
}
intput（）//强制输入一个整型数
{
inta,d;
stringstr;
cin>>str;
a=decide（str）;
while（a==0）
{
cout<<"输入错误,请重新输入！
"<cin>>str;
a=decide（str）;
}
d=trans（str）;
returnd;
}
voidPut（）//页面产生的方法
{
cout<<"请选择产生页面的方法a:
随机产生b:
输入产生"<cout<<"您选择的菜单是:
";
charF;
cin>>F;
while（F!
='a'&&F!
='b'）
{
cout<<"输入错误，请重新输入:
";
cin>>F;
}
if（F=='a'）
P_String（QString）;
if（F=='b'）
{
cout<<"请输入各页面号:
"<for（inti=0;i{
QString[i]=put（）;
}
}
cout<cout<<"|---------------------------------------------------------------|"<}
voidmain（）
{
cout<<"|-----------------------页面置换算法-----------------------|"<cout<<"|---------------------------------------------------------------|"<intt=1;
while（t）
{
Put（）;
YZ_replacetest1;
YZ_replacetest3;
charselect;
do{
cout<<"请选择要应用的算法:
<1>FIFO算法<2>LRU算法<3>OPT算法<0>退出"<intp,q;
cout<<"请您输入菜单号:
";
cin>>select;
while（select!
='0'&&select!
='1'&&select!
='2'&&select!
='3'）
{
cout<<"您的输入无效,请重新输入:
"<cin>>select;
}
if（select=='0'）
{
cout<<"您选择的是菜单<0>"<cout<<"完成退出."<t=0;
}
if（select=='1'）
{
cout<<"您选择的是菜单<1>"<cout<<"FIFO算法状态:
"<test1.initia1（QString）;
test1.FIFO（）;
test1.BlockClear（）;
cout<<"-------------------------------------------"<for（p=0;p{
for（q=0;qcout<cout<}
cout<<"-------------------------------------------"<cout<<"命中率:
"<test1.~YZ_replace（）;
cout<}
if（select=='2'）
{
inti,j;
K=-1;
InitL（b,c）;
for（i=0;i{
Lru（QString[i],b）;
c[0][i]=QString[i];/*记录当前的内存单元中的页面*/
for（j=0;jc[j][i]=b[j].num;
}
cout<<"您选择的是菜单<2>"<cout<<"LRU算法状态:
"<cout<<"------------------------------------------"<for（i=0;i{
for（j=0;j{
if（c[i][j]==-1）
cout<<"0";
else
cout<<""<}
cout<<""<}
cout<<"------------------------------------------"<cout<<"命中率:
"<<（Psize-（K+1））<<"/"<cout<<'\t';
cout<}
if（select=='3'）
{
升级会员 