兰州大学操作系统实验八存储管理模拟题目和答案实验报告文档格式.docx

兰州大学操作系统实验八存储管理模拟题目和答案实验报告文档格式.docx

《兰州大学操作系统实验八存储管理模拟题目和答案实验报告文档格式.docx》由会员分享，可在线阅读，更多相关《兰州大学操作系统实验八存储管理模拟题目和答案实验报告文档格式.docx（13页珍藏版）》请在冰豆网上搜索。

包含链表：

空闲页面表忙页面表

包含数组：

进程数组页面号数组

流程图：

否

是

实验结果分析：

观察数据可看出：

横向：

三种替换算法的命中率由高到底排列应该是LRU>

CLOCK>

FIFO。

纵向：

进程的驻留级越大，其缺页率就越低。

实验体会：

1.存中进程的多少会影响驻留集大小和缺页中断率。

如果存中进程太多，将导致每个进程的驻留集太小，发生缺页中断的概率很大。

相应地，系统发生抖动的可能性就会很大。

如果在存中保持太少的活动进程，那么所有活动进程同时处于阻塞状态的可能性就会很大，从而降低处理机的利用率。

2.置换算法的好坏将直接影响系统的性能，不适当的置换算法可能导致系统出现“抖动”现象。

常用的页面置换算法：

最正确置换算法、最近最少使用算法、先进先出算法和时钟算法等。

最正确置换算法难以实现但可以成为核对其他算法的标准。

3.也应注意负载问题，解决系统应当保持多少个活动进程驻留在存的问题，即控制多道程序系统的度。

当存中的活动进程数太少时，负载控制将增加新进程或激活一些挂起进程进入存；

反之，当存中的进程数太多时，负载控制将暂时挂起一些进程，减少存中的活动进程数。

实验代码：

#include<

stdio.h>

stdlib.h>

unistd.h>

string.h>

#defineTRUE1

#defineFALSE0

#defineINVALID-1

#definetotal_instruction320//指令流长

#definetotal_vp32//页长

#defineclear_period50

typedefstruct//页面结构

{

intpn,//页面序号

pfn,//页面所在存区的页框号

counter,//单位时间访问次数

time;

//上次访问的时间

}pl_type;

pl_typepl[total_vp];

//页面结构数组

structpfc_struct{//页面控制结构

intpn,//页面号

pfn;

//存区页面的页框号

structpfc_struct*next;

//页面指针，用于维护存缓冲区的链式结构

};

typedefstructpfc_structpfc_type;

//主存区页面控制结构别名

pfc_typepfc[total_vp],//主存区页面控制结构数组

*freepf_head,//主存区页面控制结构的空闲页面头指针

*busypf_head,//主存区页面控制结构的忙页面头指针

*busypf_tail;

//主存区页面控制结构的忙页面尾指针

intdiseffect;

//页错误计数器，初次把页面载入主存时也当做页错误

inta[total_instruction];

//随即指令流数组

intpage[total_instruction];

//指令对应的页面号

intoffset[total_instruction];

//指令所在页面中的偏移量

intinitialize（int）;

//初始化页面结构数组和页面控制结构数组

intFIFO（int）;

//先进先出算法

intLRU（int）;

//最近最久未使用算法

intCLOCK（int）;

//简单时钟（钟表）算法

intmain（）

ints;

//随机数

inti;

srand（10*getpid（））;

/*每次运行时进程号不同，用来作为初始化随机数队列的"

种子"

*/

s=（int）（（float）（total_instruction-1）*（rand（）/（RAND_MAX+1.0）））;

printf（"

\n--------randinstructionsqueue--------\n"

）;

for（i=0;

i<

total_instruction;

i+=4）//产生指令队列

{

a[i]=s;

//任选一指令访问点m

a[i+1]=a[i]+1;

//顺序执行一条指令

a[i+2]=（int）（（float）a[i]*（rand（）/（RAND_MAX+1.0）））;

//执行前地址指令m'

a[i+3]=a[i+2]+1;

%6d%6d%6d%6d\n"

a[i],a[i+1],a[i+2],a[i+3]）;

s=（int）（（float）（（total_instruction-1）-a[i+2]）*（rand（）/（RAND_MAX+1.0）））+a[i+2];

}

--------------------------------------\n"

i<

i++）//将指令序列变换成页地址流

page[i]=a[i]/10;

offset[i]=a[i]%10;

comparethethreemethods:

"

\n--------------------------------------\n"

Rss\tFIFO\tLRU\tCLOCK\n"

for（i=4;

=32;

i++）//用户存工作区从4个页面到32个页面

%2d\t"

i）;

FIFO（i）;

LRU（i）;

CLOCK（i）;

\n"

return0;

}

//初始化页面结构数组和页面控制结构数组

//total_pf;

用户进程的存页面数

intinitialize（inttotal_pf）

diseffect=0;

for（i=0;

total_vp;

i++）

pl[i].pn=i;

pl[i].pfn=INVALID;

//置页面所在主存区的帧号为-1.表示该页不在主存中

pl[i].counter=0;

//置页面结构中的访问次数为0

pl[i].time=-1;

//置页面结构中的上次访问的时间为-1

total_pf-1;

pfc[i].next=&

pfc[i+1];

//建立pfc[i-1]和pfc[i]之间的

pfc[i].pfn=i;

//初始化主存区页面的页框号

pfc[total_pf-1].next=NULL;

pfc[total_pf-1].pfn=total_pf-1;

freepf_head=&

pfc[0];

//主存区页面控制结构的空闲页面头指针指向pfc[0]

return0;

//最近最久未使用算法

//inttotal_pf;

intLRU（inttotal_pf）

intMinT;

//最小的访问时间，即很久没被访问过

intMinPn;

//拥有最小的访问时间的页的页号

inti,j;

intCurrentTime;

//系统当前时间

initialize（total_pf）;

CurrentTime=0;

if（pl[page[i]].pfn==INVALID）//页面失效

diseffect++;

//页错误次数加

if（freepf_head==NULL）//无空闲页面

MinT=100000;

for（j=0;

j<

j++）{//找出time的最小值，说明该页很久没被访问过

if（MinT>

pl[j].time&

&

pl[j].pfn!

=INVALID）

MinT=pl[j].time;

MinPn=j;

pfc[pl[MinPn].pfn];

//最久没被访问过的页被释放

pl[MinPn].pfn=INVALID;

//最久没被访问过的页被换出主存

pl[MinPn].time=-1;

//最久没被访问过的页的访问时间置为无效

freepf_head->

next=NULL;

pl[page[i]].pfn=freepf_head->

pfn;

//有空闲页面,把相应的页面换入主存，并把pfn改为相应的页框号

pl[page[i]].time=CurrentTime;

//令访问时间为当前系统时间

freepf_head=freepf_head->

next;

//减少一个空闲页面

else

//命中则刷新该单元的访问时间

CurrentTime++;

//系统当前时间加

%6.3f\t"

1-（float）diseffect/320）;

//简单时钟算法

intCLOCK（inttotal_pf）

intuse[total_vp];

//使用位

intswap;

swap=0;

//发生替换

pfc_type*pnext;

//时钟指针

pfc_type*head;

//队列头指针

pnext=freepf_head;

head=freepf_head;

i++）{use[i]=0;

}//初始化使用位为

if（pl[page[i]].pfn==INVALID）//页面失效,不在主存中

while（use[pnext->

pfn]==1）//若时钟指针指向的页的使用位为，则