实时系统动态内存算法分析dsa（一）

最近开发过程使用了ucos系统，为了提高系统性能，需要自己移植内存管理算法，看了一些关于实时系统动态内存算法的东西，整理了出来，希望也给同样需求的人提供方便；我们在开发时很少去关注内存是如何分配的，尤其对于PC端的开发人员来说完全不会涉及到，因为PC的资源往往是充裕的，但对于嵌入式开发来说，很多时候物理内存会成为开发时的瓶颈，如何最大程度的利用现有内存资源，这就是我们下面要讨论的；

下面从以下几点来由浅入深的探讨：

一、介绍比较常见的几种内存分配算法（DSA，Dynamic storage allocation）；

        二、通过实例来看一个最简单的内存分配算法；

        三、对于TLSF算法代码进行分析；

        四、分析linux中的buddy伙伴系统代码；

参考文章：

 TLSF: a New Dynamic Memory Allocator for Real-Time Systems

A constant-time dynamic storage allocator for real-timesystems      

一、内存分配算法介绍

1、背景：

DSA（Dynamic storage allocation）编程开发中有着重要意义，特别是面向对象编程当中，但是我们往往打怵用DSA，

因为一旦使用不当，DSA的响应时间与碎片会让我们的系统健壮性和鲁棒性变得非常脆弱，衡量内存算法最重要的两个标

准就是其响应时间与碎片化程度；

2、分类：

DSA的目的是让应用程序方便的从内存池里获取未使用的内存，不同的算法主要区别在于如何高效的获取需要的内存

大小，我们先看几个经典算法；这里我做了概括说明，对于其具体的优缺点可以阅读TLSF: a New Dynamic Memory 

Allocator for Real-Time Systems这篇论文，里面有更详细的说明；

二、实例-简单sda实现：

理论性的东西网上很多，这里我就不去赘述了，下面我们看一个sda的实例，非常简单，类似上面提到的Segregated Free Lists算法，这种算法是根据自身系统将一个大的内存池分割为不同大小的小内存池，申请内存时去匹配最合适的内存池申请内存；大内存块在分配内存时出现比自己块小的内存块时将其移到更小内存块，当小内存块被释放，可以合并为大内存块时，需要合并，如下图所示：

这里为了说明问题只添加了4个小的内存池，上面每个pool的大小都是经验估值，每个pool的大小和数量需要根据你自己系统（应用）去修改，用的频率高的pool数量要多些；用三个函数就可以说明这种算法的实现，初始化，malloc和free；

1、内存池初始化：

我用ucos系统来做测试，第一步肯定是跟系统要一块足够的内存区域，ucos没有MMU，所以这块内存区域不可能大于物理内存，我这里跟系统要10k bytes。

#define BLOCK_NUM0                      300
#define BLOCK_NUM1			150
#define BLOCK_NUM2			80
#define BLOCK_NUM3			40

#define BLOCK_SIZE0			32
#define BLOCK_SIZE1                     64
#define BLOCK_SIZE2			128
#define BLOCK_SIZE3			256

//这个数组大小不能小于我们申请的几个分区总和，也不能超过系统RAM
static UINT32 MEM_Pool[10*1024];


//因为我们需要四个分区，用这个变量来保存每个分区信息
int OS_MEM *p_mem_info[4];

int MEM_Init(void)
{
	INT8U err = 0;       
		OS_MEM *p_mem;
		UINT8 *p_mem_pool = (UINT8 *)&MEM_Pool[0];

	//ucos内存初始化
	OS_MemInit();

	//part0
	p_mem = OSMemCreate(p_mem_pool, BLOCK_NUM0, BLOCK_SIZE0, &err);
	if (err == OS_ERR_NONE) {
		p_mem_info[0] = p_mem;

	} else {
		printf("[ERROR]%s:\r\n", FUNCTION_NAME, err);
		return err;
	}
	p_mem_pool += (BLOCK_NUM0 * BLOCK_SIZE0);

	//part1
	p_mem = OSMemCreate(p_mem_pool, BLOCK_NUM1, BLOCK_SIZE1, &err);
	if (err == OS_ERR_NONE) {
		p_mem_info[1] = p_mem;
	} else {
		printf("[ERROR]%s:\r\n", FUNCTION_NAME, err);
		return err;
	}
	p_mem_pool += (BLOCK_NUM1 * BLOCK_SIZE1);

	//part2
	p_mem = OSMemCreate(p_mem_pool, BLOCK_NUM2, BLOCK_SIZE2, &err);
	if (err == OS_ERR_NONE) {
		p_mem_info[2] = p_mem;

	} else {
		printf("[ERROR]%s:\r\n", FUNCTION_NAME, err);
		return err;
	}
	p_mem_pool += (BLOCK_NUM2 * BLOCK_SIZE2);


	p_mem = OSMemCreate(p_mem_pool, BLOCK_NUM3, BLOCK_SIZE3, &err);
	if (err == OS_ERR_NONE) {
		p_mem_info[3] = p_mem;
	} else {
		return err;
	}
	p_mem_pool += (BLOCK_NUM3 * BLOCK_SIZE3);

	return err;
}

要理解这块代码，首先简单看一下ucos系统提供的内存相关的函数：

我们回过头看MEM_Init函数，25行的OS_MemInit()是ucos使用内存的初始化操作，我们来看27-36行，part0部分是对32字节分区初始化，调用OSMemCreate()函数时需要给出申请起始地址，分区大小和数量，我们在开始定义了一个全局的静态变量，用来获取可用地址范围，这里的OSMemCreate()函数返回分区信息；part1，part2，part3部分雷同；

2、内存申请：

上面的初始化不难理解，下面看下我们需要使用内存时如何申请：

void * malloc(UINT32 size)
{
	
	OS_MEM *p_info;
	INT8U err;
	void *p_addr;

	p_info = FindPartitionBySize(Size);
	if (p_info == NULL) {
		printf("No match memory partition found!");
		return NULL;
	}
	
	//Ucos api，内存分配函数，执行此函数后ucos内存地址应用层才可以使用
	p_addr = OSMemGet(p_info->p_mem, &err);
	if (err != OS_ERR_NONE || p_addr == NULL) {
		return NULL;
	}


	return p_addr;
}

这段代码的关键点是FindPartitionBySize函数，定义如下：

OS_MEM *FindPartitionBySize(int size)
{
	UINT8 mid = (4 - 1) / 2, i;
	
	//还记得上个表中对ucos系统变量OS_MEM的说明？当我们调用OSMemCreate函数返回OS_MEM时，分区中的块大小已经固定了
	if (size > (*p_mem_info[mid]).p_mem->OSMemBlkSize) {
		for (i = mid + 1; i < 4; i++) {
			if (size<= (*p_mem_info[i]).p_mem->OSMemBlkSize)
				return p_mem_info[i];
		}		
	} else {
		for (i = 0; i < mid + 1; i++) {
			if (size <= (*p_mem_info[i]).p_mem->OSMemBlkSize)
				return p_mem_info[i];
		}
	}

	return NULL;	
}

这段代码比较简单，使用最简单的二分查找法，先找到中间分区的大小，如果需要的分区大小比中间分区大，则遍历更大分区，反之遍历更小分区；但要注意，FindPartitionBySize返回的只是分区首地址，最后还是通过ucos的OSMemGet()函数来获取分区中实际使用的内存地址；

OS_MEM *FindPartitionBySize(int size)
{
	UINT8 mid = (4 - 1) / 2, i;
	
	//还记得上个表中对ucos系统变量OS_MEM的说明？当我们调用OSMemCreate函数返回OS_MEM时，分区中的块大小已经固定了
	if (size > (*p_mem_info[mid]).p_mem->OSMemBlkSize) {
		for (i = mid + 1; i < 4; i++) {
			if (size<= (*p_mem_info[i]).p_mem->OSMemBlkSize)
				return p_mem_info[i];
		}		
	} else {
		for (i = 0; i < mid + 1; i++) {
			if (size <= (*p_mem_info[i]).p_mem->OSMemBlkSize)
				return p_mem_info[i];
		}
	}


	return NULL;	
}

3、内存释放：

void Free(void *p_Addr)
{
	
	OS_MEM *p_info;
	INT8U err;
	UINT8 *p = (UINT8 *)p_Addr;

	if (p == NULL) {
		return;
	}

	p_info = FindPartitionByAddr((void *)p);
	if (p_info == NULL) {
		printf("No match memory partition found! Address");
		return;
	}


	err = OSMemPut(p_info->p_mem, (void *)p);
	if (err != OS_ERR_NONE) {
		printf("Put memory block error!");
		return;
	}


	return;
}

看下FindPartitionByAddr()函数的定义：

OS_MEM *FindPartitionByAddr(void *p_Addr)
{
	UINT8 i;
	UINT32 addr = (UINT32)p_Addr;

	for (i = 0; i < 4; i++) {
		UINT32 start = (UINT32)p_mem_info[i].p_mem->OSMemAddr;
		UINT32 size = (*p_mem_info[i]).p_mem->OSMemBlkSize * (*p_mem_info[i]).p_mem->OSMemNBlks;
		if (addr >= start &&  addr < (start + size))
			return p_mem_info[i];
	}
	
	return NULL;
}

使用ucos api OSMemPut()来释放内存时，需要知道分区和所需释放内存地址；

好了，分析到这里，我们已经完成了一个简单的sda算法，但这种算法虽然时间度不是很复杂，但容易产生碎片，这种方法对于低功耗、低处理能力的MCU还是很不错的，随着现在硬件水平的提高，这种算法可能无法满足要求，下面更深入一步，继续看看比较复杂的TLSF实现；