内存管理实验.docx
《内存管理实验.docx》由会员分享，可在线阅读，更多相关《内存管理实验.docx（25页珍藏版）》请在冰豆网上搜索。
内存管理实验
内存管理实验
一．实验目的
1.通过本次实验体会操作系统中内存的分配模式；
2.掌握内存分配的方法；
3.学会进程的建立，当一个进程被终止时内存是如何处理被释放块，并当内存不满足进程申请时是如何使用内存紧凑；
4.掌握内存回收过程及实现方法；
5.学会进行内存的申请释放和管理；
6.掌握内存分配FF，BF，WF策略及实现的思路；
2.实验内容
1.编写程序实现采用可变分区方法管理内存。
2.在该实验中，采用可变分区方式完成对存储空间的管理。
3.设计用来记录主存使用情况的数据结构：
已分区表和空闲分区表或链表。
4.在设计好的数据结构上设计一个主存分配算法。
5.在设计好的数据结构上设计一个主存回收算法。
其中，若回收的分区有上邻空闲分区和（或）下邻空闲分区，要求合并为一个空闲分区登记在空闲分区表的一个表项里。
三．概要设计
1．功能模块图
2．各个模块详细的功能描述
主要数据结构：
structfree_block_type//空闲块
{
intsize;
intstart_addr;
structfree_block_type*next;
};
structallocated_block//已分配的内存块
{
intpid;
intsize;
intstart_addr;
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（）实现。
4．详细设计
1．功能函数的调用关系图
2．
各功能函数流程图
Set_algorithm（）:
New_process（）:
Allocate_mem（）：
Kill_process（）:
五．测试数据及运行结果
显示菜单：
设置内存空间大小：
创建进程：
杀死进程1：
选择内存分配算法菜单：
首次适应法：
6．调试情况设计技巧及体会
1.调试情况：
第一步：
对.c文件进行编译，生成目标文件（.o文件），使用的命令是gcc-ca.c（a是文件名）；
第二步：
编译.o文件生成可执行文件（.exe文件），使用的命令是gcc-oaa.o（a是文件名）；
第三步：
运行.exe文件查看结果，使用的命令是./a（a是文件名）；
2.设计技巧及体会
这次实验让我们充分了解了内存分配的机制和管理内存的几种方法，从而更进一步对计算机操作系统有了更深的认识。
虽然在这次实验的过程中遇到了很多问题，对内存理解的不深刻，不太清楚计算机系统中是如何对内存进行管理的，但是通过这次实验，现在已经清楚地知道了内存的管理机制，对内存理解的更加透彻。
在以后的学习中能够更好的理解操作系统在计算机应用中起到的作用。
七．源代码
#include
#include
#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（）;
intdisplay_mem_usage（）;
structallocated_block*find_process（intpid）;
structfree_block_type
{
intsize;
intstart_addr;
structfree_block_type*next;
};
structallocated_block
{
intpid;
intsize;
intstart_addr;
charprocess_name[PROCESS_NAME_LEN];
structallocated_block*next;
};
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;break;
case'3':
new_process（）;flag=1;break;
case'4':
kill_process（）;flag=1;break;
case'5':
display_mem_usage（）;flag=1;break;
case'0':
do_exit（）;exit（0）;
default:
break;
}
}
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;
fb->start_addr=DEFAULT_MEM_START;
fb->next=NULL;
returnfb;
}
intset_mem_size（）
{
intsize;
if（flag!
=0）
{
printf（"Cannotsetmemorysizeagain\n"）;
return0;
}
printf（"Totalmemorysize="）;
scanf（"%d",&size）;
if（size>0）
{
mem_size=size;
free_block->size=mem_size;
}
flag=1;
return1;
}
voidset_algorithm（）
{
intalgorithm;
printf（"\t1-FirstFit\n"）;
printf（"\t2-BestFit\n"）;
printf（"\t3-WorstFit\n"）;
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（）
{
structfree_block_type*tmp,*work;
printf（"RearrangefreeblocksforFF\n"）;
tmp=free_block;
while（tmp!
=NULL）
{
work=tmp->next;
while（work!
=NULL）
{
if（work->start_addrstart_addr）
{
swap（&work->start_addr,&tmp->start_addr）;
swap（&work->size,&tmp->size）;
}
else
work=work->next;
}
tmp=tmp->next;
}
}
voidrearrange_BF（）
{
structfree_block_type*tmp,*work;
printf（"RearrangefreeblocksforBF\n"）;
tmp=free_block;
printf（"%d,%d\n",tmp->start_addr,tmp->size）;
while（tmp!
=NULL）
{
work=tmp->next;
while（work!
=NULL）
{
if（work->sizesize）
{
swap（&work->start_addr,&tmp->start_addr）;
swap（&work->size,&tmp->size）;
printf（"start_addr:
%d,size:
%d\n",work->start_addr,work->size）;
}
else
work=work->next;
}
tmp=tmp->next;
}
}
voidrearrange_WF（）
{
structfree_block_type*tmp,*work;
printf（"RearrangefreeblocksforFF\n"）;
tmp=free_block;
printf（"%d,%d\n",tmp->start_addr,tmp->size）;
while（tmp!
=NULL）
{
work=tmp->next;
while（work!
=NULL）
{
if（work->size>tmp->size）
{
swap（&work->start_addr,&tmp->start_addr）;
swap（&work->size,&tmp->size）;
printf（"start_addr:
%d,size:
%d\n",work->start_addr,work->size）;
}
else
work=work->next;
}
tmp=tmp->next;
}
}
voidswap（int*a,int*b）
{
inttemp;
temp=*a;
*a=*b;
*b=temp;
}
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）;
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（"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!
=NULL）
{
if（fbt->size>=request_size）
{
if（fbt->size-request_size>MIN_SLICE）
{
fbt->size=fbt->size-request_size;
//ab->size=request_size;
ab->start_addr=fbt->start_addr;
fbt->start_addr=fbt->start_addr+request_size;
printf（"%d,%d\n",ab->start_addr,ab->size）;
return1;
}
else
{
//pre->next=fbt->next;
ab->size=fbt->size;
ab->start_addr=fbt->start_addr;
if（fbt==free_block）
{
free_block=fbt->next;
free（fbt）;
}
else
{
pre->next=fbt->next;
free（fbt）;
}
printf（"%d,%d\n",ab->start_addr,ab->size）;
return1;
}
}
else
{
pre=fbt;
fbt=fbt->next;
}
}
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）;
}
}
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）
return-1;
fbt->size=ab->size;
fbt->start_addr=ab->start_addr;
fbt->next=free_block;
free_block=fbt;
rearrange（MA_FF）;
fbt=free_block;
while（fbt!
=NULL）
{
work=fbt->next;
if（work!
=NULL）
{
if（fbt->start_addr+fbt->size==work->start_addr）
{
fbt->size=fbt->size+work->size;
fbt->next=work->next;
free（work）;
continue;
}
}
fbt=fbt->next;
}
//rearrange（algorithm）;
return1;
}
intdispose（structallocated_block*free_ab）
{
structallocated_block*pre,*ab;
if（free_ab==allocated_block_head）
{
allocated_block_head=allocated_block_head->next;
free（free_ab）;
return1;
}
pre=allocated_block_head;
ab=allocated_block_head->next;
while（ab!
=free_ab）
{
pre=ab;
ab=ab->next;
}
pre->next=ab->next;
free（ab）;
return2;
}
intdisplay_mem_usage（）
{
structfree_block_type*fbt=free_block;
structallocated_block*ab=allocated_block_head;
if（fbt==NULL）
return-1;
printf（"-----------------------------\n"）;
printf（"FreeMemory:
\n"）;
printf（"%20s%20s\n","start_addr","size"）;
while（fbt!
=NULL）
{
printf（"%20d%20d\n",fbt->start_addr,fbt->size）;
fbt=fbt->next;
}
printf（"\nUsedMemory:
\n"）;
printf（"%10s%20s%10s%10s\n","PID","ProcessName","start_addr","size"）;
while（ab!
=NULL）
{
printf（"%10d%20s%10d%10d\n",ab->pid,ab->process_name,ab->start_addr,ab->size）;
ab=ab->next;
}
printf（"---------------------------------\n"）;
return0;
}
voiddo_exit（）
{
exit（0）;
}
structallocated_block*find_process（intpid）
{
structallocated_block*ab;
ab=allocated_block_head;
while（ab!
=NULL）
{
if（ab->pid==pid）
returnab;
else
ab=ab->next;
}
}
voiddisplay_menu（void）
{
printf（"\n"）;
printf（"1-Setmemorysize（default=%d）\n",DEFAULT_MEM_SIZE）;
printf（"2-Selectmemoryallocationalgorithm\n"）;
printf（"3-Newprocess\n"）;
printf（"4-Terminateaprocess\n"）;
printf（"5-Displaymemoryusage\n"）;
printf（"0-Exit\n"）;
}
升级会员 