2. 程式人生 > 實用技巧 >FreeRTOS --（5）記憶體管理 heap4

FreeRTOS --（5）記憶體管理 heap4

阿新 • • 發佈：2020-10-09

FreeRTOS 中的 heap 4 記憶體管理，可以算是 heap 2 的增強版本，在 《FreeRTOS --（3）記憶體管理 heap2》中，我們可以看到，每次記憶體分配後都會產生一個記憶體塊，多次分配後，會產生很多記憶體碎片，在較為複雜的場景（需要經常動態分配和釋放場景）下，幾乎是無法勝任；

所以就有了 heap 4，它相比 heap 2 來說，提供了相鄰空閒的記憶體塊合併的功能，一定程度上減少了記憶體碎片，使得釋放了的記憶體能夠再度合併稱為較為大的記憶體塊，以供有大記憶體塊的分配場景使用；

1、記憶體大小

和 heap 2 一樣，用於記憶體管理的記憶體大小來自於一個大陣列，陣列的下標就是整個需要被管理的記憶體的大小，這個是和具體晶片所支援的 RAM 大小相關：

configTOTAL_HEAP_SIZE

被管理的記憶體定義為：

static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

ucHeap 就是管理的物件；

這些基本的結構都是和之前的 heap2 保持一致，不再多說；

2、對齊

對齊的部分也是和 heap 2 一致，不在多說，更多的參考：《FreeRTOS --（3）記憶體管理 heap2》的對齊章節；

3、記憶體塊

記憶體塊的定義依然是：

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;

沒有任何差別，依然有 xStart 和 xEnd 來描述兩個 marker，和 heap 2 幾乎一樣《FreeRTOS --（3）記憶體管理 heap2》；這裡不再多說；

4、記憶體初始化

和 heap 2 一樣，記憶體初始化使用prvHeapInit，在第一次呼叫記憶體分配的時候，檢查是否有初始化，否則進行prvHeapInit 的呼叫，初始化相關的結構：

static void prvHeapInit( void )
{
BlockLink_t *pxFirstFreeBlock;
uint8_t *pucAlignedHeap;
size_t uxAddress;
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
 
    /* Ensure the heap starts on a correctly aligned boundary. */
    uxAddress = ( size_t ) ucHeap;
 
    if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
    {
        uxAddress += ( portBYTE_ALIGNMENT - 1 );
        uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
        xTotalHeapSize -= uxAddress - ( size_t ) ucHeap;
    }
 
    pucAlignedHeap = ( uint8_t * ) uxAddress;
 
    /* 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;
 
    /* pxEnd is used to mark the end of the list of free blocks and is inserted
    at the end of the heap space. */
    uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize;
    uxAddress -= xHeapStructSize;
    uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
    pxEnd = ( void * ) uxAddress;
    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 = uxAddress - ( size_t ) pxFirstFreeBlock;
    pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
 
    /* Only one block exists - and it covers the entire usable heap space. */
    xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
    xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
 
    /* Work out the position of the top bit in a size_t variable. */
    xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
}

從編碼風格的角度上來說，看上去感覺和 heap 2 不是同一個人寫的（同樣的邏輯，不同的表達），不過沒關係，含義都是一樣的；

依然是初始化了 xStart 和 xEnd 兩個 marker；做了一些對齊處理後，將能夠分配的所有的空間一併掛到了 xStart->pxNextFreeBlock 連結串列；

和 heap 2 不一樣的是，heap 4 定義了一個標記，以表示記憶體是否有被使用，這裡定義了 xBlockAllocatedBit；如果是 32bit CPU 的話，這個xBlockAllocatedBit = 0x01<<31；32 bit 的最高位，這顯然是安全的；

5、記憶體分配

記憶體分配，還是使用的pvPortMalloc 介面，正確分配，返回可用的記憶體地址，出錯返回 NULL：

void *pvPortMalloc( size_t xWantedSize )
{
BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;
void *pvReturn = NULL;
 
    vTaskSuspendAll();
    {
        /* If this is the first call to malloc then the heap will require
        initialisation to setup the list of free blocks. */
        if( pxEnd == NULL )
        {
            prvHeapInit();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
 
        /* Check the requested block size is not so large that the top bit is
        set.  The top bit of the block size member of the BlockLink_t structure
        is used to determine who owns the block - the application or the
        kernel, so it must be free. */
        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;
 
                /* Ensure that blocks are always aligned to the required number
                of bytes. */
                if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
                {
                    /* Byte alignment required. */
                    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 ) )
            {
                /* Traverse the list from the start    (lowest address) 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 the end marker was reached then a block of adequate size
                was    not found. */
                if( pxBlock != pxEnd )
                {
                    /* Return the memory space pointed to - jumping over the
                    BlockLink_t structure at its start. */
                    pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );
 
                    /* This block is being returned for use so must be taken out
                    of the list 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
                        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 );
 
                        /* Calculate the sizes of two blocks split from the
                        single block. */
                        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();
                    }
 
                    /* The block is being returned - it is allocated and owned
                    by the application and has no "next" block. */
                    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( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
    return pvReturn;
}

記憶體分配部分的程式碼和之前的 heap 2 的程式碼幾乎完全一樣，這裡不做過多的解釋；

6、記憶體釋放

記憶體釋放是vPortFree 介面：

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 immediately
        before it. */
        puc -= xHeapStructSize;
 
        /* This casting is to keep the compiler from issuing warnings. */
        pxLink = ( void * ) puc;
 
        /* Check the block is actually allocated. */
        configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
        configASSERT( pxLink->pxNextFreeBlock == NULL );
 
        if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
        {
            if( pxLink->pxNextFreeBlock == NULL )
            {
                /* The block is being returned to the heap - it is no longer
                allocated. */
                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();
        }
    }
}

釋放的時候，將之前的記憶體通過呼叫prvInsertBlockIntoFreeList 插入到 Free List 中，記憶體塊的合併就體現在這個函式；

6.1、合併

當釋放記憶體的時候呼叫到了prvInsertBlockIntoFreeList，它實現了相鄰記憶體塊的合併工作，這也是 heap 4 與 heap 2 最大不同的地方：

static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )
{
BlockLink_t *pxIterator;
uint8_t *puc;
 
    /* Iterate through the list until a block is found that has a higher address
    than the block being inserted. */
    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();
    }
 
    /* Do the block being inserted, and the block it is being inserted before
    make a contiguous block of memory? */
    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 the block being inserted plugged a gab, so was merged with the block
    before and the block after, then it's pxNextFreeBlock pointer will have
    already been set, and should not be set here as that would make it point
    to itself. */
    if( pxIterator != pxBlockToInsert )
    {
        pxIterator->pxNextFreeBlock = pxBlockToInsert;
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
}

在 heap 2中，也有這個函式，但是它是按照記憶體塊的小到大進行排序，由於有相鄰記憶體塊合併的要求，所以在 heap 4 中，記憶體塊連結串列的組織形式，是按照他們的地址順序由小到大組織的；

首先通過 xStart 開始，獲取第一個空閒塊的地址，並比較它的下一個空閒塊地址和待插入空閒塊地址的大小，以便獲得合適的插入位置；

獲得合適的位置了以後，判斷待插入的這個空閒塊是否和前一個空閒塊相鄰，如果相鄰的話，就將兩個塊合併到一起：

/* 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();
    }

然後在判斷是否和後一個空閒塊也相鄰，如果相鄰，也將他們合併，當然這裡需要判斷是否是緊挨著 xEnd：

/* Do the block being inserted, and the block it is being inserted before
    make a contiguous block of memory? */
    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;
    }

打個比方：

多次分配和釋放後，記憶體佈局如下所示：

如果要釋放中間那個記憶體，那麼就會觸發向上和向下的合併：

官方針對這個 heap 4 的官圖為：

相關推薦

FreeRTOS --（5）記憶體管理 heap4

FreeRTOS 中的 heap 4 記憶體管理，可以算是 heap 2 的增強版本，在 《FreeRTOS --（3）記憶體管理 heap2》中，我們可以看到，每次記憶體分配後都會產生一個記憶體塊，多次分配後，會產生很多記憶體碎片，在較為複雜

FreeRTOS --（2）記憶體管理 heap1

轉載自https://blog.csdn.net/zhoutaopower/article/details/106631237 FreeRTOS 提供了5種記憶體堆管理方案，分別對應heap1/heap2/heap3/heap4/heap5，提供記憶體管理是作為 OS 的一項基本功能，FreeRTOS 根據具體的

FreeRTOS --（3）記憶體管理 heap2

在《FreeRTOS --（2）記憶體管理 heap1》知道 heap 1 的記憶體管理其實只是簡單的實現了記憶體對齊的分配策略，heap 2 的實現策略相比 heap 1 稍微複雜一點，不僅僅是提供了分配記憶體的介面，同時也提供了釋放記憶體

FreeRTOS --（6）記憶體管理 heap5

轉載自https://blog.csdn.net/zhoutaopower/article/details/106748308 FreeRTOS 中的 heap 5 記憶體管理，相對於 heap 4《FreeRTOS --（5）記憶體管理 heap4》只增加了對非連續記憶體區域的管理，什麼叫非連續區域記

Django學習筆記（5）上下文管理器

上下文管理器　　view.py檔案定義的方法，實際工作中會出現很多重複的程式碼，這個部分就可以使用上下文管理器來處理這些共用的內容

FreeRTOS --（7）任務管理之入門篇

轉載自https://blog.csdn.net/zhoutaopower/article/details/107019521 任務管理是作業系統中重中之重，不管什麼 OS ，任務的排程管理都是核心，FreeRTOS 也是一樣；在深入到 FreeRTOS 任務管理的原始碼之前，鄙人覺

FreeRTOS --（8）任務管理之建立任務

轉載自https://blog.csdn.net/zhoutaopower/article/details/107034995 在《FreeRTOS --（7）任務管理之入門篇》文章基本分析了任務相關的輪廓後，我們知道使用什麼介面來建立一個任務、怎麼去開啟排程器、以及根據巨

FreeRTOS --（9）任務管理之啟動排程器

轉載自https://blog.csdn.net/zhoutaopower/article/details/107057528 在使用 FreeRTOS 的時候，一般的，先建立若干任務，但此刻任務並沒有被排程起來，僅僅是建立了，如果想要真正的跑起來，那麼還需要呼叫讓排程器

FreeRTOS --（10）任務管理之任務延時

轉載自https://blog.csdn.net/zhoutaopower/article/details/107101723 在《FreeRTOS --（7）任務管理之入門篇》中講過，如果有幾個任務同時跑，但是又都不阻塞的話，那麼最高優先順序的任務將會佔領整個 CPU，因為每

FreeRTOS --（11）任務管理之系統節拍

轉載自https://blog.csdn.net/zhoutaopower/article/details/107146764 前面有了建立任務、啟動排程器、任務控制，接下來便開始分析一個 Tick 到來之後，FreeRTOS 即將有什麼行為；

FreeRTOS --（13）任務管理之空閒任務

轉載自https://blog.csdn.net/zhoutaopower/article/details/107180016 建立完畢任務，啟動排程器，任務控制，系統 SysTick 來臨後判斷是否需上下文切換；

FreeRTOS --（14）佇列管理之概述

轉載自https://blog.csdn.net/zhoutaopower/article/details/107221175 在任何的 OS 中，都需要支援任務與任務，中斷與任務之間的資料傳輸機制，在 FreeRTOS 中，這種資料傳輸的方式被稱之為佇列（Queue）；

作業系統（三）—— 記憶體管理

三、記憶體管理 1. 記憶體管理的概念 1）記憶體的基礎知識 ​ ① 記憶體：用於存放資料的硬體。程式執行前先放到記憶體中才會被CPU處理。

自動化運維工具SaltStack之return與job管理（5）

目錄1. SaltStack元件之return1.1 return流程1.2 使用mysql作為return儲存方式2. job cache2.1 job cache流程2.2 job管理

Rust能力養成系列之（32）： 管理陷阱與記憶體安全

前言 上篇末尾提及要做一點小小的吐槽，不負前言，我們花一點篇幅來談一下記憶體管理中的各個坑，而後進入記憶體安全的內容。

軟考中級系統整合專案管理 資訊化知識（5）面向物件系統分析與設計

1)面向物件系統分析與設計 ①　物件： 由資料及其操作所構成的封裝體，是系統中用來描述客觀事物的一個模組，是構成系統的基本單位。物件是由一組屬性和對這組屬性進行的操作構成的。

2019年Java面試題基礎系列228道（5），快看看哪些你還不會？

2019年Java面試題基礎系列228道 Java面試題（一） 第一篇更新1~20題的答案解析 juejin.im/post/5de8c6…

分散式唯一ID生成系列（5）——Twitter的雪法演演算法Snowflake適合做分散式ID嗎

寫到這裡，分散式Id算是寫到最後一篇了，在這一篇裡，我會講到目前網上最適合分散式Id的方法，什麼方法呢，請您往下看：

WINFORM許可權系統開發系列教程（八）角色管理模組

實現過程 1 角色列表頁和資訊頁面佈局 2 功能實現分析 載入所有角色列表 新增 --角色資訊頁面 許可權分配--入口--角色選單設定頁面

條形圖-資料分析（5）

# -*- coding: utf-8 -*- import numpy; import matplotlib; from pandas import read_csv; from matplotlib import pyplot as plt;