Linux实验 ：动态分区分配模拟

实验概述

了解动态分区分配方式中的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。
用C语言实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和free()。其中空闲分区通过空闲分区链来管理，在进行内存分配时，系统有限使用空闲区低端的空间。
假设初始状态可用内存空间为640KB，有如下请求序列：

JOB1 请求 130KB
JOB2 请求 60KB
JOB3 请求 100KB
JOB2 释放 60KB
JOB4 请求 200KB
JOB3 释放 100KB
JOB1 释放 130KB
JOB5 请求 140KB
JOB6 请求 60KB
JOB7 请求 50KB
JOB6释放 60KB

要求输出每次分配和回收后，空闲内存分区链的状态情况。

实验内容

首先分析俩种算法的思想和优缺点以及算法实现的思路。

首次适应算法

算法思想： 将空闲分区链以地址递增的顺序连接；在进行内存分配时，从链首开始顺序查找，直到找到一块分区的大小可以满足需求时，按照该作业的大小，从该分区中分配出内存，将剩下的空闲分区仍然链在空闲分区链中。

优点： 高址部分的大的空闲分区得到保留，为大作业的内存分配创造了条件；

缺点：（1）每次都是优先利用低址部分的空闲分区，造成低址部分产生大量的外碎片。（2）每次都是从低址部分查找，使得查找空闲分区的开销增大；
我们以空闲分区链为例来说明采用FF算法时的分配情况。FF算法要求空闲分区链以地址递增的次序链接。

算法实现：
首次适应算法比较简单，在分配内存时，从链首开始顺序查找，直至找到一个大小能满足要求的空闲分区为止。然后再按照作业的大小，从该分区中划出一块内存空间分配给请求者，余下的空闲分区仍留在空闲链中。如果从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。

	for (int i = 1; i < M_queue.size(); i++)  
	{  
	 if ((M_queue[i].flag == 0) && p1.size < M_queue[i].size)  
	 {  
	  temp.flag = 1;  
	  temp.id = p1.id;  
	  temp.size = p1.size;  
	  temp.front_number = M_queue[i].front_number;  
	  temp.number = temp.front_number + temp.size;  
	  M_queue[i].front_number = temp.number;  
	  M_queue[i].size -= temp.size;  
	  M_queue.insert(M_queue.begin() + i, temp);//insert为在指定位置插入元素  
	  break;  
	 }  
	}  

最佳适应算法

算法思想： 将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序，从而形成空闲分区链。每次从链首进行查找合适的空闲分区为作业分配内存，这样每次找到的空闲分区是和作业大小最接近的，所谓“最佳”。

优点： 第一次找到的空闲分区是大小最接近待分配内存作业大小的；

缺点: 产生大量难以利用的外部碎片。

算法实现：
首先将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序，从而形成空闲分区链。每次从链首进行查找合适的空闲分区为作业分配内存，余下的空闲分区仍留在空闲链中。如果从链首直至链尾都不能找到一个能满足要求的分区，则此次内存分配失败，返回。

	int best_num = MAX;//记录目标空闲区大小  
	  int best_i;//记录目标空闲区编号  
	  for (int i = 1; i < M_queue.size(); i++)//找到只比p1.size大一点的空闲区，即目标空闲区  
	  {  
	   if ((M_queue[i].flag == 0) && (M_queue[i].size >= p1.size) && (M_queue[i].size <= best_num))  
	   {  
	    best_num = M_queue[i].size;  
	    best_i = i;  
	   }  
	  }  
	  temp.flag = 1;  
	  temp.id = p1.id;  
	  temp.size = p1.size;  
	  temp.front_number = M_queue[best_i].front_number;  
	  temp.number = temp.front_number + temp.size;  
	  M_queue[best_i].front_number = temp.number;  
	  M_queue[best_i].size -= p1.size;  
	  M_queue.insert(M_queue.begin() + best_i, temp);  
	 }

根据算法实现的思路可以画出这俩种算法的算法流程图如下：

重要数据结构：
内存：

	struct memory  
	{  
	 int front_number;  //前一个的序列号  
	 int number;  //序号  
	 int id;  //占用程序的id 0为未占用  
	 bool flag;//0为未被占用，可被回收  
	 int size; //大小  
	}; 

作业：

	struct work  
	{  
	 int id;  
	 int size;  
	};  

代码最终运行结果截图：
首次适应算法：

最佳适应算法：