模拟页式存储管理操作系统课程设计报告.doc

. .
一、目的和要求
1、设计目的
通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
2、设计要求
根据模拟的页式管理设计，掌握在页式存储管理中最根本的三种页面调度算法FIFO、LRU以及OPT。但在三种算法中均要求在调度程序中产生的页面序列是随机产生的，而不是人为的输入，在执行时只需改变页面的大小及存容量就可以得到不同的页面序列，另外还需要说明随机的性能和其性能可能对算法的影响，并对随机性要有一定的参数控制能力。此外，计算并输出FIFO、LRU以及OPT算法在不同存容量下的命中率。
根据法的执行过程，编写一个解决上述问题的程序，显示访问每个值页面中的值。
具体参数：访问串的长度，访问串，页面个数。
分别用3种不同的法实现页面的置换，并输出相关信息。
二、设计思路及过程
1、概要设计
1.1 问题概述
根据三种不同的置换算法，依据其不同的算法式，分别计算该算法在不同情况下的命中率，并显示各页面的变化情况。
1.2 容分析
对于该课程设计中模拟的页式存储管理的页面置换过程，只要掌握其中最根本的三种算法，包括FIFO、LRU及OPT。 但最重要的一点就是要求产生随机序列，所以在编写程序时要采用控制产生随机值的种子数函数，如此能产生随机的访问序列。另外，不能在执行完一次操作后就只能进展另外一种算法的操作，必须还要有更加详细的操作，比方：是否要重新得到新序列？还是要不改变访问序列而只改变访问串的存容量？抑或是不操作就退出该算法以进展下一种调度算法？因此，在执行完每次操作后都必须要有提示语，看是否进入更细节的操作，还是退出本次算法的操作以进入下一种算法的调度。
2、过程设计
2.1模块设计
在以下图的主模块设计图中，只注重描绘了页式存储管理的三种主要算法，未描绘出细节局部。其中，在执行每种算法时都会要求输入你所需要的访问串长度、随机值以及同一种算法的不同存容量，如此就可以得出不同的命中率。另外，在执行完该操作后又会出现三条提示语，是重新得到新序列？还是不改变访问序列只改变访问串的存容量？抑或是不操作退出以进展下一种调度算法？这些在以下图中都未一一实现。

=2.2 算法原理分析
要学成功实现算法，首先要知道各个法是怎么做的，即原理是怎样的，下面是三种算法的原理。
FIFO算法是先进先出，当当前存中没有正要访问的页面时，置换出最先进来的页面。
LRU算法是最近最久未使用，当当前存中没有正要访问的页面时，置换出在当前页面中最近最久没有使用的页面。
OPT算法是未来最远出现，当当前存中没有正要访问的页面时，置换出当前页面中在未来的访问页中最远出现的页面或再也不出现的页面。
2.3 程序流程图
本次课程设计的主要流程是3种置换算法的流程图，本人负责OPT，流程图如下所示：
N
N
Y
Y
开场
输入内存中分配页数
N
Y
还有请求访问页？
内存中是否已存在？
直接复制前一列内容
内存有空页？
直接插入
替换内存中将来不出现或离当前最远的页
输出全部页面变化情况
完毕
据第一个访问页初始化第一列值

图2.2 OPT算法流程图
三、数据定义
int length,num_page,count,seed; //length记录访问串的长度，num_page页面数，count记录缺页次数
int result[20][30],order[30],a[10]; //result记录结果,order存储访问串,a存储当前页面中的值
int pos1,flag1,flag2,flag3;//pos1位置变量，flag1等为标志变量
char result1[30];//记录缺页数组
四、核心代码
三种置换算法中只列出本人负责局部〔OPT算法〕，具体代码及注释如下：
void opt() //理想型
{
int i,pos[10],flag[10];//i为for循环控制语句，pos为位置变量，flag标志变量
while(1)
{
flag1=flag2=0;
for(i=0;i<length;i++)//访问串遍历
{
if(!search(order[i]))//查询要访问的页是否在存中
{
count++;
result1[i]='*';
if(a[num_page-1]!=-1) //表示当前页面已满要淘汰一个
{
memset(pos,-1,sizeof(pos));//初始pos数组
memset(flag,0,sizeof(flag));//初始flag数组
int j,k;
for( j=i;j<length;j++)//找当前页中的值在将来访问串中对应最近位置
{
for( k=0;k<num_page;k++)
{
if(order[j]==a[k]&&flag[k]==0)
{
pos[k]=j;
flag[k]=1;
}
}
}
cout<<endl;
int max=-10,max_pos;
for( k=0;k<num_page;k++)//找出位置最远的那个值
{
if(pos[k]==-1)//未出现那么跳出，替换该值
{
max_pos=k;
break;
}
else if(max<pos[k])
{
max=pos[k];
max_pos=k;
}
}
a[max_pos]=order[i];
}
else //还有空页,直接调入存
{
for(int j=0;j<num_page;j++)
{
if(a[j]==-1)
{
a[j]=order[i];
break;
}
}
}
}
else result1[i]=' ';
for(int j=0;j<num_page;j++)
{
result[j][i]=a[j];
}
}
again(); //再操作
if(flag1==0&&flag2==0)
break;
}
}

其中的查询函数search〔〕具体代码如下:
bool search(int n) //查找当前存中是否已存在该页
{
int i;
for(i=0;i<num_page;i++)
{
if(a[i]==n)
return true;
}
return false;
}

其中的再操作函数again〔〕，具体代码如下：
void again() //用于再输入
{
print();
int numpage,m;
printf("************************************** \n");
printf(" 1.重新输入新序列.\n");
printf(" 2.不改变访问序列只改变页面数.\n");
printf(" 0.不操作退出.\n");
printf("************************************** \n");
printf(" 选择所要操作:");
scanf("%d",&m);
if(m==1)
{
flag1=1; //重新输入
init();
}
else if(m==2)
{
flag2=1;
cout<<"输入新页面数：";
cin>>numpage;
num_page=numpage;memset(a,-1,sizeof(a));
}
else return ;
}

五、运行截图
根据不同的分工，限于纸只列出局部截图，以下是对OPT调度算法的实验截图：

图5.1 一样的存容量下不同的访问串序列1

图5.2 一样的存容量下不同的访问串序列2
依上图5.1和5.2来看，OPT调度算法在访问串长度一致，随机值不同以致产生不同的访问串序列时，但页面数一样的情况下，所得到的命中率也不同。

图5.3　不同的存容量下一样的访问串序列
在上图5.3中就是对同一访问串序列进展OPT调度，只是改变其页面的大小，得到了不同的命中率。

六、小结
生程序，并说明随机的性能和其性能可能对算法的影响，对随机性要有一定的参数控制能力；计算并输出FIFO及LRU算法在不同存容量下的命中率。
做了这么屡次课程设计了，大致的过程都熟悉了，每次的动手实践，调动了我们主动学习的积极性, 并引导我们根据实际编程要求, 训练自己实际分析问题的能力及编程能力, 并养成良好的编程习惯。 通过详细的实例, 循序渐进地启发我们完成设计课程设计将要求。
从拿到题目到完成整个编程，从理论到实践可以学到很多很多的东西，同时不仅可以稳固了以前所学过的知识，而且学到了很多在书本上所没有学到过的知识。通过这次课程设计使我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正为社会效劳，从而提高自己的实际动手能力和独立思考的能力。知识的获得是无止境的，只要你想学，只要你行动，就一定会有所收获的。回首这两个星期的课程设计，尽管很是头痛，很多都不会，但经过努力，我们还是学了不少知识的。这期间，教师给了我们多帮助，非常感！

附录
所有源程序代码如下：
#include<iostream>
#include<stdlib.h>
using namespace std;
int length,num_page,count,seed;
int result[20][30],order[30],a[10];
int pos1,flag1,flag2,flag3;
char result1[30];
void init()
{
memset(a,-1,sizeof(a));
int i;
cout<<"输入访问串的长度:";
cin>>length;
cout<<"输入种子数控制产生的随机值：";
cin>>seed;
srand(seed);
cout<<"产生的随机访问串:";
for(i=0;i<length;i++)
{
// cin>>order[i];
order[i]=rand()%10;
cout<<order[i]<<" ";
}
cout<<endl;
cout<<"输入页面的个数：";
cin>>num_page;
}

void print()
{
int i,j;
cout<<"(*表示缺页)"<<endl;
cout<<endl;
for( j=0;j<length;j++)
printf("%2d ",order[j]);
cout<<endl;
for( i=0;i<num_page;i++)
{
for( j=0;j<length;j++)
{
if(result[i][j]==-1)
{
printf(" ");
}
else
printf("%2d ",result[i][j]);
}
cout<<endl;
}
for( j=0;j<length;j++)
{
printf("%2c ",result1[j]);
}
cout<<endl;
cout<<"缺页率："<<count<<"/"<<length;
printf("=%.1lf",(count*1.0)/(length*1.0)*100);
cout<<"%"<<endl;
}
bool search(int n) //查找当期存是否已存在
{
int i;
for(i=0;i<num_page;i++)
{
if(a[i]==n)
return true;
}
return false;
}
void again() //用于再输入
{
print();
int numpage,m;
printf("************************************** \n");
printf(" 1.重新输入新序列.\n");
printf(" 2.不改变访问序列只改变页面数.\n");
printf(" 0.不操作退出.\n");
printf("************************************** \n");
printf(" 选择所要操作:");
scanf("%d",&m);
if(m==1)
{
flag1=1; //重新输入
init();
}
else if(m==2)
{
flag2=1;
cout<<"输入新页面数：";
cin>>numpage;
num_page=numpage;memset(a,-1,sizeof(a));
}
else return ;
}
void fifo() //先进先出
{
int i,thisn=0;
while(1)
{
count=0;
flag1=flag2=0;
for(i=pos1;i<length;i++)
{
if(!search(order[i]))
{
count++;
result1[i]='*';
if(a[num_page-1]!=-1) //表示当前页面已满要淘汰一个
{
a[thisn]= order[i];
thisn++;
if(thisn>=num_page)
thisn=0;
}
else
{
for(int j=0;j<num_page;j++)
{
if(a[j]==-1)
{
a[j]=order[i];
break;
}
}
}
}
else result1[i]=' ';
for(int j=0;j<num_page;j++)
{
result[j][i]=a[j];
}
}
again(); //再操作
if(flag1==0&&flag2==0)
break;
}
}
void lru() //最久最近没使用
{
int i,pos[10];
while(1)
{
count=0;
flag1=flag2=0;
memset(pos,-1,sizeof(pos));
for(i=pos1;i<length;i++)
{
if(!search(order[i]))
{
count++;
result1[i]='*';
if(a[num_page-1]!=-1) //表示当前页面已满要淘汰一个
{
int j,k;
for( j=0;j<i;j++) //查找当前页中的值对应的最近位置
{
for( k=0;k<num_page;k++)
{
if(order[j]==a[k])
{
pos[k]=j;
}
}
}
int min=pos[0],min_pos=0;
for( k=1;k<num_page;k++)//找出位置最远的那个
{
if(min>pos[k])
{
min=pos[k];
min_pos=k;
}
}
a[min_pos]=order[i];
}
else //还有空页
{
for(int j=0;j<num_page;j++)
{
if(a[j]==-1)
{
a[j]=order[i];
break;
}
}
}
}
else result1[i]=' ';
for(int j=0;j<num_page;j++)
{
result[j][i]=a[j];
}
}
again(); //再操作
if(flag1==0&&flag2==0)
break;
}
}
void opt() //理想型
{
int i,pos[10],flag[10];
while(1)
{
flag1=flag2=0;
for(i=0;i<length;i++)
{
if(!search(order[i]))
{
count++;
result1[i]='*';
if(a[num_page-1]!=-1) //表示当前页面已满要淘汰一个
{
memset(pos,-1,sizeof(pos));
memset(flag,0,sizeof(flag));
int j,k;
for( j=i;j<length;j++)//找出当前页中的值在将来访问串中对应的最近位置
{
for( k=0;k<num_page;k++)
{
if(order[j]==a[k]&&flag[k]==0)
{
pos[k]=j;
flag[k]=1;
}
}
}
cout<<endl;
int max=-10,max_pos;
for( k=0;k<num_page;k++)//找出位置最远的那个值
{
if(pos[k]==-1)//未出现那么跳出，替换该值
{
max_pos=k;
break;
}
else if(max<pos[k])
{
max=pos[k];
max_pos=k;
}
}
a[max_pos]=order[i];
}
else //还有空页
{
for(int j=0;j<num_page;j++)
{
if(a[j]==-1)
{
a[j]=order[i];
break;
}
}
}
}
else result1[i]=' ';
for(int j=0;j<num_page;j++)
{
result[j][i]=a[j];
}
}
again(); //再操作
if(flag1==0&&flag2==0)
break;
}
}
void mune()
{
int m;
printf("\n**************************************\n\n");
printf(" 动态分配分区法演示\n");
printf("\n************************************** \n\n");
printf(" 1.先进先出算法.\n\n");
printf(" 2.最久最近未使用页面置换算法.\n\n");
printf(" 3.理想型淘汰算法.\n\n");
printf(" 0.退出程序.\n");
printf("\n************************************** \n");
printf("\n 选择所要操作:");
scanf("%d",&m);
switch(m)
{
case 1:
init();
fifo( );
mune();
break;
case 2:
init();
lru( );
mune();
break;
case 3:
init();
opt( );
mune();
break;
case 0:
break;
default:
printf("选择错误,重新选择.");
mune();
}
}
void main() //主函数
{
mune();
}
. .word.zl.