模拟内存管理 最终.docx
《模拟内存管理 最终.docx》由会员分享，可在线阅读，更多相关《模拟内存管理 最终.docx（20页珍藏版）》请在冰豆网上搜索。
模拟内存管理最终
理学院模拟内存管理实验报告
年级二
学号2012518074
姓名刘丹
成绩_______________
专业信息与计算科学
实验地点理学院四楼机房
指导教师姚斌
实验项目用C语言实现模拟内存管理
实验日期2014年4月——5月
一、实验目的
1、通过本次试验体会操作系统中内存的分配模式；
2、掌握内存分配的方法；
3、学会进程的建立，当一个进程被终止时内存是如何处理被
释放块，并当内存不满足进程申请时是如何使用内存紧
凑；
4、学会进行内存的申请释放和管理；
二、实验问题描述
用C++编程模拟内存管理
三、实验步骤
功能（函数）设计：
通过在C++上编程实现当一个进程被终止时内存的处理及内存的申请释放和管理。
四、实验结果（程序）及分析
1、实验主要代码
#include
#include
#include
#definePROCESS_NAME_LEN32//进程名字长度http:
//yige.org/
#defineMIN_SLICE10//最小碎片大小
#defineDEFAULT_MEM_SIZE1024//默认的内存大小
#defineDEFAULT_MEM_START0//起始地址
#defineMA_FF1//首次适应算法
#defineMA_BF2//最佳适应算法
#defineMA_WF3//最坏适应算法//空闲分区的结构体
typedefstructfree_block_type{
intsize;
intstart_addr;
structfree_block_type*next;
}
free_block_type;
free_block_type*free_block;//已分配分区的结构体
typedefstructallocated_block{
intpid;
intsize;
intstart_addr;
charprocess_name[PROCESS_NAME_LEN];
structallocated_block*next;
}allocated_block;
structallocated_block*allocated_block_head=NULL;
intmem_size=DEFAULT_MEM_SIZE;
intma_algorithm=MA_FF;
staticintpid=0;
intflag=0;//函数声明
voiddisplay_menu（）;
intset_mem_size（）;
voidset_algorithm（）;
voidrearrange（intalgorithm）;
intnew_process（）;
intallocate_mem（structallocated_block*ab）;
voidkill_process（）;
intfree_mem（structallocated_block*ab）;
intdispose（structallocated_block*free_ab）;
intdisplay_mem_usage（）;
allocated_block*find_process（intpid）;
voidrearrange_FF（）;
voidrearrange_BF（）;
voidrearrange_WF（）;//初始化空闲分区
free_block_type*init_free_block（intmem_size）{
free_block_type*fb;
fb=（free_block_type*）malloc（sizeof（free_block_type））;
if（fb==NULL）{
printf（"Nomem\n"）;
returnNULL;
}
fb->size=mem_size;
fb->start_addr=DEFAULT_MEM_START;
fb->next=NULL;
returnfb;
}//显示主菜单
voiddisplay_menu（）{
printf（"\n"）;
printf（"4-Terminateaprocess\n"）;
printf（"5-Displaymemoryusage\n"）;
printf（"0-Exit\n"）;
}/*设置内存大小*/
intset_mem_size（）{
intsize;
if（flag!
=0）{/*flag标志防止内存被再次设置*/
printf（"Cannotsetmemorysizeagain\n"）;
return0;
}
printf（"Totalmemorysize="）;
scanf（"%d",&size）;
if（size>0）{
mem_size=size;
free_block->size=mem_size;/*设置初始大小为1024*/
}
flag=1;
return1;
}
/*选择当前算法*/
voidset_algorithm（）{
intalgorithm;
printf（"\t1-FirstFit\n"）;
printf（"\t2-BestFit\n"）;
printf（"\t3-WorstFit\n"）;
printf（"Pleaseinputyourchoice:
"）;
scanf（"%d",&algorithm）;
if（algorithm>=1&&algorithm<=3）
ma_algorithm=algorithm;
rearrange（ma_algorithm）;
}/*为每一个进程分配完内存以后重新按已选择的算法再次排序*/
voidrearrange（intalgorithm）{
switch（algorithm）{
caseMA_FF:
rearrange_FF（）;break;
caseMA_BF:
rearrange_BF（）;break;
caseMA_WF:
rearrange_WF（）;break;
}
}
/*首次适应算法，按地址的大小由小到达排序*/
voidrearrange_FF（）{
free_block_type*temp,*p=NULL;
free_block_type*head=NULL;
intcurrent_min_addr;
if（free_block）{
temp=free_block;
current_min_addr=free_block->start_addr;
while（temp->next!
=NULL）{
if（temp->next->start_addrcurrent_min_addr=temp->next->start_addr;
p=temp;
}
temp=temp->next;
}
if（p!
=NULL）{
temp=p->next;
p->next=p->next->next;
temp->next=free_block;
free_block=temp;
}
head=free_block;
p=head;
temp=head->next;
while（head->next!
=NULL）{
current_min_addr=head->next->start_addr;
while（temp->next!
=NULL）{
if（temp->next->start_addrcurrent_min_addr=temp->next->start_addr;
p=temp;
}
temp=temp->next;
}
if（p->next!
=head->next）{
temp=p->next;
p->next=p->next->next;
temp->next=head->next;
head->next=temp;
}
head=head->next;
temp=head->next;
p=head;
}
}
return;
}/*最佳适应算法，按内存块的大小由小到大排序*/
voidrearrange_BF（）{
free_block_type*temp,*p=NULL;
free_block_type*head=NULL;
intcurrent_min_size=free_block->size;
temp=free_block;
while（temp->next!
=NULL）{
if（temp->next->sizecurrent_min_size=temp->next->size;
p=temp;
}
temp=temp->next;
}
if（p!
=NULL）{
temp=p->next;
p->next=p->next->next;
temp->next=free_block;
free_block=temp;
}
head=free_block;
p=head;
temp=head->next;
while（head->next!
=NULL）{
current_min_size=head->next->size;
while（temp->next!
=NULL）{
if（temp->next->sizecurrent_min_size=temp->next->size;
p=temp;
}
temp=temp->next;
}
if（p->next!
=head->next）{
temp=p;
p->next=p->next->next;
temp->next=head->next;
head->next=temp;
}
head=head->next;
temp=head->next;
p=head;
}
}/*最坏适应算法，按地址块的大小从大到小排序*/
voidrearrange_WF（）{
free_block_type*temp,*p=NULL;
free_block_type*head=NULL;
intcurrent_max_size=free_block->size;
temp=free_block;
while（temp->next!
=NULL）{
if（temp->next->size>current_max_size）{
current_max_size=temp->next->size;
p=temp;
}
temp=temp->next;
}
if（p!
=NULL）{
temp=p;
p->next=p->next->next;
temp->next=free_block;
free_block=temp;
}
head=free_block;
p=head;
temp=head->next;
while（head->next!
=NULL）{
current_max_size=head->next->size;
while（temp->next!
=NULL）{
if（temp->next->size>current_max_size）{
current_max_size=temp->next->size;
p=temp;
}
temp=temp->next;
}
if（p->next!
=head->next）{
temp=p->next;
p->next=p->next->next;
temp->next=head->next;
head->next=temp;
}
head=head->next;
temp=head->next;
p=head;
}
return;
}//创建一个新的进程
intnew_process（）{
structallocated_block*ab;
intsize;
intret;
ab=（structallocated_block*）malloc（sizeof（structallocated_block））;
if（!
ab）exit（-5）;
ab->next=NULL;
pid++;
sprintf（ab->process_name,"PROCESS-%02d",pid）;
ab->pid=pid;
printf（"Memoryfor%s:
",ab->process_name）;
printf（"Pleaseinputyouwanttoallocateprocess'size:
"）;
scanf（"%d",&size）;
if（size>0）{
ab->size=size;
}
ret=allocate_mem（ab）;
if（（ret==1）&&（allocated_block_head==NULL））{
allocated_block_head=ab;
return1;}
elseif（ret==1）{
ab->next=allocated_block_head;
allocated_block_head=ab;
return2;}
elseif（ret==-1）{
printf（"Allocationfail\n"）;
pid--;
free（ab）;
return-1;
}
return3;
}//内存分配
intallocate_mem（structallocated_block*ab）{
free_block_type*fbt,*pre;
free_block_type*temp,*p,*p1;
allocated_block*q;
intrequest_size=ab->size;
intsum=0;
intmax;
fbt=pre=free_block;
if（fbt）{
if（ma_algorithm==MA_WF）{
if（fbt==NULL||fbt->sizereturn-1;
}
else{
while（fbt!
=NULL&&fbt->sizepre=fbt;
fbt=fbt->next;
}
}
if（fbt==NULL||fbt->sizeif（free_block->next!
=NULL）{
sum=free_block->size;
temp=free_block->next;
while（temp!
=NULL）{
sum+=temp->size;
if（sum>=request_size）
break;
temp=temp->next;
}
if（temp==NULL）
return-1;
else{
pre=free_block;
max=free_block->start_addr;
fbt=free_block;
while（temp->next!
=pre）{
if（maxstart_addr）{
max=pre->start_addr;
fbt=pre;
}
pre=pre->next;
}
pre=free_block;
while（pre!
=temp->next）
{
q=allocated_block_head;
p=free_block;
while（q!
=NULL）
{
if（q->start_addr>pre->start_addr）
q->start_addr=q->start_addr-pre->size;
q=q->next;
}
while（p!
=NULL）
{
if（p->start_addr>pre->start_addr）
p->start_addr=p->start_addr-pre->size;
p=p->next;
}
pre=pre->next;
}
pre=free_block;
while（pre!
=temp->next）{
p1=pre->next;
if（pre==fbt）
break;
free（pre）;
pre=p1;
}
q=allocated_block_head;
free_block=fbt;
free_block->start_addr=q->start_addr+q->size;
free_block->size=sum;
free_block->next=temp->next;
if（free_block->size-request_sizeab->size=free_block->size;
ab->start_addr=free_block->start_addr;
pre=free_block;
free_block=free_block->next;
free（pre）;
}
else{
ab->start_addr=free_block->start_addr;
free_block->start_addr=free_block->start_addr+request_size;
free_block->size=free_block->size-request_size;
}
}
}
else
return-1;
}
else{
if（fbt->size-request_sizeab->size=fbt->size;
ab->start_addr=fbt->start_addr;
if（pre->next==free_block）{
free_block=fbt->next;
}
else{
pre->next=fbt->next;
}
free_block=fbt->next;
free（fbt）;
}
else{
ab->start_addr=fbt->start_addr;
fbt->start_addr=fbt->start_addr+request_size;
fbt->size=fbt->size-request_size;
}
}
rearrange（ma_algorithm）;
return1;
}
else
{
printf（"FreeMemoryalreadyhasbeenallocatedover:
"）;
return-1;
}
}//选择杀死一个进程
voidkill_process（）{
structallocated_block*ab;
intpid;
printf（"KillProcess,pid="）;
scanf（"%d",&pid）;
ab=find_process（pid）;
if（ab!
=NULL）{
free_mem（ab）;
dispose（ab）;
}
}//找到要杀死的进程的标号
allocated_block*find_process（intpid）{
allocated_block*abb;
abb=allocated_block_head;
if（abb->pid==pid）
{
returnabb;
}
abb=allocated_block_head->next;
while（abb->next!
=NULL）{
if（abb->pid==pid）
returnabb;
abb=abb->next;
}
returnabb;
}//释放杀死进程的内存块
intfree_mem（structallocated_block*ab）{
intalgorithm=ma_algorithm;
structfree_block_type*fbt,*pre;
fbt=（structfree_block_type*）malloc（sizeof（structfree_block_type））;
pre=（structfree_block_type*）malloc（sizeof（structfree_block_type））;
if（!
fbt）return-1;
fbt->start_addr=ab->start_addr;
fbt->size=ab->size;
fbt->next=free_block;
free_block=fbt;
rearrange_FF（）;
pre->next=free_block;
pre->size=0;
while（pre->next&&（pre->next->start_addr!
=fbt->start_addr））
pre=pre->next;
if（pre->size!
=0&&fbt->next!
=NULL）
{if（（（pre->start_addr+pre->size）==fbt->start_addr）&&（（fbt->start_addr+fbt->size）==fbt->next->start_addr））{
pre->size=pre->size+fbt->size+fbt->next->size;
pre->next=fbt->next->next;
free（fbt->next）;
free（fbt）;
}
elseif（（pre->start_addr+pre->size）==fbt->start_addr）{
pre->size=pre->size+fbt->size;
pre->next=fbt->next;
free（fbt）;
}
elseif（fbt->s
升级会员 