操作系统实验三存储管理实验
班级：
学号：
姓名：
目 录
1. 实验目的... 2
2. 实验内容... 2
(1) 通过随机数产生一个指令序列，共320条指令... 2
(2) 将指令序列变换成为页地址流... 2
(3) 计算并输出下述各种算法在不同内存容量下的命中率... 2
3. 随机数产生办法... 3
环境说明... 3
4. 程序设计说明... 3
4.1. 全局变量... 3
4.2. 随机指令序列的产生... 4
4.3. FIFO算法... 4
4.4. LRU算法... 4
4.5. OPT算法... 5
5. 编程实现（源程序）：... 5
6. 运行结果及分析... 11
6.1. 运行（以某两次运行结果为例，列表如下：）... 11
6.2. Belady’s anomaly. 11
1. 实验目的
存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。
本实验的目的是通过请求页式存储管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。
2. 实验内容
(1) 通过随机数产生一个指令序列，共320条指令
指令的地址按下述原则生成：
a) 50% 的指令是顺序执行的；
b) 25% 的指令是均匀分布在前地址部分；
c) 25% 的指令是均匀分布在后地址部分；
具体的实施方法是：
a) 在[0，319]的指令地址之间随机选取一起点m；
b) 顺序执行一条指令，即执行地址为m+1的指令；
c) 在前地址[0，m+1]中随机选取一条指令并执行，该指令的地址为m¢;
d) 顺序执行一条指令，其地址为m¢+1;
e) 在后地址[m¢+2，319]中随机选取一条指令并执行;
f) 重复上述步骤a)~f)，直到执行320次指令。
(2) 将指令序列变换成为页地址流
设：
a) 页面大小为1K；
b) 用户内存容量为4页到32页；
c) 用户虚存容量为32K。
在用户虚存中，按每K存放10条指令排列虚存地址，即320条指令在虚存中的存放方式为：
第0条~第9条指令为第0页（对应虚存地址为[0，9]）；
第10条~第19条指令为第1页（对应虚存地址为[10，19]）；
…
…
第310条~第319条指令为第31页（对应虚存地址为[310，319]）。
按以上方式，用户指令可以组成32页。
(3) 计算并输出下述各种算法在不同内存容量下的命中率
a) 先进先出的算法（FIFO）；
b) 最近最少使用算法（LRU）；
c) 最佳淘汰算法（OPT）；
命中率=1-页面失效次数/页地址流长度
在本实验中，页地址流长度为320，页面失效次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
3. 随机数产生办法
关于随机数产生办法，可以采用操作系统提供的函数，如Linux或UNIX系统提供函数srand()和rand()，分别进行初始化和产生随机数。例如：
srand();
语句可以初始化一个随机数；
a[0]=10*rand()/32767*319+1;
a[1]=10*rand()/32767*a[0];
…
语句可以用来产生a[0]与a[1]中的随机数。
环境说明
此实验采用的是Win7下Code::blocks 10.05编译器编程。
此word实验文档中采用notepad++的语法高亮。
4. 程序设计说明
4.1. 全局变量
const int maxn = 320; //序列个数
const int max = maxn +20;//数组大小
const int maxp = max/10; //最大页数
int inst[max];//指令序列
int page[max];//页地址流
int size; //内存能容纳的页数
bool in[maxp]; //该页是否在内存里，提高效率
int pin[maxp]; //现在在内存里的页
其中in[]数组是为了方便直接判断该页是否在内存里，而不用遍历内存里所有页来判断。
fault_n用来记录缺页次数。
4.2. 随机指令序列的产生
按照实验要求的写了，但是由于没有考虑细节，开始时出了点问题。
（1） 当m=319时，我们顺序执行m+1会产生第32页的页地址，从而使页地址没能按要求限制在[0, 31]之间。
解决方法：采用循环模加来避免超出范围。
（2） 但是这样之后有可能出现模0的问题。所以我索性将等于0的模数都赋值为160.
最后的程序如下。
void produce_inst()
{
int m, n;
int num = 0;
while(num ＜ maxn)
{
m = rand()% maxn;
inst[num++]=(m+1)%maxn;
if(num == maxn)break;
m =(m+2)% maxn;
if(m == 0) m = 160;
n = rand()% m;
inst[num++]=(n+1)%maxn;
if(num == maxn)break;
n =(n+2)% maxn;
m = maxn - n;
if(m == 0) m = 160;
m = rand()% m + n;
inst[num++]= m;
}
}
4.3. FIFO算法
定义变量ptr。
一开始先预调页填满内存。在这一部分，ptr指向下一个要存放的位置。
之后继续执行剩下的指令。此时，ptr表示队列最前面的位置，即最先进来的位置，也就是下一个要被替换的位置。ptr用循环加，即模拟循环队列。
4.4. LRU算法
定义数组ltu[],即last_time_use来记录该页最近被使用的时间。
定义变量ti模拟时间的变化，每执行一次加一。
这个算法，我没有预调页，而是直接执行所有指令。
若当前需要的页没在内存里，就寻找最近最少使用的页，也就是ltu[]最小的页，即最近一次使用时间离现在最久的页，然后替换掉它。或者在内存还未满时，直接写入，这个我以初始化内存里所有页为-1来实现。
若已经在内存里了，则只遍历内存内的页，把当前页的最近使用时间改一下即可。
4.5. OPT算法
定义数组ntu[], 即next_time_use来记录下一次被使用的时间，即将来最快使用时间。初始化为-1.
开始时预调页填满内存里的页。同样利用变量ptr来表示下一个要存放的位置从而控制预调页的过程。
接着初始化ntu数组为-1。然后求出每一页下一次被使用的指令号，以此代替使用时间。如果所有剩下的序列都没有用该页时，则还是-1.这种值为-1的页显然是最佳替换对象。
然后执行所有剩下的指令。当该页不在内存里时，遍历ntu数组，遇到-1的直接使用该页，没有则用ntu[]值最大的，也就是最晚使用的。
无论该页在不在内存里，因为这一次已经被使用了，所以都应该更新这个页的ntu[]，只需往前看要执行的页流，记录下第一个遇到的该页即可。如果没有找到同样添-1即可。
5. 编程实现（源程序）：
#include
#include
#include
#include
usingnamespace std;
const int maxn = 320; //序列个数
const int max = maxn +20;//数组大小
const int maxp = max/10; //最大页数
int inst[max];//指令序列
int page[max];//页地址流
int size; //内存能容纳的页数
bool in[maxp]; //该页是否在内存里，提高效率
int pin[maxp]; //现在在内存里的页
void welcome()
{
printf("******************************************\n");
printf("** By schnee On20##-12-06 **\n");
printf("** 班级:09211311 班内序号：30 **\n");
printf("******************************************\n\n");
}
void input_hint()
{
printf("\n1--create new instruction sequence 2--set memory page number(4 to 32)\n");
printf("3--solve by FIFO algorithm 4--solve by LRU algorithm\n");
printf("5--solve by OPT algorithm 0--exit\n");
printf("*********Please input Your choice: ");
}
/*通过随机数产生一个指令序列，共320条指令*/
void produce_inst()
{
int m, n;
int num = 0;
while(num ＜ maxn)
{
m = rand()% maxn;
inst[num++]=(m+1)%maxn;
if(num == maxn)break;
m =(m+2)% maxn;
if(m == 0) m = 160;
n = rand()% m;
inst[num++]=(n+1)%maxn;
if(num == maxn)break;
n =(n+2)% maxn;
m = maxn - n;
if(m == 0) m = 160;
m = rand()% m + n;
inst[num++]= m;
}
}
/*将指令序列变换成为页地址流*/
void turn_page_address()
{
for(int i=0; i＜maxn; i++)
page[i]= inst[i]/10;
}
void FIFO_solve()
{
memset(in,false,sizeof(in));
int fault_n = 0;//缺页率
int ptr, i;
//预调页填满空间
ptr = 0; //下一个要放的位置
for(i=0; i＜maxn && ptr＜size; i++)
if(!in[page[i]])
{
pin[ptr++]= page[i];
in[page[i]]=true;
fault_n++;
}
//继续执行剩下的指令
ptr = 0;//队列里最先进来的位置，即下一个要被替换的位置
for(; i＜maxn; i++)
if(!in[page[i]])
{
in[pin[ptr]]=false;
in[page[i]]=true;
pin[ptr]= page[i];
fault_n++;
ptr =(ptr+1)% size;
}
printf("\nBy FIFO algorithm, the fault-page number is: %d\n", fault_n);
printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0));
}
void LRU_solve()
{
int ltu[maxp]; //last_time_use
int ti = 1; //模拟时间
int fault_n = 0;
memset(ltu, 0,sizeof(ltu));
memset(in,false,sizeof(in));
memset(pin,-1,sizeof(pin));
int min, ptr, i, j;
for(i=0; i＜maxn; i++)
{
if(!in[page[i]])
{
//寻找lru
min=1000000; ptr=0;
for(j=0; j＜size; j++)
{
if(ltu[j]＜ min)
{
min = ltu[j];
ptr = j;
}
}
//替换或写入
if(pin[ptr]!=-1)
in[pin[ptr]]=false;
in[page[i]]=true;
pin[ptr]= page[i];
fault_n++;
ltu[ptr]= ti++;
}
else//已经在内存里则只需更改最近使用时间
{
for(j=0; j＜size; j++)
if(pin[j]== page[i])
{
ltu[j]= ti++;
break;
}
}
}
printf("\nBy LRU algorithm, the fault-page number is: %d\n", fault_n);
printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0));
}
void OPT_solve()
{
int ntu[maxp];//next_time_use
int fault_n = 0;
int i, j;
memset(in,false,sizeof(in));
memset(ntu,-1,sizeof(ntu));
//预调页填满
int ptr = 0;
for(i=0; i＜maxn && fault_n＜size; i++)
{
if(!in[page[i]])
{
in[page[i]]=true;
pin[ptr]= page[i];
fault_n++;
ptr++;
}
}
//初始化ntu数组
ptr = 0;
for(j=i; j＜maxn && ptr＜32; j++)
{
if(ntu[page[j]]==-1)
{
ntu[page[j]]= j;
ptr++;
}
}
int max;
for(; i＜maxn; i++)
{
if(!in[page[i]])
{
max = 0;ptr = 0;
for(j=0; j＜size; j++)
{
if(ntu[pin[j]]==-1)
{
ptr = j;
break;
}
if(ntu[pin[j]]＞ max)
{
max = ntu[pin[j]];
ptr = j;
}
}
in[pin[ptr]]=false;
in[page[i]]=true;
pin[ptr]= page[i];
fault_n++;
}
ntu[page[i]]=-1;
for(j=i+1; j＜maxn; j++)
if(page[j]== page[i])
{
ntu[page[i]]= j;
break;
}
}
printf("\nBy OPT algorithm, the fault-page number is: %d\n", fault_n);
printf(" the hit ratio is : %.2lf\n",(1-(fault_n+0.0)/320.0));
}
int main()
{
srand(time(NULL));
welcome();
int choice;
while(1)
{
input_hint();
scanf("%d",&choice);
printf("\n");
if(choice == 0)
{
printf("BYE-BYE!!!\n");
break;
}
if(choice == 1)
{
produce_inst();
turn_page_address();
printf("New page address sequence is set OK!!!\n");
}
elseif(choice == 2)
{
printf("Please input the size of memory page number: ");
scanf("%d",&size);
}
elseif(choice == 3)
FIFO_solve();
elseif(choice == 4)
LRU_solve();
elseif(choice == 5)
OPT_solve();
else
printf("INPUT ERROR !!! \n");
}
return 0;
}
6. 运行结果及分析
6.1. 运行（以某两次运行结果为例，列表如下：）
随着页数的增多，除了FIFO对某些序列会有Belady’s anomaly（详见6.2）外，大部分情况和LRU算法、OPT算法都是缺页率减小。
OPT是理想情况，效率是最高的。当然当不缺页时，所有的算法缺页次数都是把所有页调进去的次数。
LRU算法有时候和FIFO算法的效率差别并不大。甚至有时候它还比FIFO低一些的。
6.2. Belady’s anomaly
如下，我稍微改了下输入，手动输入课本上的样例，编程见证了Belady异常现。这是只有FIFO算法才有的异常。
