Linux操作系统实验报告存储管理试验参考模板Word下载.docx
- 文档编号:5829342
- 上传时间:2023-05-05
- 格式:DOCX
- 页数:17
- 大小:271.74KB
Linux操作系统实验报告存储管理试验参考模板Word下载.docx
《Linux操作系统实验报告存储管理试验参考模板Word下载.docx》由会员分享,可在线阅读,更多相关《Linux操作系统实验报告存储管理试验参考模板Word下载.docx(17页珍藏版)》请在冰点文库上搜索。
(5)实验假设申请和释放的页数都是2的整次幂。
(1)建立工作集页面模型。
(2)利用随机函数动态生成进程访问页面的序列号。
(3)实现FIFO页面淘汰算法。
(4)实现页故障率反馈模型。
2、实验目的与要求
①
(1)用C语言是实现模拟Linux系统中连续内存分配用到的伙伴对算法。
(2)通过链表的形式输出在内存申请和释放过程中内存状态的对比图。
②
(1)了解工作集模型的原理及其特点。
(2)实现页故障率反馈模型。
3、实验步骤与源程序
1.Buddyheap算法模拟
源程序;
#include<
stdio.h>
stdlib.h>
typedefstructblock
{
intsize;
intstart;
intloc;
structblock*next;
structblock*prior;
}block;
intmaxsize=512;
block*note;
block*id[10];
voidprintmem(){
inti;
for(i=9;
i>
=0;
i--){
printf("
%d->
"
i);
block*temp=(structblock*)malloc(sizeof(structblock));
temp=id[i]->
next;
while(temp!
=NULL){
printf("
%d(%s)(%d)->
temp->
size,temp->
loc==1?
占用"
:
空闲"
start);
temp=temp->
}
\n"
);
}
}
voidinit(){
for(i=0;
i<
9;
i++){
id[i]=(structblock*)malloc(sizeof(structblock));
id[i]->
prior=id[i];
id[i]->
next=NULL;
note=(structblock*)malloc(sizeof(structblock));
note->
size=maxsize;
start=0;
loc=0;
id[9]=(structblock*)malloc(sizeof(structblock));
id[9]->
next=note;
prior=id[9];
printmem();
intpower(intx,inty){
intk=0,tmp=1;
for(;
k<
y;
k++){
tmp=tmp*x;
returntmp;
introot(intx,inty){
intresult=y,count=0;
while(result!
=1){
result=result/x;
count++;
returncount;
intsplit(inttempId){
block*pend=(structblock*)malloc(sizeof(structblock));
block*cend=(structblock*)malloc(sizeof(structblock));
block*newf=(structblock*)malloc(sizeof(structblock));
block*newu=(structblock*)malloc(sizeof(structblock));
pend=id[tempId]->
intflag=0,isFirst=0;
while(pend!
if(pend->
loc==0){
if(isFirst==0){
id[tempId]->
next=pend->
}else{
pend->
prior->
}
intsize=(pend->
size)/2;
intstart=pend->
start;
newu->
size=size;
start=start;
newf->
start=start+size;
prior=newu;
next=newf;
tempId--;
cend=id[tempId];
while(cend->
next!
cend=cend->
cend->
next=newu;
prior=cend;
flag=1;
return1;
}else{
pend=pend->
isFirst++;
}
if(flag==0){
tempId=tempId+1;
if(tempId<
=9){
free(pend);
free(cend);
free(newu);
free(newf);
split(tempId);
return-1;
intmerge(inttempId,block*first){
block*merger=(structblock*)malloc(sizeof(structblock));
block*second=NULL;
second=id[tempId]->
intnextStart=first->
start+first->
size;
intpreStart=first->
start-first->
intflag=0,isFirst=0;
while(second!
if((second->
start==nextStart||second->
start==preStart)&
&
second->
loc==0){
merger->
size=(first->
size)+(second->
size);
start=(first->
start)<
(second->
start)?
(first->
start):
if(first->
first->
next->
prior=first->
prior;
if((first->
prior)==first->
prior){
id[tempId]->
next=first->
if(second->
second->
prior=second->
if(isFirst==0){
next=second->
}else{
tempId++;
next=id[tempId]->
prior=id[tempId];
if(id[tempId]->
=NULL)id[tempId]->
prior=merger;
id[tempId]->
next=merger;
9){
merge(tempId,merger);
return0;
return1;
}else{
second=second->
isFirst++;
return1;
intfreeb(intsize){
block*first=(structblock*)malloc(sizeof(structblock));
inttempId=root(2,size);
first=id[tempId]->
intflag=0;
while(first!
if(first->
loc==1){
first->
flag=1;
break;
first=first->
if(flag==1){
merge(tempId,first);
printmem();
}else{
需要释放的内存块不存在!
intrequestb(intsize){
block*temp=(structblock*)malloc(sizeof(structblock));
inttempId=root(2,size);
temp=id[tempId]->
while(temp!
if(temp->
loc==0&
temp->
size==size){
temp->
loc=1;
分配成功!
printmem();
}else{
temp=temp->
if(flag==0){
tempId++;
intrs=split(tempId);
if(rs==-1){
printf("
没有合适的空间可分配!
requestb(size);
return-1;
free(temp);
intmain(){
init();
intflag=1;
charorder;
do{
请输入命令:
(以空格相隔,示例:
r8)\n"
scanf("
%c%d"
&
order,&
if(order=='
r'
){
requestb(size);
}elseif(order=='
f'
freeb(size);
error!
是否继续?
(1继续,0退出):
%d"
flag);
getchar();
}while(flag==1);
结果图:
2.页故障率反馈模型
malloc.h>
#defineMAX_WORKSET10
#defineWINDOW_SIZE20
intmempage=10;
intprocArray[WINDOW_SIZE];
intwin[MAX_WORKSET][2];
doublemaxRate=0.8,minRate=0.2;
doublecurRate;
intcur_workset=3;
intconflictCount=0;
voidprint(){
curRate=(double)conflictCount/(double)WINDOW_SIZE;
printf("
缺页故障率:
%g,故障率上限/下限:
%g/%g\n"
curRate,maxRate,minRate);
voidchangeArray(){
WINDOW_SIZE;
i++){
procArray[i]=rand()%mempage;
进程调用页面序列:
%d|"
procArray[i]);
voidinit(){
inti,j;
//changeArray();
MAX_WORKSET;
win[i][0]=-1;
win[i][1]=cur_workset;
voidchangePage(intnumber){
inti,flag=0;
for(i=1;
cur_workset;
if(win[flag][1]<
=win[i][1]){
flag=i;
win[flag][0]=procArray[number];
win[flag][1]=1;
conflictCount++;
if(i!
=flag&
win[i][1]!
=-1){
win[i][1]++;
voidstep(intnumber){
inti,hit=0;
if(procArray[number]==win[i][0]){
//number++;
hit=1;
if(hit==0){
changePage(number);
voidrun(){
conflictCount=0;
changeArray();
step(i);
冲突次数:
%d,"
conflictCount);
voidfeedback(){
if(curRate>
maxRate){
cur_workset++;
}elseif(curRate<
minRate){
cur_workset--;
charquit;
run();
print();
feedback();
输入任意字符继续,q退出\n"
%c"
quit);
}while(quit!
='
q'
4、结果分析与实验体会
存储管理是操作系统中最重要的组成部分之一。
在早期计算时代,由于人们所需要的内存数目远远大于物理内存,人们设计出了各种各样的策略来解决此问题,其中最成功的是虚拟内存技术。
它使得系统中为有限物理内存竞争的进程所需内存空间得到满足。
我们以BuddyHeap算法为例,实现模拟Linux系统中连续内存分配。
BH算法具有速度快的明显特点,同时解决了外碎片问题,但带来内碎片,这是由于实际请求一般不能恰好与2i相对应,此时必须向上取整。
对于更大块的请求内碎片的浪费更严重。
为此Linux将剩余的内碎片按2j整数次幂切片并由二次分配器进行单独管理。
此外当进程物理空间不要求连续时,内存分配由第三分配器完成。
此外,这个实验还需要很好的理解FIFO算法,这是最简单的页面淘汰算法,在实现时,对应每一个页面需要有一个调入时间,该时间可设在内存中并用软件记录,不过最好设在寄存器中并由硬件记录。
当内存空间紧张时,调入时间最早的页面将被淘汰。
FIFO算法易于理解和编程,但它的效率不高。
被置换的页面可能存有一个初始化程序段,很早以前曾用到,以后不会再用到;
但也可能存有一组经常访问的全局变量,初始化时被调入内存,在整个程序运行过程中都将会用到。
这次实验难点在理论方面,在理解了之后操作比较顺利。
友情提示:
范文可能无法思考和涵盖全面,供参考!
最好找专业人士起草或审核后使用,感谢您的下载!
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Linux 操作系统 实验 报告 存储 管理 试验 参考 模板