概述

在計算機系統(tǒng)中，變量、中間數(shù)據(jù)一般存放在系統(tǒng)存儲空間中，只有實際使用的時候才將他們從存儲空間調(diào)入到中央處理器內(nèi)部進(jìn)行計算。通常存儲空間分為兩類：內(nèi)部存儲空間和外部存儲空間。對于電腦來講，內(nèi)部存儲空間就是電腦的內(nèi)存，外部存儲空間就是電腦的硬盤。而對于單片機來講，內(nèi)部存儲就是 RAM ，隨機存儲器。外部存儲可以理解為 flash ，掉電不丟失。該篇文章的主題，內(nèi)存管理，主要討論的是關(guān)于 RAM 的管理。

堆、棧和靜態(tài)區(qū)

針對于 Cortex M3 內(nèi)核的單片機的詳細(xì)內(nèi)存分配可以參照筆者的這篇文章 STM32 內(nèi)存分配解析及變量的存儲位置 ，在這里不進(jìn)行贅述，簡單的進(jìn)行劃分一下，大致可以分為三個部分：靜態(tài)區(qū)，棧，堆。

• 靜態(tài)區(qū)：保存全局變量和 static 變量(包括由 static 修飾的全局變量和局部變量)。靜態(tài)區(qū)的內(nèi)容在總個程序的生命周期內(nèi)都存在，由編譯器在編譯的時候進(jìn)行分配。

• 棧：保存局部變量。棧上的內(nèi)容只在函數(shù)的范圍內(nèi)存在，當(dāng)函數(shù)運行結(jié)束，這些內(nèi)容也會自動被銷毀。其特點是效率高，但空間大小有限。

• 堆：由 malloc 函數(shù)分配的內(nèi)存。其生命周期由 free 決定，在沒有釋放之前一直存下，直到程序結(jié)束。

內(nèi)存碎片和內(nèi)存泄漏

涉及到動態(tài)內(nèi)存管理時，會觸及到兩個概念，一個就是內(nèi)存碎片另一個就是內(nèi)存泄漏，下面分別闡述著兩個概念。

內(nèi)存碎片

假設(shè)我現(xiàn)在有 16 個字節(jié)的空閑內(nèi)存，如下圖所示：

現(xiàn)在我使用 malloc 分配了四次內(nèi)存，然后這 16 個字節(jié)的內(nèi)存變成了這樣：

然后，又使用 free 釋放了三次內(nèi)存，釋放之后的內(nèi)存空間是這樣的：

在沒有 MMU 的情況下，現(xiàn)在我準(zhǔn)備用 malloc 一次性分配 12 個字節(jié)的內(nèi)存空間，雖然上述 16 個字節(jié)的內(nèi)存空間還剩下 13 個字節(jié)，但是卻因為內(nèi)存不是連續(xù)的，因此是不能夠進(jìn)行分配的，這也就是出現(xiàn)內(nèi)存碎片的原因了。

內(nèi)存泄漏

內(nèi)存泄漏產(chǎn)生的原因是當(dāng)分配時的內(nèi)存已經(jīng)不再使用了，但是卻沒有被釋放掉，這個時候，導(dǎo)致內(nèi)存不夠用，這對于嵌入式設(shè)備這種內(nèi)存極其有限的對象來說是極其有害的。因此，在使用 malloc時，要搭配著 free 來進(jìn)行使用。

什么時候會使用到堆呢？

靜態(tài)區(qū)，棧我們我們在編寫程序的時候都會涉及到，定義一個全局變量，就存放在了靜態(tài)區(qū)，在函數(shù)內(nèi)部定義了一個局部變量，就存放在了棧，那堆呢？堆什么時候會使用到呢？假設(shè)現(xiàn)在有這樣一個程序。

int main(void)
{
    char *buffer[3] = {NULL};
    char *string1 = "hello";
    char *string2 = "word"; 
    char *string3 = "wenzi";

    buffer[0] = (char *)malloc(strlen(string1) + 1);
    if (buffer[0] != NULL)
        strcpy(buffer[0],string1);

    buffer[1] = (char *)malloc(strlen(string2) + 1);
    if (buffer[1] != NULL)
        strcpy(buffer[1],string2);

    buffer[2] = (char *)malloc(strlen(string3) + 1);
    if (buffer[2] != NULL)
        strcpy(buffer[2],string3); 
}

可以看到上述代碼的意思是將string1、string2、string3三個字符串復(fù)制到 buffer 所在內(nèi)存位置，但是這個時候，如果不給數(shù)組的元素分配一定大小的內(nèi)存，那么可能就放不下拷貝進(jìn)去的字符串，因此在往里面拷貝字符串時，應(yīng)該提前開辟出一段內(nèi)存空間出來，這個時候，就需要使用到 malloc 來進(jìn)行內(nèi)存分配，當(dāng)然所對應(yīng)的，當(dāng)這個數(shù)組使用完之后，需要使用 free來將分配的內(nèi)存釋放掉，否則就會造成內(nèi)存泄漏。

單片機如何進(jìn)行分配內(nèi)存

在上述介紹的分配內(nèi)存中，都是使用 malloc來進(jìn)行分配內(nèi)存，然后使用 free 來進(jìn)行釋放內(nèi)存，但是針對于單片機 RAM 如此緊缺的設(shè)備來講，使用 C 標(biāo)準(zhǔn)庫中的內(nèi)存管理函數(shù)是不恰當(dāng)?shù)模嬖谥S多弊端，主要有以下幾點：

• 他們的實現(xiàn)可能非常大，占據(jù)了相當(dāng)大的一塊代碼空間

• 這兩個函數(shù)會使得鏈接器配置得復(fù)雜

• 如果允許堆空間的生長方向覆蓋其他變量的內(nèi)存，他們會成為 debug 的災(zāi)難

基于此，正點原子的例程中給出了一種內(nèi)存管理的方法：分塊式內(nèi)存管理，實現(xiàn)原理如下圖所示：

簡單說明一下，分塊式內(nèi)存管理由內(nèi)存池和內(nèi)存管理表構(gòu)成。內(nèi)存池被等分為 n 塊，對應(yīng)的內(nèi)存管理表，大小也為 n。內(nèi)存管理表的每一項對應(yīng)著內(nèi)存池的一塊內(nèi)存。之所以有內(nèi)存表項的存在，是因為需要通過內(nèi)存表項表征當(dāng)前內(nèi)存塊有沒有被占用，如果對應(yīng)的內(nèi)存塊沒有被占用，那么該表項值就為 0 ，非 0 表示該內(nèi)存塊已經(jīng)被占用。如果某項值為 10，那么說明本項對應(yīng)的內(nèi)存塊在內(nèi)，總共分配了 10 個內(nèi)存塊給外部的某個指針。

內(nèi)存分配原理

當(dāng)指針 p 調(diào)用 malloc 申請內(nèi)存的時候，先判斷 p 要分配的內(nèi)存塊數(shù)(m)，然后從第 n 項開始，向下查找，直到找到 m 塊連續(xù)的空內(nèi)存塊（即對應(yīng)內(nèi)存管理表項為 0），然后將這 m 個內(nèi)存管理表項的值都設(shè)置為 m（標(biāo)記被占用），最后，把最后的這個空內(nèi)存塊的地址返回指針 p，完成一次分配。注意，如果當(dāng)內(nèi)存不夠的時候（找到最后也沒找到連續(xù)的 m 塊空閑內(nèi)存），則返回 NULL 給 p，表示分配失敗。基于此原理，我們來完成內(nèi)存分配函數(shù)。
首先我們需要定義內(nèi)存池的大小和內(nèi)存表的大?。?/p>

#define MEM1_BLOCK_SIZE            32         //內(nèi)存塊大小為32字節(jié)
#define MEM1_MAX_SIZE            10*1024    //最大管理內(nèi)存 10K
#define MEM1_ALLOC_TABLE_SIZE    MEM1_MAX_SIZE/MEM1_BLOCK_SIZE   //內(nèi)存表大小  

上述中內(nèi)存表的大小直接用內(nèi)存池的大小除以內(nèi)存塊的大小是因為內(nèi)存管理表和內(nèi)存塊一一對應(yīng)的，內(nèi)存塊的數(shù)量也就等于內(nèi)存池中內(nèi)存塊的數(shù)量。
有了內(nèi)存池和內(nèi)存管理表的大小，那么就可以定義內(nèi)存池和內(nèi)存管理表了，定義如下所示：

//內(nèi)存池(32字節(jié)對齊)
__align(32) uint8_t mem1base[MEM1_MAX_SIZE];                                                    //內(nèi)部SRAM內(nèi)存
//內(nèi)存管理表
uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                    //內(nèi)部SRAM內(nèi)存池MAP
//內(nèi)存管理參數(shù)       
const uint32_t memtblsize = MEM1_ALLOC_TABLE_SIZE;    //內(nèi)存表大小
const uint32_t memblksize = MEM1_BLOCK_SIZE;          //內(nèi)存分塊大小
const uint32_t memsize = MEM1_MAX_SIZE;                  //內(nèi)存總大小

上述所定義的就是內(nèi)存池和內(nèi)存管理表的相關(guān)內(nèi)容，關(guān)于內(nèi)存池采用 32 個字節(jié)對齊是因為 內(nèi)存塊的大小是 32 字節(jié)，而且我們從這里也可以看到我們所定義的內(nèi)存池本質(zhì)就是一個全局變量的數(shù)組，這個數(shù)組在編譯時，就被分配了一個固定大小的內(nèi)存，然后我們會編寫 malloc 函數(shù)往這個內(nèi)存池中去分配內(nèi)存，緊接著，為了使得程序更加簡潔，我們創(chuàng)建一個結(jié)構(gòu)體，用來存儲內(nèi)存管理的相關(guān)參數(shù)：

struct _m_mallco_dev
{
    void (*init)(void);          //初始化
    uint8_t (*perused)(void);    //內(nèi)存使用率
    uint8_t     *membase;        //內(nèi)存池 管理SRAMBANK個區(qū)域的內(nèi)存
    uint16_t *memmap;            //內(nèi)存管理狀態(tài)表
    uint8_t  memrdy;             //內(nèi)存管理是否就緒
}

可以看到這個結(jié)構(gòu)體包含了兩個函數(shù)指針，兩個指針，以及一個普通變量。有了結(jié)構(gòu)體類型之后，我們定義一個變量并初始化如下：

struct _m_mallco_dev mallco_dev=
{
    my_mem_init,                //內(nèi)存初始化
    my_mem_perused,             //內(nèi)存使用率
    mem1base,                   //內(nèi)存池
    mem1mapbase,                //內(nèi)存管理狀態(tài)表
    0,                          //內(nèi)存管理未就緒
};

可以看到對與初始化的結(jié)構(gòu)體變量來說，兩個函數(shù)指針，指向的分別是內(nèi)存初始化和內(nèi)存使用率函數(shù)，內(nèi)存使用率函數(shù)不在這里闡述了，需要了解的可以在公眾號底部回復(fù) 內(nèi)存管理獲得內(nèi)存管理源代碼進(jìn)行學(xué)習(xí)。這里闡述一下內(nèi)存初始化，回顧我們之前定義的內(nèi)存池，是一個全局變量的數(shù)組，因此，這里的初始化實際也就是對于全局?jǐn)?shù)組進(jìn)行賦 0 操作，代碼如下所示：

void my_mem_init(void)  
{  
    mymemset(mallco_dev.memmap, 0,memtblsize*2);//內(nèi)存狀態(tài)表數(shù)據(jù)清零  
    mymemset(mallco_dev.membase, 0,memsize);    //內(nèi)存池所有數(shù)據(jù)清零  
    mallco_dev.memrdy = 1;                      //內(nèi)存管理初始化OK  
}  

上述的 mymemset函數(shù)也不在這里闡述了，可以自行閱讀筆者在公眾號后天給出的源代碼，上述代碼功能也就是對內(nèi)存池和內(nèi)存管理表進(jìn)行賦 0 ，為什么賦 0 時內(nèi)存管理表的大小要乘以 2 ，是因為內(nèi)存管理表是的數(shù)據(jù)是 16 位的，而計算內(nèi)存管理表的大小時所依據(jù)的是 8 位的內(nèi)存池的數(shù)據(jù)。
有了初始化，我們就可以根據(jù)所要求獲取的內(nèi)存大小向內(nèi)存池獲取內(nèi)存了，下面是內(nèi)存分配的代碼實現(xiàn)：

uint32_t my_mem_malloc(uint32_t size)  
{  
    signed long offset=0;  
    uint32_t nmemb;    //需要的內(nèi)存塊數(shù)  
    uint32_t cmemb = 0;//連續(xù)空內(nèi)存塊數(shù)
    uint32_t i;  

    if (!mallco_dev.memrdy)
        mallco_dev.init();//未初始化,先執(zhí)行初始化 
    if (size == 0)
        return 0XFFFFFFFF;//不需要分配

    nmemb = size / memblksize;      //獲取需要分配的連續(xù)內(nèi)存塊數(shù)
    if (size % memblksize)
        nmemb ++;  
    for (offset = memtblsize-1; offset >= 0; offset--)//搜索整個內(nèi)存控制區(qū)  
    {     
        if (!mallco_dev.memmap[offset])
            cmemb++;//連續(xù)空內(nèi)存塊數(shù)增加
        else 
            cmemb = 0;                              //連續(xù)內(nèi)存塊清零
        if (cmemb == nmemb)                         //找到了連續(xù)nmemb個空內(nèi)存塊
        {
            for(i = 0; i < nmemb; i++)                      //標(biāo)注內(nèi)存塊非空 
            {  
                mallco_dev.memmap[offset+i] = nmemb;  
            }  
            return (offset*memblksize);//返回偏移地址  
        }
    }  
    return 0XFFFFFFFF;//未找到符合分配條件的內(nèi)存塊  
}  

上述代碼仔細(xì)閱讀也不難理解，總體來說，分配的過程最開始是檢查內(nèi)存池是否已經(jīng)初始化，如果沒有初始化，那么就進(jìn)行初始化，進(jìn)一步地就檢查所要分配的大小是否等于 0 ，如果等于0 ，那么就返回。接下來的就是根據(jù)要分配的內(nèi)存大小來計算所要分配的內(nèi)存塊數(shù)，最后，所要分配的內(nèi)存可能不足以需要一整個內(nèi)存塊了，但是不足的話仍舊以一個內(nèi)存塊來進(jìn)行計算，緊接著，就開始從內(nèi)存池的底部開始尋找空閑內(nèi)存塊，如果找到了，就將對應(yīng)的內(nèi)存管理表賦值成所要分配的內(nèi)存塊大小。最后，返回所分配的內(nèi)存在內(nèi)存池中的偏移。注意，到這里并沒有結(jié)束，返回的只是偏移，并不是我們所需要的地址，因此，我們還需要如下所示的一個函數(shù)：

void *mymalloc(uint32_t size)  
{  
    uint32_t offset;   
    offset = my_mem_malloc(size);              
    if (offset == 0XFFFFFFFF)
        return NULL;  
    else 
        return (void*)((uint32_t)mallco_dev.membase+offset);  
}  

上面這個函數(shù)就不在這里贅述了，其功能呢就是將在我們剛剛那個函數(shù)得到的偏移地址加上內(nèi)存池所在的地址就得到了我們分配的那個內(nèi)存的地址。

內(nèi)存釋放原理

當(dāng) p 申請的內(nèi)存用完，需要釋放的時候，調(diào)用 free 函數(shù)實現(xiàn)。free 函數(shù)先判斷 p 指向的內(nèi)存地址所對應(yīng)的內(nèi)存塊，然后找到對應(yīng)的內(nèi)存管理表項目，得到 p 所占用的內(nèi)存塊數(shù)目 m（內(nèi)存管理表項目的值就是所分配內(nèi)存塊的數(shù)目），將這 m 個內(nèi)存管理表項目的值都清零，標(biāo)記釋放，完成一次內(nèi)存釋放。這就是內(nèi)存釋放的原理，對應(yīng)的代碼如下所示：

uint8_t my_mem_free(uint32_t offset)  
{  
    int i;  
    if (!mallco_dev.memrdy)        //未初始化,先執(zhí)行初始化
    {
        mallco_dev.init();    
        return 1;                 //未初始化  
    }  
    if (offset < memsize)//偏移在內(nèi)存池內(nèi). 
    {  
        int index = offset/memblksize;         //偏移所在內(nèi)存塊號碼  
        int nmemb = mallco_dev.memmap[index];    //內(nèi)存塊數(shù)量
        for(i = 0; i < nmemb; i++)                          //內(nèi)存塊清零
        {  
            mallco_dev.memmap[index+i]=0;  
        }  
        return 0;  
    }
    else 
        return 2;//偏移超區(qū)了.  
}

通過上述代碼我們也可以知道關(guān)于內(nèi)存的釋放只需要將其內(nèi)存管理表的項置 0 就好，簡而言之，我們需要找到需要釋放的內(nèi)存所在的地址，然后根據(jù)內(nèi)存管理表的數(shù)值一次將內(nèi)存管理表的值進(jìn)行置 0 就完成了內(nèi)存的釋放，當(dāng)然，上述代碼也不是全部，釋放前我們需要知道釋放內(nèi)存在內(nèi)存池中的偏移，這部分代碼如下所示：

void myfree(void *ptr)  
{  
    uint32_t offset;   
    if(ptr==NULL)return;//地址為0.  
     offset=(uint32_t)ptr-(uint32_t)mallco_dev.membase;     
    my_mem_free(offset);    //釋放內(nèi)存      
} 

其中 ptr 就是要釋放的內(nèi)存的地址，然后在減去內(nèi)存池所在的地址，就可以得到要釋放的內(nèi)存在內(nèi)存池中的偏移。

總結(jié)

上述就是關(guān)于在裸機上實現(xiàn)的一個內(nèi)存管理，仔細(xì)來看實現(xiàn)原理其實挺簡單，關(guān)于這個例子，筆者覺得也僅僅是提供了一個關(guān)于內(nèi)存分配的一個思路，要真正的運用到實際中，還存在問題，在上述中的內(nèi)存分配中，在進(jìn)行分配時，當(dāng)要分配的大小小于一個內(nèi)存塊的大小時，直接采用的是分配一個內(nèi)存塊的大小，而在例子中定義的內(nèi)存塊大小是 32 K ，也就是說如果分配的內(nèi)存大小小于 32 K ，那就分配 32 K ，這樣是極其浪費的。如果把內(nèi)存塊定義的太小，那么相應(yīng)伴隨的又是內(nèi)存管理表數(shù)組的增大，也會增加對于 RAM 的消耗，所以總體來說上述的代碼存在著一些不完善，但是對于學(xué)習(xí)來說是極好的~