FreeRTOS提供了5中内存分配的方式，分别在heap_1.c, heap_2.c, heap_3.c, heap_4.c, heap_5.c中。

对于传统的库函数malloc和free，有以下的缺陷：

• 线程不安全
• 耗时
• 有些嵌入式硬件没有实现

所以FreeRTOS提供了5中内存分配的方式，用户当然也可以自己实现。

下面分别来解析以下这5个heap文件
5个heap的位置在Source/portable/MemMang/

heap_1.c

• 从一个静态数组力分配
• 只分配内存，不释放

适用于不会删除任务 、队列、信号量、互斥量的应用程序

注释

The simplest possible implementation of pvPortMalloc().  Note that this implementation does NOT allow allocated memory to be freed again.

表示只分配，不释放

内存分配函数

void *pvPortMalloc( size_t xWantedSize )
{
void *pvReturn = NULL;
static uint8_t *pucAlignedHeap = NULL;/* Ensure that blocks are always aligned to the required number of bytes. */#if( portBYTE_ALIGNMENT != 1 ){if( xWantedSize & portBYTE_ALIGNMENT_MASK ){/* Byte alignment required. */xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );}}#endifvTaskSuspendAll();{if( pucAlignedHeap == NULL ){/* Ensure the heap starts on a correctly aligned boundary. */pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );}/* Check there is enough room left for the allocation. */if( ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&( ( xNextFreeByte + xWantedSize ) > xNextFreeByte )    )/* Check for overflow. */{/* Return the next free byte then increment the index past thisblock. */pvReturn = pucAlignedHeap + xNextFreeByte;xNextFreeByte += xWantedSize;}traceMALLOC( pvReturn, xWantedSize );}( void ) xTaskResumeAll();#if( configUSE_MALLOC_FAILED_HOOK == 1 ){if( pvReturn == NULL ){extern void vApplicationMallocFailedHook( void );vApplicationMallocFailedHook();}}#endifreturn pvReturn;
}

解析

首先是内存对齐判断

    #if( portBYTE_ALIGNMENT != 1 ){if( xWantedSize & portBYTE_ALIGNMENT_MASK ){/* Byte alignment required. */xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );}}#endif

这里，如果内存对齐有效，则执行，如果要分配的内存不是对齐字节(通常是8)的整数倍，则补齐，所以xWantedSize要加上要补齐的长度

然后挂起调度器

vTaskSuspendAll();

防止分配内存过程中被打断。

静态数组对齐检查

pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );

这里uheap就是静态数组，首先确保它对齐了，因为uheap的首地址可能不是8的倍数，所以，确保实际开始分配的地址是对齐的
比如基础地址低三位是3，+8之后是11，屏蔽低三位后是8，也就是8的倍数，对齐了，这样开头就有5个字节直接被抛弃了

溢出检测

if( ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) && ( ( xNextFreeByte + xWantedSize ) > xNextFreeByte )    )
/* Check for overflow. */

分配内存

pvReturn = pucAlignedHeap + xNextFreeByte;
xNextFreeByte += xWantedSize;

恢复调度器

( void ) xTaskResumeAll();

分配失败hook函数

    #if( configUSE_MALLOC_FAILED_HOOK == 1 ){if( pvReturn == NULL ){extern void vApplicationMallocFailedHook( void );vApplicationMallocFailedHook();}}#endif

如果开启了分配失败hook函数，就调用该hook

释放

void vPortFree( void *pv )
{/* Memory cannot be freed using this scheme.  See heap_2.c, heap_3.c andheap_4.c for alternative implementations, and the memory management pages ofhttp://www.FreeRTOS.org for more information. */( void ) pv;/* Force an assert as it is invalid to call this function. */configASSERT( pv == NULL );
}

heap_1.c里不释放内存

heap_2.c

/** A sample implementation of pvPortMalloc() and vPortFree() that permits* allocated blocks to be freed, but does not combine adjacent free blocks* into a single larger block (and so will fragment memory).  See heap_4.c for* an equivalent that does combine adjacent blocks into single larger blocks.*/

分配和释放内存，但对内存碎片不做处理，也就是说，不会把内存碎片合并为一个大的碎片

void *pvPortMalloc( size_t xWantedSize )
{
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
static BaseType_t xHeapHasBeenInitialised = pdFALSE;
void *pvReturn = NULL;vTaskSuspendAll();{/* If this is the first call to malloc then the heap will requireinitialisation to setup the list of free blocks. */if( xHeapHasBeenInitialised == pdFALSE ){prvHeapInit();xHeapHasBeenInitialised = pdTRUE;}/* The wanted size is increased so it can contain a BlockLink_tstructure in addition to the requested amount of bytes. */if( xWantedSize > 0 ){xWantedSize += heapSTRUCT_SIZE;/* Ensure that blocks are always aligned to the required number of bytes. */if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0 ){/* Byte alignment required. */xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );}}if( ( xWantedSize > 0 ) && ( xWantedSize < configADJUSTED_HEAP_SIZE ) ){/* Blocks are stored in byte order - traverse the list from the start(smallest) block until one of adequate size is found. */pxPreviousBlock = &xStart;pxBlock = xStart.pxNextFreeBlock;while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) ){pxPreviousBlock = pxBlock;pxBlock = pxBlock->pxNextFreeBlock;}/* If we found the end marker then a block of adequate size was not found. */if( pxBlock != &xEnd ){/* Return the memory space - jumping over the BlockLink_t structureat its start. */pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + heapSTRUCT_SIZE );/* This block is being returned for use so must be taken out of thelist of free blocks. */pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;/* If the block is larger than required it can be split into two. */if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE ){/* This block is to be split into two.  Create a new blockfollowing the number of bytes requested. The void cast isused to prevent byte alignment warnings from the compiler. */pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );/* Calculate the sizes of two blocks split from the singleblock. */pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;pxBlock->xBlockSize = xWantedSize;/* Insert the new block into the list of free blocks. */prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );}xFreeBytesRemaining -= pxBlock->xBlockSize;}}traceMALLOC( pvReturn, xWantedSize );}( void ) xTaskResumeAll();#if( configUSE_MALLOC_FAILED_HOOK == 1 ){if( pvReturn == NULL ){extern void vApplicationMallocFailedHook( void );vApplicationMallocFailedHook();}}#endifreturn pvReturn;
}
/*-----------------------------------------------------------*/void vPortFree( void *pv )
{
uint8_t *puc = ( uint8_t * ) pv;
BlockLink_t *pxLink;if( pv != NULL ){/* The memory being freed will have an BlockLink_t structure immediatelybefore it. */puc -= heapSTRUCT_SIZE;/* This unexpected casting is to keep some compilers from issuingbyte alignment warnings. */pxLink = ( void * ) puc;vTaskSuspendAll();{/* Add this block to the list of free blocks. */prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );xFreeBytesRemaining += pxLink->xBlockSize;traceFREE( pv, pxLink->xBlockSize );}( void ) xTaskResumeAll();}
}
/*-----------------------------------------------------------*/

解析以下，heap_2.c里，不同内存间靠链表维系。
所以有这么一个结构体

typedef struct A_BLOCK_LINK
{struct A_BLOCK_LINK *pxNextFreeBlock;   /*<< The next free block in the list. */size_t xBlockSize;                      /*<< The size of the free block. */
} BlockLink_t;

这个结构体主要充当表头的作用，用来串起每一块内存，方便分配和释放，分配就是一个插入链表的操作，释放就是删除链表的操作。

heap_3.c

这个文件里直接调用了malloc和free，依赖平台自己的实现。

void *pvPortMalloc( size_t xWantedSize )
{
void *pvReturn;vTaskSuspendAll();{pvReturn = malloc( xWantedSize );traceMALLOC( pvReturn, xWantedSize );}( void ) xTaskResumeAll();#if( configUSE_MALLOC_FAILED_HOOK == 1 ){if( pvReturn == NULL ){extern void vApplicationMallocFailedHook( void );vApplicationMallocFailedHook();}}#endifreturn pvReturn;
}
/*-----------------------------------------------------------*/void vPortFree( void *pv )
{if( pv ){vTaskSuspendAll();{free( pv );traceFREE( pv, 0 );}( void ) xTaskResumeAll();}
}

heap_4.c

同heap_2.c的实现，不同的是，4会合并内存碎片，而且比malloc高效，非常常用,但是依然有碎片的风险。
它只是把空闲内存都串起来。
比如要分配一个大内存，但是内存里都是不连续的碎片空间，也会造成失败

heap_5.c

同4，不同的，可以使用不连续的内存空间。

参考：

http://elmagnificogi.github.i...