操作系统实验内存分配.docx
《操作系统实验内存分配.docx》由会员分享，可在线阅读，更多相关《操作系统实验内存分配.docx（28页珍藏版）》请在冰豆网上搜索。
操作系统实验内存分配
西安邮电大学
（计算机学院）
课内实验报告
实验名称：
内存管理
专业名称：
软件工程
班级：
学生姓名：
学号（8位）：
指导教师：
实验日期：
实验五：
进程
1.实验目的
通过深入理解区管理的三种算法，定义相应的数据结构，编写具体代码。
充分模拟三种算法的实现过程，并通过对比，分析三种算法的优劣。
（1）掌握内存分配FF，BF，WF策略及实现的思路；
（2）掌握内存回收过程及实现思路；
（3）参考给出的代码思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。
2.实验要求：
1）掌握内存分配FF，BF，WF策略及实现的思路；
2）掌握内存回收过程及实现思路；
3）参考本程序思路，实现内存的申请、释放的管理程序，调试运行，总结程序设计中出现的问题并找出原因，写出实验报告。
3.实验过程：
创建进程：
删除其中几个进程：
（默认以ff首次适应算法方式排列）
Bf最佳适应算法排列方式：
wf最差匹配算法排列方式：
4.实验心得：
这次实验实验时间比较长，而且实验指导书中对内存的管理讲的很详细，老师上课的时候也有讲的很详细，但是代码比较长，刚开始的时候也是不太懂，但是后面经过和同学一起商讨，明白几种算法的含义：
首次适应算法。
在采用空闲分区链作为数据结构时，该算法要求空闲分区链表以地址递增的次序链接。
在进行内存分配时，从链首开始顺序查找，直至找到一个能满足进程大小要求的空闲分区为止。
然后，再按照进程请求内存的大小，从该分区中划出一块内存空间分配给请求进程，余下的空闲分区仍留在空闲链中。
循环首次适应算法。
该算法是由首次适应算法演变而形成的，在为进程分配内存空间时，从上次找到的空闲分区的下一个空闲分区开始查找，直至找到第一个能满足要求的空闲分区，并从中划出一块与请求的大小相等的内存空间分配给进程。
最佳适应算法将空闲分区链表按分区大小由小到大排序，在链表中查找第一个满足要求的分区。
最差匹配算法将空闲分区链表按分区大小由大到小排序，在链表中找到第一个满足要求的空闲分区。
实验中没有用到循环首次适应算法，但是对其他三种的描述还是很详细，总的来说，从实验中还是学到了很多。
5.程序源代码：
#include
#include
#include
#include
#definePROCESS_NAME_LEN32//进程名长度
#defineMIN_SLICE10//最小碎片的大小
#defineDEFAULT_MEM_SIZE1024//内存大小
#defineDEFAULT_MEM_START0//起始位置
/*内存分配算法*/
#defineMA_FF1
#defineMA_BF2
#defineMA_WF3
/*描述每一个空闲块的数据结构*/
structfree_block_type
{
intsize;//空闲块大小
intstart_addr;//空闲块起始地址
structfree_block_type*next;//指向下一个空闲块
};
/*指向内存中空闲块链表的首指针*/
structfree_block_type*free_block=NULL;
/*每个进程分配到的内存块的描述*/
structallocated_block
{
intpid;//进程标识符
intsize;//进程大小
intstart_addr;//进程分配到的内存块的起始地址
charprocess_name[PROCESS_NAME_LEN];//进程名
structallocated_block*next;//指向下一个进程控制块
};
/*进程分配内存块链表的首指针*/
structallocated_block*allocated_block_head=NULL;
intfree_block_count=0;//空闲块个数
intmem_size=DEFAULT_MEM_SIZE;//内存大小
intcurrent_free_mem_size=0;//当前空闲内存大小
intma_algorithm=MA_FF;//当前分配算法
staticintpid=0;//初始PID
intflag=0;//设置内存大小标志,表示内存大小是否设置
/*函数声明*/
structfree_block_type*init_free_block（intmem_size）;
voiddisplay_menu（）;
intset_mem_size（）;
voidset_algorithm（）;
voidrearrange（intalgorithm）;
intrearrange_WF（）;
intrearrange_BF（）;
intrearrange_FF（）;
intnew_process（）;
intallocate_mem（structallocated_block*ab）;
voidkill_process（）;
intfree_mem（structallocated_block*ab）;
intdispose（structallocated_block*free_ab）;
intdisplay_mem_usage（）;
structallocated_block*find_process（intpid）;
intdo_exit（）;
intallocate_FF（structallocated_block*ab）;
intallocate_BF（structallocated_block*ab）;
intallocate_WF（structallocated_block*ab）;
intallocate（structfree_block_type*pre,structfree_block_type*allocate_free_nlock,structallocated_block*ab）;
intmem_retrench（structallocated_block*ab）;
//通过内存紧缩技术给新进程分配内存空间
intmem_retrench（structallocated_block*ab）
{
structallocated_block*allocated_work,*allocated_pre=allocated_block_head;
structfree_block_type*free_work,*free_pre=free_block->next;
if（allocated_pre==NULL）
return-1;
allocated_pre->start_addr=0;
allocated_work=allocated_pre->next;
while（allocated_work!
=NULL）
{
allocated_work->start_addr=allocated_pre->start_addr+allocated_pre->size;
allocated_pre=allocated_work;
allocated_work=allocated_work->next;
}
free_block->start_addr=allocated_pre->start_addr+allocated_pre->size;
free_block->size=current_free_mem_size;
free_block->next=NULL;
free_work=free_pre;
while（free_pre!
=NULL）
{
free（free_pre）;
free_pre=free_work;
if（free_pre!
=NULL）
free_work=free_work->next;
}
allocate（NULL,free_block,ab）;
return1;
}
//给新进程分配内存空间
intallocate（structfree_block_type*pre,structfree_block_type*allocate_free_block,structallocated_block*ab）
{
structallocated_block*p=allocated_block_head;
ab->start_addr=allocate_free_block->start_addr;
if（allocate_free_block->size-ab->size{
ab->size=allocate_free_block->size;
if（pre!
=NULL）
{
pre->next=allocate_free_block;
}
else
{
free_block=allocate_free_block->next;
}
free（allocate_free_block）;
}
else
{
allocate_free_block->start_addr+=ab->size;
allocate_free_block->size-=ab->size;
}
if（p==NULL）
{
allocated_block_head=ab;
}
else
{
while（p->next!
=NULL）
p=p->next;
p->next=ab;
}
current_free_mem_size-=ab->size;
if（current_free_mem_size==0）
free_block=NULL;
return0;
}
//按照最坏适应算法给新进程分配内存空间
intallocate_WF（structallocated_block*ab）
{
intret;
structfree_block_type*wf=free_block;
if（wf==NULL）
return-1;
if（wf->size>=ab->size）
allocate（NULL,wf,ab）;
elseif（current_free_mem_size>=ab->size）
ret=mem_retrench（ab）;
else
ret=-2;
rearrange_WF（）;
returnret;
}
//按照最佳适应算法给新进程分配内存空间
i
升级会员 