FreeRtos heap4源码分析

===============================   博客点滴积累，部分话语和知识点来源于网络，感谢网络资源的提供者======

heap4 与heap2 比较相似，也是简单地实现了pvPortMalloc()和vPortFree()，不过对于释放的空闲内存碎片进行了合并，其他的细微区别会在代码说明的，这里只贴与heap2 不一样的地方

/* Assumes 8bit bytes! */
#define heapBITS_PER_BYTE ( ( size_t ) 8 )
/*结合宏heapBITS_PER_BYTE 标记结构体A_BLOCK_LINK的xBlockSize最高位*/
static size_t xBlockAllocatedBit = 0;
/* 定义一个链表结构体，存空闲的内存块指针和大小 */
typedef struct A_BLOCK_LINK
{

struct A_BLOCK_LINK *pxNextFreeBlock;/*<< 下一个空闲块的指针 */
size_t xBlockSize;/*<<空闲块的大小 最高bit为1 表示已经被分配，为0表示空闲 这是与heap2 有区别的地方*/
#if (SUPPORT_HEAP_DEBUG == 1)
TaskHandle_t xHandle;
#endif

} BlockLink_t;
static void prvHeapInit( void )
{

BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;
uint32_t ulAddress;
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
ulAddress = ( uint32_t ) ucHeap;
if( ( ulAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
{//调整使其字节对齐，向上取整

ulAddress += ( portBYTE_ALIGNMENT - 1 );

ulAddress &= ~portBYTE_ALIGNMENT_MASK;

xTotalHeapSize -= ulAddress - ( uint32_t ) ucHeap;

}
pucAlignedHeap = ( uint8_t * ) ulAddress;
/* xStart is used to hold a pointer to the first item in the list of free
blocks.  The void cast is used to prevent compiler warnings. */
xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
xStart.xBlockSize = ( size_t ) 0;
/*这一块和heap2有点区别了，heap2 pxEnd 是一个结构体，heap4时，是一个结构体指针
指向ulAddress，这个地址存着pxEnd 结构体*/
ulAddress = ( ( uint32_t ) pucAlignedHeap ) + xTotalHeapSize;
ulAddress -= xHeapStructSize;
ulAddress &= ~portBYTE_ALIGNMENT_MASK;
pxEnd = ( void * ) ulAddress;
pxEnd->xBlockSize = 0;
pxEnd->pxNextFreeBlock = NULL;
/* To start with there is a single free block that is sized to take up the
entire heap space, minus the space taken by pxEnd. */
pxFirstFreeBlock = ( void * ) pucAlignedHeap;
pxFirstFreeBlock->xBlockSize = ulAddress - ( uint32_t ) pxFirstFreeBlock;//结束地址-开始地址= 大小
pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
#if (SUPPORT_HEAP_DEBUG == 1)

pxFirstBlock = pxFirstFreeBlock;

#endif
/* Only one block exists - and it covers the entire usable heap space. */
xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;

/*设置xBlockAllocatedBit 最高位为1 将来标记内存块是否被分配过*/
xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );

}
/*-----------------------------------------------------------*/
/*heap4 与heap2 最大的区别就是这个函数了，插入时，会合并内存碎片*/
static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )
{

BlockLink_t *pxIterator;
uint8_t *puc;
/*遍历查找到，内存块地址大于插入块地址，就跳出*/
for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
{
/* Nothing to do here, just iterate to the right position. */
}
/* Do the block being inserted, and the block it is being inserted after
make a contiguous block of memory? */
puc = ( uint8_t * ) pxIterator;
if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
{//前一块和插入块相邻，合并内存块

pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;

pxBlockToInsert = pxIterator;

}
else
{

mtCOVERAGE_TEST_MARKER();

}
puc = ( uint8_t * ) pxBlockToInsert;
if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
{//后一块和插入块相邻，合并内存块

if( pxIterator->pxNextFreeBlock != pxEnd )

{

/* Form one big block from the two blocks. */

pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;

pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;

}

else

{

pxBlockToInsert->pxNextFreeBlock = pxEnd;

}

}
else
{

pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;

}
/* 如果和前一块内存合并了， 内存地址会相等，不用修改指针，若不相等，则需要修改指针插入*/
if( pxIterator != pxBlockToInsert )
{

pxIterator->pxNextFreeBlock = pxBlockToInsert;

}
else
{

mtCOVERAGE_TEST_MARKER();

}

}
/*-----------------------------------------------------------*/

void *pvPortMalloc( size_t xWantedSize )
{

BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
void *pvReturn = NULL;
vTaskSuspendAll();
{

/* 如果是第一次初始化，需要初始化空闲链表. */

if( pxEnd == NULL )

{

prvHeapInit();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

/* 需要分配的内存不能太大 */

if( ( xWantedSize & xBlockAllocatedBit ) == 0 )

{

/* The wanted size is increased so it can contain a BlockLink_t

structure in addition to the requested amount of bytes. */

if( xWantedSize > 0 )

{

xWantedSize += xHeapStructSize;/*分配的地址最前面放这个BlockLink_t结构体*/

if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )

{/* 调整字节对齐 */

xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );

configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else

{

mtCOVERAGE_TEST_MARKER();

}

if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )

{

/* /*空闲块是从小到大存储，遍历链表，直到找到合适的空闲块 */ */

pxPreviousBlock = &xStart;

pxBlock = xStart.pxNextFreeBlock;

while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )

{

pxPreviousBlock = pxBlock;

pxBlock = pxBlock->pxNextFreeBlock;

}

if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )

{/* 如果该空闲块比较大，剩余的大小大于两个BlockLink_t，则将该块分为两个 */

/* 创建一个新块*/

pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );

configASSERT( ( ( ( uint32_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );

/* 计算新块的大小*/

/* If the end marker was reached then a block of adequate size wasnot found. */

if( pxBlock != pxEnd )

{/* 遍历后找到合适的块 */

/* 返回分配的内存地址 - 分配的地址实际是BlockLink_t + 需要分配的大小，所以返回的地址要跳过BlockLink_t */

pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );

#if (SUPPORT_HEAP_DEBUG == 1)

pxPreviousBlock->pxNextFreeBlock->xHandle = xTaskGetCurrentTaskHandle();

#endif

/* 去掉空闲链表的刚分配的块 */

pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;

pxBlock->xBlockSize = xWantedSize;

/* Insert the new block into the list of free blocks. */

prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );

}

else

{

mtCOVERAGE_TEST_MARKER();

}

xFreeBytesRemaining -= pxBlock->xBlockSize;//减去已经分配的字节数，剩下实际可分配的字节数

if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )

{

xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;

}

else

{

mtCOVERAGE_TEST_MARKER();

}

/* 标记该内存块已经被分配，并置pxBlock->pxNextFreeBlock = NULL */

pxBlock->xBlockSize |= xBlockAllocatedBit;

pxBlock->pxNextFreeBlock = NULL;

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else

{

mtCOVERAGE_TEST_MARKER();

}

traceMALLOC( pvReturn, xWantedSize );

}

( void ) xTaskResumeAll();

#if( configUSE_MALLOC_FAILED_HOOK == 1 )
{

if( pvReturn == NULL )

{

extern void vApplicationMallocFailedHook( void );

vApplicationMallocFailedHook();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}
#endif
configASSERT( ( ( ( uint32_t ) pvReturn ) & portBYTE_ALIGNMENT_MASK ) == 0 );
return pvReturn;

}
/*-----------------------------------------------------------*/
void vPortFree( void *pv )
{

uint8_t *puc = ( uint8_t * ) pv;
BlockLink_t *pxLink;
if( pv != NULL )
{ /* 分配的大小是 实际大小 + heapSTRUCT_SIZE 所以实际的起始地址需要减去heapSTRUCT_SIZE */

puc -= xHeapStructSize;

pxLink = ( void * ) puc;

/* Check the block is actually allocated. */

configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );

configASSERT( pxLink->pxNextFreeBlock == NULL );

/*被分配的地址，xBlockSize 最高bit为1*/

if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )

{

if( pxLink->pxNextFreeBlock == NULL )/*被分配后pxLink->pxNextFreeBlock 被置位NULL*/

{

/* 修改标志，表示该内存块空闲 */

pxLink->xBlockSize &= ~xBlockAllocatedBit;

vTaskSuspendAll();

{

/* Add this block to the list of free blocks. */

xFreeBytesRemaining += pxLink->xBlockSize;

traceFREE( pv, pxLink->xBlockSize );

prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );

}

( void ) xTaskResumeAll();

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

else

{

mtCOVERAGE_TEST_MARKER();

}

}

}
/*-----------------------------------------------------------*/