FreeRTOS五种内存管理详解

freeRTOS五种内存管理详解

heap1

源码分析

c 复制代码
void * pvPortMalloc( size_t xWantedSize )
{
    void * pvReturn = NULL; // 申请的内存地址
    static uint8_t * pucAlignedHeap = NULL; // 用于指向堆内存的起始地址

#if ( portBYTE_ALIGNMENT != 1 ) // 如果对齐为1则不对齐,否则进入对齐操作
    {
        if( xWantedSize & portBYTE_ALIGNMENT_MASK ) // 与操作后有数据则表示尚未对齐
        {
            /* 首先, xWantedSize & portBYTE_ALIGNMENT_MASK是收集结尾有几个字节未对齐。
            然后,计算距离下一个对齐(portBYTE_ALIGNMENT)还剩多少字节,给申请的(xWantedSize)补上。
            正常情况下,这个数字补齐后肯定大于xWantedSize,除非加上的字节让它溢出了。
            所以如果小于xWantedSize,则将其置为0
            */
            if ( (xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) )) > xWantedSize )
            {
                xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
            } 
            else 
            {
                xWantedSize = 0; // 当申请为0的时候后续最关键的内存分配会被跳过,内存返回为NULL
            }
        }
    }
#endif

    vTaskSuspendAll(); // 内存申请,涉及到对全局变量以及局部静态变量的操作,故进入临界区
    {
        if( pucAlignedHeap == NULL )
        {
            /* ( portPOINTER_SIZE_TYPE )是强转成指针对应的整数类型,以便后续计算。
            ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) 的目的是为了向上对齐,也就是&后可以去除不对齐的部分。 
            由于去除不对其的部分可能会导致超出内存范围,所以加上portBYTE_ALIGNMENT留有一定空间用于向上对其。
            本质上是对ucHeap进行对齐操作。
            */
            pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) & ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
        }

        /* 检查是否有足够空间用于分配 */
        if( ( xWantedSize > 0 ) && /* 有效空间 */
            ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) && /* 防止剩余内存不足 */
            ( ( xNextFreeByte + xWantedSize ) > xNextFreeByte ) ) /* 防止溢出. */
        {
            pvReturn = pucAlignedHeap + xNextFreeByte; // pucAlignedHeap可以理解成ucHeap对齐后的地址,xNextFreeByte则是已申请的内存
            xNextFreeByte += xWantedSize;	// 统计被使用空间(名字好像取错了)
        }

        traceMALLOC( pvReturn, xWantedSize ); // 用于跟踪调试的宏,未设置则为空
    }
    ( void ) xTaskResumeAll(); // 退出临界区

#if ( configUSE_MALLOC_FAILED_HOOK == 1 ) // malloc失败的处理钩子函数
    {
        if( pvReturn == NULL )
        {
            extern void vApplicationMallocFailedHook( void );
            vApplicationMallocFailedHook();
        }
    }
#endif

    return pvReturn;
}

总结

作为最早期的内存管理,其实heap1做的事情很简单。首先,他的内存来源是全局静态数组。然后内存只能申请,并不能释放。因此,谈不上内存碎片等问题。在此之上,heap1加入了如下设计:

1. 线程安全:在申请内存的时候通过vTaskSuspendAll()和xTaskResumeAll()。暂停和恢复了任务的调度,让整体申请可以安全使用。
2. 内存对齐:主要分为两个对齐,前半部分对申请的内存大小进行了对齐,后半部分则对申请的起始内存地址进行了对齐。
3. traceMALLOC()宏用于跟踪内存申请
4. vApplicationMallocFailedHook()函数,用于内存申请失败回调

其实这也是同一系列heap有一些通用的特色设计

大致流程总结如下:

1. 申请的内存(xWantedSize)对齐
2. 内存起始地址(pucAlignedHeap)对齐(首次)
3. 返回内存起始地址+已申请的内存
4. 加上申请出的内存大小,更新已申请的内存

heap2

源码分析

c 复制代码
void * pvPortMalloc( size_t xWantedSize )
{
    BlockLink_t * pxBlock, * pxPreviousBlock, * pxNewBlockLink;
    static BaseType_t xHeapHasBeenInitialised = pdFALSE;
    void * pvReturn = NULL;

    vTaskSuspendAll();
    {
        /* 如果第一次调用,则调用prvHeapInit()函数来初始化 */
        if( xHeapHasBeenInitialised == pdFALSE )
        {
            prvHeapInit();
            xHeapHasBeenInitialised = pdTRUE;
        }

        /*
        * 首先,heapSTRUCT_SIZE指的是BlockLink_t结构体,它是一个保存内存块的单向链表。
        * 而heapSTRUCT_SIZE计算,实际上自带内存对齐
        */
        if( ( xWantedSize > 0 ) && 
        ( ( xWantedSize + heapSTRUCT_SIZE ) >  xWantedSize ) ) /* 判断剩余空间是否溢出 */
        {
            xWantedSize += heapSTRUCT_SIZE; // 将结构体的大小算入到申请的内存中去

            /* xWantedSize & portBYTE_ALIGNMENT_MASK是未对齐的部分,
                portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK )是算出需要补多少才能对齐
                xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )是对齐后的内存大小
                判断其>xWantedSize本质上就是判断是否溢出*/
            if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) ) 
                    > xWantedSize )
            {
                xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
                configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 ); // 确保真的是对齐的,以防万一吧
            }
            else
            {
                xWantedSize = 0;
            }	   
        }
        else 
        {
            xWantedSize = 0; 
        }

        // 判断申请内存大于0且剩余内存足够
        if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
        {
            
            pxPreviousBlock = &xStart; // 上一个内存区块
            pxBlock = xStart.pxNextFreeBlock; // 当前内存区块
            /* 区块按字节顺序存储 - 从起始(最小)区块开始遍历列表,直到找到足够大小的区块为止 */
            while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
            {
                pxPreviousBlock = pxBlock;
                pxBlock = pxBlock->pxNextFreeBlock;
            }

            /* 如果我们找到了结束标记,那么就没有找到足够大小的区块 */
            if( pxBlock != &xEnd )
            {
                /* 返回给用户内存使用的地址(需要跳过结构体头部分) */
                pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + heapSTRUCT_SIZE );

                /* 这里区块被使用,所以将它从空闲列表里剔除 */
                pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

                /* 如果区块剩余够大,则分成两个部分,一个使用区块,一个空闲区块. */
                if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
                {
                    /* 将区块分成两部分,计算下一个部分的地址 */
                    pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );

                    /* 重新计算两个区域的大小 */
                    pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
                    pxBlock->xBlockSize = xWantedSize;

                    /* 将空闲块插入到空闲队列里面 */
                    prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );
                }
                // 计算剩余内存
                xFreeBytesRemaining -= pxBlock->xBlockSize;
            }
        }
        
        traceMALLOC( pvReturn, xWantedSize );
    }
    ( void ) xTaskResumeAll();

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

    return pvReturn;
}
c 复制代码
void vPortFree( void * pv )
{
    uint8_t * puc = ( uint8_t * ) pv;
    BlockLink_t * pxLink;

    if( pv != NULL )
    {
        /* 被释放的内存前面会有一个 BlockLink_t 结构,所以反推真实申请的内存起始地址 */
        puc -= heapSTRUCT_SIZE;

        /* 这种强行转换是为了防止某些编译器发出字节对齐警告。 */
        pxLink = ( void * ) puc;

        vTaskSuspendAll();
        {
            /* 将释放的内存添加到内存区域内 */
            prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
            xFreeBytesRemaining += pxLink->xBlockSize; // 内存添加到内存剩余中去
            traceFREE( pv, pxLink->xBlockSize );
        }
        ( void ) xTaskResumeAll();
    }
}

总结

相对1而言,2最精彩的地方莫过于,通过数据结构来将内存进行管理,每个内存的头部分都用于结构体,结构体内的内存是按照由小到大的顺序排列,heapSTRUCT_SIZE之后的内存用来保存数据。这样的做法带来了一个好处(内存可以自由的申请释放)。同时也带来一个坏处,每次释放内存后,并没有进行相邻区域的合并,导致其内存会在多次申请和释放中不断的碎片化。

大致流程可以总结如下:

1. 初始化xStart, xEnd和pucAlignedHeap(首次)
2. 申请内存 (xWantedSize)加上结构体(heapSTRUCT_SIZE)并进行内存对齐
3. 遍历到空闲链表内满足且最小内存(空闲链表自身是由小到大)
4. 该内存块从空闲链表弹出,并返回出内存块+heapSTRUCT_SIZE的地址
5. 内存剩余空间大于heapMINIMUM_BLOCK_SIZE则将原先区块分成已用内存块和空闲内存块
6. 空闲内存块在插入到空闲链表中

heap3

源码分析

c 复制代码
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();
            }
        }
    #endif

    return pvReturn;
}
c 复制代码
void vPortFree( void * pv )
{
    if( pv )
    {
        vTaskSuspendAll();
        {
            free( pv );
            traceFREE( pv, 0 );
        }
        ( void ) xTaskResumeAll();
    }
}

总结

实际上这个基本上就是对malloc和free进行了线程保护,这个建立在某些sdk针对自己的内存分配有着自己的方法的前提下。我们只需要保护他们的申请和释放函数,没必要引入特别多的内存管理。

heap4

源码分析

c 复制代码
static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert ) /* PRIVILEGED_FUNCTION */
{
    BlockLink_t * pxIterator;
    uint8_t * puc;

    /* 迭代列表,直到找到地址介于二者之间 */
    for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
    {
        /* 这里不做任何事情,直到迭代后找到后,后续进行操作 */
    }

    /* 计算插入的数据块是否和上一个是连续的内存。
    * 如果是则合并(地址为上一个内存的地址,大小增加) 
    * 本质上没有将pxBlockToInsert插入进链表,只是扩大了上一个内存的size
    */
    puc = ( uint8_t * ) pxIterator;

    if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
    {
        pxIterator->xBlockSize += pxBlockToInsert->xBlockSize; // 直接将上个数据库扩大就完成了插入
        pxBlockToInsert = pxIterator; // 这里表示pxBlockToInsert已经和pxIterator一个意思了。用于后续判断
    }
    else
    {
        mtCOVERAGE_TEST_MARKER(); // 忽略,用于测试的宏
    }

    /* 插入的数据块和它下一个数据块是否是连续
     * 如果是则合并(当前内存地址不变,大小增加,当前的pxNextFreeBlock地址改为下一个pxNextFreeBlock) 
     * 其实这里的做法, 是修改当前的pxBlockToInsert,然后替换下一个数据块(差一步pxIterator->pxNextFreeBlock的修改)
     */
    puc = ( uint8_t * ) pxBlockToInsert;

    if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
    {
        if( pxIterator->pxNextFreeBlock != pxEnd )
        {
            pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
            pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock; // 这里的意图是想替换pxIterator->pxNextFreeBlock
        }
        else
        {
            pxBlockToInsert->pxNextFreeBlock = pxEnd; // 如果到结尾了,则插入尾巴 tag1
        }
    }
    else
    {
        pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock; // 如果不是,则准备作为一个独立的块插入空闲块链表里 tag2
    }

    /* 
     * 这里比较巧妙,当合并了前区块的时候,这里直接跳过
     * 如果和前面区块无关,和后面区块无关,则进入tag2,插入空闲块,最后,将pxBlockToInsert接入链表
     * 如果和前面区块无关,但是和后面区块相连,则修改pxBlockToInsert并且替换pxIterator->pxNextFreeBlock
     * 如果合并了前区块,但是和后面区块相连,将pxIterator的大小再扩大,无需将pxBlockToInsert接入链表
     * 如果和前面区块无关,但是已经到了pxEnd,则进入tag1,在pxEnd前插入
     */
    if( pxIterator != pxBlockToInsert )
    {
        pxIterator->pxNextFreeBlock = pxBlockToInsert; // 接入空闲链表中
    }
    else
    {
        mtCOVERAGE_TEST_MARKER(); // 忽略,用于测试的宏
    }
}
c 复制代码
void * pvPortMalloc( size_t xWantedSize )
{
    BlockLink_t * pxBlock, * pxPreviousBlock, * pxNewBlockLink;
    void * pvReturn = NULL;

    vTaskSuspendAll();
    {
        /* 如果这是第一次调用 malloc,则堆需要初始化来设置空闲块列表。 */
        if( pxEnd == NULL )
        {
            prvHeapInit();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }

        /* 取出最高位,最高位必须是0,因为后续需要用它作为标志位 */
        if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
        {
            /* 这部分和heap2.c一样主要为了扩大申请内存,以便保存结构体
             * 其中,xHeapStructSize是对齐后的大小, 最终的xWantedSize还进行了一次对齐
             */
            if( ( xWantedSize > 0 ) && 
                ( ( xWantedSize + xHeapStructSize ) >  xWantedSize ) ) /* Overflow check */
            {
                xWantedSize += xHeapStructSize;

                /* 判断是否对齐 */
                if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
                {
                    /* 判断对齐后有无溢出 */
                    if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) ) 
                            > xWantedSize )
                    {
                        xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ); // 加上了xHeapStructSize后,进行一次对齐操作
                        configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );
                    }
                    else
                    {
                        xWantedSize = 0;
                    }  
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            } 
            else 
            {
                xWantedSize = 0;
            }

            // 判断申请内存大于0且剩余内存足够
            if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
            {
                
                pxPreviousBlock = &xStart;
                pxBlock = xStart.pxNextFreeBlock;
                
                /* 开始遍历列表.(内存地址从小到大) */
                while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
                {
                    pxPreviousBlock = pxBlock;
                    pxBlock = pxBlock->pxNextFreeBlock;
                }

                /*这里操作基本上和heap2.c差别不大*/
                if( pxBlock != pxEnd )
                {
                    /* 返回给用户内存使用的地址(需要跳过结构体头部分) */
                    pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );

                    /* 里区块被使用,所以将它从空闲列表里剔除 */
                    pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

                    /* 如果区块剩余够大,则分成两个部分,一个使用区块,一个空闲区块. */
                    if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
                    {
                        /* This block is to be split into two.  Create a new
                         * block following the number of bytes requested. The void
                         * cast is used to prevent byte alignment warnings from the
                         * compiler. */
                        pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
                        configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );

                        /* 重新计算两个区域的大小 */
                        pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
                        pxBlock->xBlockSize = xWantedSize;

                        /* 将空闲块插入到空闲队列里面 */
                        prvInsertBlockIntoFreeList( pxNewBlockLink );
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }

                    xFreeBytesRemaining -= pxBlock->xBlockSize; // 计算总共剩余内存

                    // 计算曾经出现过的最小剩余内存,这部分不一定是连续的,也许是分散的。指标用于反应系统内存压力
                    if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
                    {
                        xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }

                    /* 正在返回的程序块是由应用程序分配和拥有的,没有 "下一个 "程序块。 */
                    pxBlock->xBlockSize |= xBlockAllocatedBit; // 最高位用作是否被初始化的标志,在free的时候即便被free了两遍也
                    pxBlock->pxNextFreeBlock = NULL; // 
                    xNumberOfSuccessfulAllocations++;
                }
                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 /* if ( configUSE_MALLOC_FAILED_HOOK == 1 ) */

    configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
    return pvReturn;
}
c 复制代码
void vPortFree( void * pv )
{
    uint8_t * puc = ( uint8_t * ) pv;
    BlockLink_t * pxLink;

    if( pv != NULL )
    {
        /* 被释放的内存前面将紧接着一个 BlockLink_t 结构 */
        puc -= xHeapStructSize;

        /* 这样做是为了防止编译器发出警告。 */
        pxLink = ( void * ) puc;

        /* 检查块是否已实际分配。 */
        configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
        configASSERT( pxLink->pxNextFreeBlock == NULL );

        if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
        {
            if( pxLink->pxNextFreeBlock == NULL )
            {
                /* 获取内存大小(去掉最高位) */
                pxLink->xBlockSize &= ~xBlockAllocatedBit;

                vTaskSuspendAll();
                {
                    /* 将释放后的内存插入空闲链表中 */
                    xFreeBytesRemaining += pxLink->xBlockSize;
                    traceFREE( pv, pxLink->xBlockSize );
                    prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
                    xNumberOfSuccessfulFrees++;
                }
                ( void ) xTaskResumeAll();
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
}

总结

heap2的prvInsertBlockIntoFreeList是一个宏。在最初的迭代查找中是查找它的大小,然后按照顺序放到空闲块链表里。而heap4的则是一个函数(相对复杂,故直接做成函数)。在最初迭代中,查找的是链表的地址,整体的合并设计的极为巧妙,寻找相邻的前后区块进行合并减少了内存碎片化。在pvPortMalloc的实现上,多了xBlockAllocatedBit, xNumberOfSuccessfulFrees,xNumberOfSuccessfulAllocations,xMinimumEverFreeBytesRemaining等功能。相当于在heap2的基础之上加入了相邻内存合并来解决内存碎片问题。

heap5

源码分析

c 复制代码
void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions )
{
    BlockLink_t * pxFirstFreeBlockInRegion = NULL, * pxPreviousFreeBlock;
    size_t xAlignedHeap;
    size_t xTotalRegionSize, xTotalHeapSize = 0;
    BaseType_t xDefinedRegions = 0;
    size_t xAddress;
    const HeapRegion_t * pxHeapRegion;

    /* 只能执行一遍! */
    configASSERT( pxEnd == NULL );

    pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );

    while( pxHeapRegion->xSizeInBytes > 0 )
    {
        xTotalRegionSize = pxHeapRegion->xSizeInBytes;

        /* 起始地址对齐. */
        xAddress = ( size_t ) pxHeapRegion->pucStartAddress;

        if( ( xAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
        {
            // 先补,再舍
            xAddress += ( portBYTE_ALIGNMENT - 1 );
            xAddress &= ~portBYTE_ALIGNMENT_MASK;

            /* 调整地址对齐后的大小 */
            xTotalRegionSize -= xAddress - ( size_t ) pxHeapRegion->pucStartAddress;
        }

        xAlignedHeap = xAddress;

        /* 如果尚未设置 xStart,则设置 xStart */
        if( xDefinedRegions == 0 )
        {
            /* xStart 用于保存指向空闲块列表中第一个项目的指针。*/
            xStart.pxNextFreeBlock = ( BlockLink_t * ) xAlignedHeap;
            xStart.xBlockSize = ( size_t ) 0; // 起始位置大小始终为0
        }
        else
        {
            /* 只有当一个区域已被添加到堆中时,才会出现这里. */
            configASSERT( pxEnd != NULL );

            /* 校验块的起始地址递增。 */
            configASSERT( xAddress > ( size_t ) pxEnd );
        }

        /* 记住上一区域的结束标记位置(如果有)。 */
        pxPreviousFreeBlock = pxEnd;

        /* pxEnd 用于标记空闲区块列表的结束,并插入区域空间的末尾 */
        xAddress = xAlignedHeap + xTotalRegionSize; // 指针指到底
        xAddress -= xHeapStructSize; // 往前退一个xHeapStructSize大小用于存放结构体
        xAddress &= ~portBYTE_ALIGNMENT_MASK; // 地址对齐
        pxEnd = ( BlockLink_t * ) xAddress; // 
        pxEnd->xBlockSize = 0; // xEnd大小始终是0
        pxEnd->pxNextFreeBlock = NULL; // xEnd下一个地址始终是NULL

        /* 首先,该区域有一个空闲块,其大小为整个堆区域减去空闲块结构占用的空间。 */
        pxFirstFreeBlockInRegion = ( BlockLink_t * ) xAlignedHeap; // 第一个内存块位置
        pxFirstFreeBlockInRegion->xBlockSize = xAddress - ( size_t ) pxFirstFreeBlockInRegion; // 结束的地址减去地址,得到长度
        pxFirstFreeBlockInRegion->pxNextFreeBlock = pxEnd; //下一个指向结束

        /* 如果这不是构成整个堆空间的第一个区域,则将前一个区域链接到这个区域。 */
        if( pxPreviousFreeBlock != NULL )
        {
            pxPreviousFreeBlock->pxNextFreeBlock = pxFirstFreeBlockInRegion;
        }

        xTotalHeapSize += pxFirstFreeBlockInRegion->xBlockSize; // 计算总共大小

        /* 移动到下一个结构体 */
        xDefinedRegions++;
        pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );
    }

    xMinimumEverFreeBytesRemaining = xTotalHeapSize; // 记录曾经最小的空闲内存大小
    xFreeBytesRemaining = xTotalHeapSize; // 记录空闲内存大小

    /* 检测总共大小 */
    configASSERT( xTotalHeapSize );

    /* 计算出 size_t 变量中最高位的位置。(用于标志区块是否空闲) */
    xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
}
c 复制代码
/*
 * 使用说明:
 *
 * vPortDefineHeapRegions() 必须在 pvPortMalloc() 之前调用.
 * 如果创建了任何任务对象(任务、队列、事件组等),pvPortMalloc() 将被调用。
 * 因此必须在定义任何其他对象之前调用 vPortDefineHeapRegions()。
 * 
 * 数组使用 NULL 零大小区域定义终止,
 * 数组中定义的内存区域必须按照从低地址到高地址的地址顺序出现。 
 * 因此,下面是一个使用该函数的有效示例。
 *
 * HeapRegion_t xHeapRegions[] =
 * {
 *  { ( uint8_t * ) 0x80000000UL, 0x10000 }, << 从地址 0x80000000 开始定义一个 0x10000 字节的数据块
 *  { ( uint8_t * ) 0x90000000UL, 0xa0000 }, << 定义从 0x90000000 地址开始的 0xa0000 字节块
 *  { NULL, 0 }                << 终止数组。
 * };
 *
 * vPortDefineHeapRegions( xHeapRegions ); << 将数组传入 vPortDefineHeapRegions()。
 *
 * 注意 0x80000000 地址较低,因此首先出现在数组中。
 *
 */

总结

heap5是基于heap4,对其prvHeapInit()进行了进一步的修改。在heap4中,使用的还是一段连续的内存。通过初次malloc,调用prvHeapInit()。在heap5中,在第一次prvHeapInit()之前,需要单独的使用vPortDefineHeapRegions(),但是可以通过参数一次性注册多块不连续的内存。在别的分析中,没有去阅读其初始的注释,它告诉我们需要以{NULL, 0}作为结尾。且不连续的内存需要由小到大的排列。

相关推荐
云卓SKYDROID8 分钟前
除草机器人算法以及技术详解!
算法·机器人·科普·高科技·云卓科技·算法技术
半盏茶香32 分钟前
【C语言】分支和循环详解(下)猜数字游戏
c语言·开发语言·c++·算法·游戏
徐子童36 分钟前
双指针算法习题解答
算法
想要打 Acm 的小周同学呀1 小时前
LRU缓存算法
java·算法·缓存
劲夫学编程2 小时前
leetcode:杨辉三角
算法·leetcode·职场和发展
毕竟秋山澪2 小时前
孤岛的总面积(Dfs C#
算法·深度优先
浮生如梦_4 小时前
Halcon基于laws纹理特征的SVM分类
图像处理·人工智能·算法·支持向量机·计算机视觉·分类·视觉检测
励志成为嵌入式工程师6 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉6 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer6 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法