实验四 动态分区分配算法Word格式.docx
《实验四 动态分区分配算法Word格式.docx》由会员分享，可在线阅读，更多相关《实验四 动态分区分配算法Word格式.docx（21页珍藏版）》请在冰豆网上搜索。
structallocated_block{
intpid;
intsize;
intstart_addr;
charprocess_name[PROCESS_NAME_LEN];
structallocated_block*next;
};
structallocated_block*allocated_block_head=NULL;
//函数声明
structfree_block_type*init_free_block（intmem_size）;
voiddisplay_menu（）;
intset_mem_size（）;
voidset_algorithm（）;
voidrearrange（intalgorithm）;
intrearrange_FF（）;
intrearrange_BF（）;
intrearrange_WF（）;
intnew_process（）;
intallocate_mem（structallocated_block*ab）;
voidkill_process（）;
intfree_mem（structallocated_block*ab）;
intdispose（structallocated_block*free_ab）;
intdisplay_mem_usage（）;
voiddo_exit（）;
structallocated_block*find_process（intpid）;
intmain（）{
charchoice;
pid=0;
free_block=init_free_block（mem_size）;
//初始化空闲区
while
（1）{
display_menu（）;
//显示菜单
fflush（stdin）;
choice=getchar（）;
//获取用户输入
switch（choice）{
case'
1'
:
set_mem_size（）;
break;
//设置内存大小
2'
set_algorithm（）;
flag=1;
//设置算法
3'
new_process（）;
flag=1;
//创建新进程
4'
kill_process（）;
//删除进程
5'
display_mem_usage（）;
//显示内存使用
0'
do_exit（）;
exit（0）;
//释放链表并退出
default:
}
return1;
}
structfree_block_type*init_free_block（intmem_size）{
structfree_block_type*fb;
fb=（structfree_block_type*）malloc（sizeof（structfree_block_type））;
if（fb==NULL）{
printf（Nomem\n）;
returnNULL;
fb->
size=mem_size;
start_addr=DEFAULT_MEM_START;
fb->
next=NULL;
returnfb;
voiddisplay_menu（）{
printf（\
）;
printf（-Setmemorysize（default=%d）\n,DEFAULT_MEM_SIZE）;
printf（-Selectmemoryallocationalgorithm\n）;
printf（-Newprocess\n）;
printf（-Terminateaprocess\n）;
printf（_x0005_-Displaymemoryusage\n）;
printf（
intset_mem_size（）{
if（flag!
=0）{//防止重复设置
printf（Cannotsetmemorysizeagain\n）;
return0;
printf（Totalmemorysize=）;
scanf（%d,&
size）;
if（size>
0）{
mem_size=size;
free_block->
voidset_algorithm（）{
intalgorithm;
printf（\1-FirstFit\n）;
printf（\2-BestFit\n）;
printf（\3-WorstFit\n）;
algorithm）;
if（algorithm>
=1&
&
algorithm<
=3）{
ma_algorithm=algorithm;
else
牰湩晴尨输入有误，请重新输入！
\n）;
//按指定算法重新排列空闲区链表
rearrange（ma_algorithm）;
voidrearrange（intalgorithm）{
switch（algorithm）{
caseMA_FF:
rearrange_FF（）;
caseMA_BF:
rearrange_BF（）;
caseMA_WF:
rearrange_WF（）;
//首次适应算法
intrearrange_FF（）{
structfree_block_type*temp;
//使用头插法，thead为临时头,p为最小地址的数据块的前一个结点
structfree_block_type*thead=NULL,*p=NULL;
//当前的最小地址
intmin_addr=free_block->
start_addr;
temp=free_block;
while（temp->
next!
=NULL）{
if（temp->
next->
start_addr<
min_addr）{
min_addr=temp->
p=temp;
temp=temp->
next;
if（NULL!
=p）{
temp=p->
p->
next=p->
temp->
next=free_block;
free_block=temp;
thead=free_block;
p=free_block;
temp=free_block->
while（thead->
min_addr=thead->
if（p->
=thead->
next）{
next=thead->
thead->
next=temp;
thead=thead->
p=thead;
temp=thead->
//最佳适应算法
intrearrange_BF（）{
//使用头插法，thead为临时头,p为最小内存的数据块的前一个结点
//当前的最小内存
intmin_size=free_block->
size;
size<
min_size）{
min_size=temp->
min_size=thead->
//最坏适应算法
intrearrange_WF（）{
//使用头插法，thead为临时头,p为最大内存的数据块的前一个结点
//当前的最大内存
intmax_size=free_block->
size>
max_size）{
max_size=temp->
max_size=thead->
return1;
intnew_process（）{
structallocated_block*ab;
intret;
ab=（structallocated_block*）malloc（sizeof（structallocated_block））;
if（!
ab）exit（-5）;
ab->
pid++;
sprintf（ab->
process_name,PROCESS-d,pid）;
pid=pid;
printf（Memoryfor%s:
ab->
process_name）;
size=size;
汥敳瀠楲瑮?
输入大小有误，请重新输入\n）;
ret=allocate_mem（ab）;
if（（ret==1）&
（allocated_block_head==NULL））{
allocated_block_head=ab;
elseif（ret==1）{
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）{
structfree_block_type*fbt,*pre,*head,*temp,*tt;
structallocated_block*tp;
intrequest_size=ab->
intsum=0;
intmax;
head=（structfree_block_type*）malloc（sizeof（structfree_block_type））;
pre=head;
fbt=free_block;
pre->
next=fbt;
if（ma_algorithm==MA_WF）{
if（NULL==fbt||fbt->
request_size）
else{
while（NULL!
=fbt&
fbt->
request_size）{
pre=fbt;
fbt=fbt->
=free_block->
sum=free_block->
=temp）{
sum+=temp->
if（sum>
=request_size）
if（NULL==temp）
pre=free_block;
max=free_block->
=pre）{
if（max<
pre->
start_addr）{
max=pre->
fbt=pre;
pre=pre->
tp=allocated_block_head;
tt=free_block;
if（pre!
=fbt）{
=tp）{
if（tp->
start_addr>
start_addr）
tp->
start_addr=tp->
start_addr-pre->
tp=tp->
=tt）{
if（tt->
tt->
start_addr=tt->
tt=tt->
while（pre!
=temp->
=fbt）
free（pre）;
free_block=fbt;
size=sum;
next=temp->
if（free_block->
size-request_size<
MIN_SLICE）{
size=free_block->
start_addr=free_block->
free_block=free_block->
start_addr=fbt->
start_addr+request_size;
size-request_size;
//将内存块全部分配
if（fbt->
size=fbt->
if（pre->
next==free_block）{
free_block=fbt->
next=fbt->
free（fbt）;
fbt->
free（head）;
voidkill_process（）{
printf（KillProcess,pid=）;
pid）;
ab=find_process（pid）;
if（ab!
=N
升级会员 