内存管理实验文档格式.docx
《内存管理实验文档格式.docx》由会员分享，可在线阅读，更多相关《内存管理实验文档格式.docx（18页珍藏版）》请在冰点文库上搜索。
charprocess_name[PROCESS_NAME_LEN];
structallocated_block*next;
（1）Setmemorysize（default=1024）:
这个模块是用来设置内存大小的，从键盘获取一个数字，并将它赋值给内存大小；
若没有设置，则默认内存的大小为1024。
（2）Set_algorithm：
这个模块是用来设置分配算法的，共有三种算法：
首次循环适配算法、最好适配算法、最差适配算法。
从键盘输入一种算法前的序号，根据算法点用不同的函数对内存进行分配；
（3）New_process:
此模块是用来创建进程的。
从键盘输入进程号，调用fork（）创建进程并为其分配一定大小的内存，若分配成功，则将其连接到已分配链表中，否则分配失败；
（4）Kill_process:
此模块是用来杀死进程的。
从键盘输入一个进程号，先调用find_process（）函数进行查找，若找到，则调用kill（）函数将其杀死并释放内存空间；
（5）Display_mem_usage:
此模块是用来显示内存的使用情况的。
将每个进程的内存使用情况显示出来，包括起始地址和内存大小；
（6）Do_exit:
这个模块是用来结束程序的，直接调用exit（）实现。
四．详细设计
1.功能函数的调用关系图
Set_mem_size（）
Rearrange_FF（）
Set_algorithm（）
Rearrange_BF（）
Rearrange_WF（）
New_process（）
Allocate_mem（）
Kill_process（）
Free_mem（）
Display_mem_usage（）
Do_exit（）
exit（）
2.各功能函数流程图
Set_algorithm（）:
开始
显示算法选择菜单
从键盘输入算法序号
Switch（）
MA_FF MA_BF MA_WF
Rearrange_F Rearrange_B Rearrange_WF
从键盘获得一个进程号和为进程的分配的
内存大小
Size>
0？
是
Allocate_mem（）为进程分配内存
判断是否分配成功
否
将此进程连接到已分配内存链表中
结束
New_process（）:
Fbt->
size>
=request_size
size-request_size>
M
IN_SLICE
将内存块分割后分配给进程
将内存块整体分配给进程
Allocate_mem（）：
Kill_process（）:
输入一个进程号
Find_process（）查找该进程
是否找到？
否
Free_mem（）释放内存
五．测试数据及运行结果
显示菜单：
设置内存空间大小：
创建进程：
杀死进程1：
选择内存分配算法菜单：
首次适应法：
六．调试情况设计技巧及体会
1.调试情况：
第一步：
对.c文件进行编译，生成目标文件（.o文件），使用的命令是gcc-ca.c（a
是文件名）；
第二步：
编译.o文件生成可执行文件（.exe文件），使用的命令是gcc-oaa.o（a
第三步：
运行.exe文件查看结果，使用的命令是./a（a是文件名）；
2.设计技巧及体会
这次实验让我们充分了解了内存分配的机制和管理内存的几种方法，从而更进一步对计算机操作系统有了更深的认识。
虽然在这次实验的过程中遇到了很多问题，对内存理解的不深刻，不太清楚计算机系统中是如何对内存进行管理的，但是通过这次实验，现在已经清楚地知道了内存的管理机制，对内存理解的更加透彻。
在以后的学习中能够更好的理解操作系统在计算机应用中起到的作用。
七．源代码
#include<
stdio.h>
#include<
stdlib.h>
#definePROCESS_NAME_LEN32#defineMIN_SLICE10
#defineDEFAULT_MEM_SIZE1024
#defineDEFAULT_MEM_START0
#defineMA_FF1#defineMA_BF2#defineMA_WF3
intmem_size=DEFAULT_MEM_SIZE;
intma_algorithm=MA_FF;
staticintpid=0;
intflag=0;
voiddisplay_menu（void）;
structfree_block_type*init_free_block（intmem_size）;
intset_mem_size（）;
voidset_algorithm（）;
voidrearrange（intalgorithm）;
voidrearrange_FF（）;
voidrearrange_BF（）;
voidrearrange_WF（）;
voidswap（int*a,int*b）;
intnew_process（）;
intdisplay_mem_usage（）;
voiddo_exit（）;
voidkill_process（）;
structallocated_block*find_process（intpid）;
structfree_block_type
intsize;
structallocated_block
structfree_block_type*free_block;
structallocated_block*allocated_block_head=NULL;
intmain（void）
charchoice;
pid=0;
free_block=init_free_block（mem_size）;
for（;
;
）
display_menu（）;
// fflush（stdin）;
choice=getchar（）;
// getchar（）;
switch（choice）
case'
1'
:
set_mem_size（）;
break;
case'
2'
set_algorithm（）;
flag=1;
case'
3'
new_process（）;
4'
kill_process（）;
5'
display_mem_usage（）;
0'
do_exit（）;
exit（0）;
default:
}
return0;
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;
intset_mem_size（）
if（flag!
=0）
Cannotsetmemorysizeagain\n"
return0;
Totalmemorysize="
scanf（"
%d"
&
size）;
if（size>
0）
mem_size=size;
free_block->
return1;
voidset_algorithm（）
intalgorithm;
\t1-FirstFit\n"
printf（"
\t2-BestFit\n"
\t3-WorstFit\n"
algorithm）;
if（algorithm>
=1&
&
algorithm<
=3）
ma_algorithm=algorithm;
rearrange（ma_algorithm）;
voidrearrange（intalgorithm）
switch（algorithm）
caseMA_FF:
rearrange_FF（）;
caseMA_BF:
rearrange_BF（）;
caseMA_WF:
rearrange_WF（）;
voidrearrange_FF（）
structfree_block_type*tmp,*work;
RearrangefreeblocksforFF\n"
tmp=free_block;
while（tmp!
=NULL）
work=tmp->
next;
while（work!
if（work->
start_addr<
tmp->
start_addr）
swap（&
work->
start_addr,&
start_addr）;
swap（&
size,&
else
work=work->
tmp=tmp->
voidrearrange_BF（）
printf（"
RearrangefreeblocksforBF\n"
tmp=free_block;
%d,%d\n"
tmp->
start_addr,tmp->
while（tmp!
{
work=tmp->
while（work!
{
if（work->
size<
size）
{
swap（&
printf（"
start_addr:
%d,size:
%d\n"
work->
start_addr,work->
}
else
work=work->
}
tmp=tmp->
}
voidrearrange_WF（）
voidswap（int*a,int*b）
inttemp;
temp=*a;
*a=*b;
*b=temp;
intnew_process（）
structallocated_block*ab;
intret;
ab=（structallocated_block*）malloc（sizeof（structallocated_block））;
if（!
ab）
exit（-5）;
ab->
pid++;
sprintf（ab->
process_name,"
PROCESS-%02d"
pid）;
pid=pid;
Memoryfor%s:
"
ab->
process_name）;
size=size;
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）"
free（ab）;
return-1;
return-3;
intallocate_mem（structallocated_block*ab）
structfree_block_type*fbt,*pre;
intrequest_size=ab->
size;
fbt=pre=free_block;
while（fbt!
if（fbt->
=request_size）
MIN_SLICE）
fbt->
size=fbt->
size-request_size;
//ab->
size=request_size;
start_addr=fbt->
start_addr;
start_addr+request_size;
%d,%d\n"
start_addr,ab->
//pre->
next=fbt->
ab->
if（fbt==free_block）
free_block=fbt->
free（fbt）;
pre->
}
pre=fbt;
fbt=fbt->
voidkill_process（）
intpid;
KillProcess,pid="
pid）;
ab=find_process（pid）;
if（ab!
free_mem（ab）;
dispose（ab）;
intfree_mem（structallocated_block*ab）
intalgorithm=ma_algorithm;
structfree_block_type*fbt,*pre,*work;
fbt=（structfree_block_type*）malloc（sizeof（structfree_block_type））;
if（!
fbt）
size=ab->
start_addr=ab->
fbt->
next=free_block;
free_block=fbt;
rearrange（MA_FF）;
fbt=free_block;
work=fbt->
if（work!
start_addr+fbt->
size==work->
size+work->
next=work->
free（work）;
continue;
//rearrange（algorithm）;
intdispose（structallocated_block*free_ab）
structallocated_block*pre,*ab;
if（free_ab==allocated_block_head）
allocated_block_head=allocated_block_head->
free（free_ab）;
return1;
pre=allocated_block_head;
ab=allocated_block_head->
while（ab!
=free_ab）
pre=ab;
ab=ab->
next=ab->
return2;
intdisplay_mem_usage（）
structfree_block_type*fbt=free_block;
structallocated_block*ab=allocated_block_head;
if（fbt==NULL）
\n"
FreeMemory:
\n"
%20s%20s\n"
"
start_addr"
size"
%20d%20d\n"
fbt->
start_addr,fbt->
fbt=fbt->
\nUsedMemory:
%10s%20s
升级会员 