关于在裸机上实现的一个内存管理讨论

概述

在计算机系统中，变量、中间数据一般存放在系统存储空间中，只有实际使用的时候才将他们从存储空间调入到中央处理器内部进行计算。通常存储空间分为两类：内部存储空间和外部存储空间。对于电脑来讲，内部存储空间就是电脑的内存，外部存储空间就是电脑的硬盘。而对于单片机来讲，内部存储就是 RAM ，随机存储器。外部存储可以理解为 flash ，掉电不丢失。该篇文章的主题，内存管理，主要讨论的是关于 RAM 的管理。
堆、栈和静态区

针对于 Cortex M3 内核的单片机简单的进行划分一下，大致可以分为三个部分：静态区，栈，堆。

• 静态区：保存全局变量和 static 变量(包括由 static 修饰的全局变量和局部变量)。静态区的内容在总个程序的生命周期内都存在，由编译器在编译的时候进行分配。
  
• 栈：保存局部变量。栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被销毁。其特点是效率高，但空间大小有限。
  
• 堆：由 malloc 函数分配的内存。其生命周期由 free 决定，在没有释放之前一直存下，知道程序结束。
  
  

内存碎片和内存泄漏

涉及到动态内存管理时，会触及到两个概念，一个就是内存碎片另一个就是内存泄漏，下面分别阐述着两个概念。
内存碎片

假设我现在有 16 个字节的空闲内存，如下图所示：

现在我使用 malloc 分配了四次内存，然后这 16 个字节的内存变成了这样：

然后，又使用 free 释放了三次内存，释放之后的内存空间是这样的：

在没有 MMU 的情况下，现在我准备用 malloc 一次性分配 12 个字节的内存空间，虽然上述 16 个字节的内存空间还剩下 13 个字节，但是却因为内存不是连续的，因此是不能够进行分配的，这也就是出现内存碎片的原因了。
内存泄漏

内存泄漏产生的原因是当分配时的内存已经不再使用了，但是却没有被释放掉，这个时候，导致内存不够用，这对于嵌入式设备这种内存极其有限的对象来说是极其有害的。因此，在使用 malloc时，要搭配着 free 来进行使用。
什么时候会使用到堆呢？

静态区，栈我们我们在编写程序的时候都会涉及到，定义一个全局变量，就存放在了静态区，在函数内部定义了一个局部变量，就存放在了栈，那堆呢？堆什么时候会使用到呢？假设现在有这样一个程序。

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三个字符串复制到 buffer 所在内存位置，但是这个时候，如果不给数组的元素分配一定大小的内存，那么可能就放不下拷贝进去的字符串，因此在往里面拷贝字符串时，应该提前开辟出一段内存空间出来，这个时候，就需要使用到 malloc 来进行内存分配，当然所对应的，当这个数组使用完之后，需要使用 free来将分配的内存释放掉，否则就会造成内存泄漏。
单片机如何进行分配内存

在上述介绍的分配内存中，都是使用 malloc来进行分配内存，然后使用 free 来进行释放内存，但是针对于单片机 RAM 如此紧缺的设备来讲，使用 C 标准库中的内存管理函数是不恰当的，存在着许多弊端，主要有以下几点：

• 他们的实现可能非常大，占据了相当大的一块代码空间
  
• 这两个函数会使得链接器配置得复杂
  
• 如果允许堆空间的生长方向覆盖其他变量的内存，他们会成为 debug 的灾难
  
  

基于此，正点原子的例程中给出了一种内存管理的方法：分块式内存管理，实现原理如下图所示：

简单说明一下，分块式内存管理由内存池和内存管理表构成。内存池被等分为 n 块，对应的内存管理表，大小也为 n。内存管理表的每一项对应着内存池的一块内存。之所以有内存表项的存在，是因为需要通过内存表项表征当前内存块有没有被占用，如果对应的内存块没有被占用，那么该表项值就为 0 ，非 0 表示该内存块已经被占用。如果某项值为 10，那么说明本项对应的内存块在内，总共分配了 10 个内存块给外部的某个指针。
内存分配原理

当指针 p 调用 malloc 申请内存的时候，先判断 p 要分配的内存块数(m)，然后从第 n 项开
始，向下查找，直到找到 m 块连续的空内存块（即对应内存管理表项为 0），然后将这 m 个内
存管理表项的值都设置为 m（标记被占用），最后，把最后的这个空内存块的地址返回指针 p，完成一次分配。注意，如果当内存不够的时候（找到最后也没找到连续的 m 块空闲内存），则返回 NULL 给 p，表示分配失败。基于此原理，我们来完成内存分配函数。
首先我们需要定义内存池的大小和内存表的大小：

#define MEM1_BLOCK_SIZE                        32             //内存块大小为32字节
#define MEM1_MAX_SIZE                        10*1024    //最大管理内存 10K
#define MEM1_ALLOC_TABLE_SIZE        MEM1_MAX_SIZE/MEM1_BLOCK_SIZE         //内存表大小  
  

上述中内存表的大小直接用内存池的大小除以内存块的大小是因为内存管理表和内存块一一对应的，内存块的数量也就等于内存池中内存块的数量。
有了内存池和内存管理表的大小，那么就可以定义内存池和内存管理表了，定义如下所示：

//内存池(32字节对齐)
__align(32) uint8_t mem1base[MEM1_MAX_SIZE];                                                                                                        //内部SRAM内存
//内存管理表
uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                                                                        //内部SRAM内存池MAP
//内存管理参数          
const uint32_t memtblsize = MEM1_ALLOC_TABLE_SIZE;    //内存表大小
const uint32_t memblksize = MEM1_BLOCK_SIZE;          //内存分块大小
const uint32_t memsize = MEM1_MAX_SIZE;                          //内存总大小
上述所定义的就是内存池和内存管理表的相关内容，关于内存池采用 32 个字节对齐是因为 内存块的大小是 32 字节，而且我们从这里也可以看到我们所定义的内存池本质就是一个全局变量的数组，这个数组在编译时，就被分配了一个固定大小的内存，然后我们会编写 malloc 函数往这个内存池中去分配内存，紧接着，为了使得程序更加简洁，我们创建一个结构体，用来存储内存管理的相关参数：

struct _m_mallco_dev
{
        void (*init)(void);                     //初始化
        uint8_t (*perused)(void);    //内存使用率
        uint8_t         *membase;             //内存池 管理SRAMBANK个区域的内存
        uint16_t *memmap;                          //内存管理状态表
        uint8_t  memrdy;                          //内存管理是否就绪
}
可以看到这个结构体包含了两个函数指针，两个指针，以及一个普通变量。有了结构体类型之后，我们定义一个变量并初始化如下：

struct _m_mallco_dev mallco_dev=
{
        my_mem_init,                                //内存初始化
        my_mem_perused,                                //内存使用率
        mem1base,                               //内存池
        mem1mapbase,                    //内存管理状态表
        0,                                                   //内存管理未就绪
};


可以看到对与初始化的结构体变量来说，两个函数指针，指向的分别是内存初始化和内存使用率函数，内存使用率函数不在这里阐述了，需要了解的可以在公众号底部回复 内存管理获得内存管理源代码进行学习。这里阐述一下内存初始化，回顾我们之前定义的内存池，是一个全局变量的数组，因此，这里的初始化实际也就是对于全局数组进行赋 0 操作，代码如下所示：

void my_mem_init(void)  
{  
    mymemset(mallco_dev.memmap, 0,memtblsize*2);//内存状态表数据清零  
        mymemset(mallco_dev.membase, 0,memsize);        //内存池所有数据清零  
        mallco_dev.memrdy = 1;                                            //内存管理初始化OK  
}  
上述的 mymemset函数也不在这里阐述了，可以自行阅读笔者在公众号后天给出的源代码，上述代码功能也就是对内存池和内存管理表进行赋 0 ，为什么赋 0 时内存管理表的大小要乘以 2 ，是因为内存管理表是的数据是 16 位的，而计算内存管理表的大小时所依据的是 8 位的内存池的数据。
有了初始化，我们就可以根据所要求获取的内存大小向内存池获取内存了，下面是内存分配的代码实现：

uint32_t my_mem_malloc(uint32_t size)  
{  
    signed long offset=0;  
    uint32_t nmemb;        //需要的内存块数  
        uint32_t cmemb = 0;//连续空内存块数
    uint32_t i;  
   
    if (!mallco_dev.memrdy)
            mallco_dev.init();//未初始化,先执行初始化
    if (size == 0)
            return 0XFFFFFFFF;//不需要分配
   
    nmemb = size / memblksize;          //获取需要分配的连续内存块数
    if (size % memblksize)
            nmemb ++;  
    for (offset = memtblsize-1; offset >= 0; offset--)//搜索整个内存控制区  
    {     
                if (!mallco_dev.memmap[offset])
                        cmemb++;//连续空内存块数增加
                else
                        cmemb = 0;                                                                //连续内存块清零
                if (cmemb == nmemb)                                                        //找到了连续nmemb个空内存块
                {
            for(i = 0; i < nmemb; i++)                                          //标注内存块非空
            {  
                mallco_dev.memmap[offset+i] = nmemb;  
            }  
            return (offset*memblksize);//返回偏移地址  
                }
    }  
    return 0XFFFFFFFF;//未找到符合分配条件的内存块  
}  


上述代码仔细阅读也不难理解，总体来说，分配的过程最开始是检查内存池是否已经初始化，如果没有初始化，那么就进行初始化，进一步地就检查所要分配的大小是否等于 0 ，如果等于0 ，那么就返回。接下来的就是根据要分配的内存大小来计算所要分配的内存块数，最后，所要分配的内存可能不足以需要一整个内存块了，但是不足的话仍旧以一个内存块来进行计算，紧接着，就开始从内存池的底部开始寻找空闲内存块，如果找到了，就将对应的内存管理表赋值成所要分配的内存块大小。最后，返回所分配的内存在内存池中的偏移。注意，到这里并没有结束，返回的只是偏移，并不是我们所需要的地址，因此，我们还需要如下所示的一个函数：

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);  
}  


上面这个函数就不在这里赘述了，其功能呢就是将在我们刚刚那个函数得到的偏移地址加上内存池所在的地址就得到了我们分配的那个内存的地址。
内存释放原理

当 p 申请的内存用完，需要释放的时候，调用 free 函数实现。free 函数先判断 p 指向的内存地址所对应的内存块，然后找到对应的内存管理表项目，得到 p 所占用的内存块数目 m（内存管理表项目的值就是所分配内存块的数目），将这 m 个内存管理表项目的值都清零，标记释放，完成一次内存释放。这就是内存释放的原理，对应的代码如下所示：

uint8_t my_mem_free(uint32_t offset)  
{  
    int i;  
    if (!mallco_dev.memrdy)        //未初始化,先执行初始化
        {
                mallco_dev.init();   
        return 1;                 //未初始化  
    }  
    if (offset < memsize)//偏移在内存池内.
    {  
        int index = offset/memblksize;             //偏移所在内存块号码  
        int nmemb = mallco_dev.memmap[index];        //内存块数量
        for(i = 0; i < nmemb; i++)                                                  //内存块清零
        {  
            mallco_dev.memmap[index+i]=0;  
        }  
        return 0;  
    }
    else
            return 2;//偏移超区了.  
}


通过上述代码我们也可以知道关于内存的释放只需要将其内存管理表的项置 0 就好，简而言之，我们需要找到需要释放的内存所在的地址，然后根据内存管理表的数值一次将内存管理表的值进行置 0 就完成了内存的释放，当然，上述代码也不是全部，释放前我们需要知道释放内存在内存池中的偏移，这部分代码如下所示：

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);        //释放内存      
}
其中 ptr 就是要释放的内存的地址，然后在减去内存池所在的地址，就可以得到要释放的内存在内存池中的偏移。
总结

上述就是关于在裸机上实现的一个内存管理，仔细来看实现原理其实挺简单，关于这个例子，笔者觉得也仅仅是提供了一个关于内存分配的一个思路，要真正的运用到实际中，还存在问题，在上述中的内存分配中，在进行分配时，当要分配的大小小于一个内存块的大小时，直接采用的是分配一个内存块的大小，而在例子中定义的内存块大小是 32 K ，也就是说如果分配的内存大小小于 32 K ，那就分配 32 K ，这样是极其浪费的。如果把内存块定义的太小，那么相应伴随的又是内存管理表数组的增大，也会增加对于 RAM 的消耗，所以总体来说上述的代码存在着一些不完善，但是对于学习来说是极好的~