实验四 动态分区分配算法Word下载.docx

实验四 动态分区分配算法Word下载.docx

《实验四 动态分区分配算法Word下载.docx》由会员分享，可在线阅读，更多相关《实验四 动态分区分配算法Word下载.docx（19页珍藏版）》请在冰豆网上搜索。

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;

next=NULL;

returnfb;

voiddisplay_menu（）{

\n"

1-Setmemorysize（default=%d）\n"

DEFAULT_MEM_SIZE）;

2-Selectmemoryallocationalgorithm\n"

3-Newprocess\n"

4-Terminateaprocess\n"

5-Displaymemoryusage\n"

0-Exit\n"

intset_mem_size（）{

if（flag!

=0）{//防止重复设置

Cannotsetmemorysizeagain\n"

return0;

Totalmemorysize="

scanf（"

%d"

&

size）;

if（size>

0）{

mem_size=size;

free_block->

voidset_algorithm（）{

intalgorithm;

printf（"

\t1-FirstFit\n"

\t2-BestFit\n"

\t3-WorstFit\n"

scanf（"

algorithm）;

if（algorithm>

=1&

&

algorithm<

=3）{

ma_algorithm=algorithm;

break;

}

else

printf（"

输入有误，请重新输入！

//按指定算法重新排列空闲区链表

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->

while（temp->

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->

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;

Memoryfor%s:

"

ab->

process_name）;

if（size>

ab->

size=size;

break;

elseprintf（"

输入大小有误，请重新输入\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）{

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）

return-1;

else{

while（NULL!

=fbt&

fbt->

request_size）{

pre=fbt;

fbt=fbt->

if（NULL==fbt||fbt->

=free_block->

sum=free_block->

temp=free_block->

while（NULL!

=temp）{

sum+=temp->

if（sum>

=request_size）

break;

temp=temp->

if（NULL==temp）

return-1;

else{

pre=free_block;

max=free_block->

fbt=free_block;

while（temp->

=pre）{

if（max<

pre->

start_addr）{

max=pre->

fbt=pre;

}

pre=pre->

}

=pre）{

tp=allocated_block_head;

tt=free_block;

if（pre!

=fbt）{

while（NULL!

=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;

free_block->

size=sum;

next=temp->

if（free_block->

size-request_size<

MIN_SLICE）{

ab->

size=free_block->

start_addr=free_block->

pre=free_block;

free_block=free_block->

free（pre）;

else{

start_addr=fbt->

free_block->

start_addr+request_size;

size-request_size;

}

}

//将内存块全部分配

if（fbt->

size=fbt->

if（pre->

next==free_block）{

free_block=fbt->

else

pre->

next=fbt->

free（fbt）;

fbt->

free（head）;

voidkill_process（）{

KillProcess,pid="

pid）;

ab=find_process（pid）;

if（ab!

=NULL）{

free_mem（ab）;

dispose（ab）;

没有pid为%d的进程！

pid）;

structallocated_block*find_process（intpid）{

structallocated_blo