STM32 内存管理实验

参考原文《STM32F1开发指南》

内存管理简介

内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。最主要的目的是如何高效、快速的分配，并且在适当的时候释放和回收内存资源。内存管理的实现方法有很多种，但最终是要实现2个函数：malloc（内存申请）和free（内存释放）。

STM32 原子开发板采用的实现方法是：分块式内存管理。

分块式内存管理

分块式内存管理由内存池和内存管理表两部分组成。内存池和对应的内存表都分成n块，是相互对应的。

内存管理表的项值代表的意义为：当该项值为0的时候，代表对应的内存块未被占用。当该项值非零的时候，代表 该项对应的内存块已经被占用，其数值代表连续占用的内存块数。比如某项值为10，说明包含本项在内的内存块总共占用了10个分配给外部的某个指针。

内存分配方向如图所示，是从顶-->底的方向分配的。首先从顶端开始找空内存；当内存管理初始化的时候，内存表全部清零，表示没有任何内存块被占用。

分配原理

当指针 p 调用 malloc 申请内存的时候，先判断 p 要分配的内存块数m，然后从第 n 项开始，向下查找，直到找到m块连续的空内存块（即对应内存管理表项为0），然后将这 m 个内存管理表项的值都设置为 m（标记被占用），最后把这个空内存块的地址返回给指针p，完成一次分配。注意，当内存不够的时候，则返回 NULL 给 p，表示分配失败。

释放原理

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

源码

//内存池(32字节对齐)
__align(32) u8 mem1base[MEM1_MAX_SIZE];											//内部SRAM内存池
__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000)));					//外部SRAM内存池

//内存管理表
u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];											//内部SRAM内存池MAP
u16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE)));	//外部SRAM内存池MAP

//内存管理参数
const u32 memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE};			//内存表大小
const u32 memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE};						//内存分块大小
const u32 memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE};								//内存总大小

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

//复制内存
//*des:目的地址
//*src:源地址
//n:需要复制的内存长度(字节为单位)
void mymemcpy(void *des,void *src,u32 n)
{
    u8 *xdes=des;
    u8 *xsrc=src;
    while(n--)*xdes++=*xsrc++;
}  

//设置内存
//*s:内存首地址
//c :要设置的值
//count:需要设置的内存大小(字节为单位)
void mymemset(void *s,u8 c,u32 count)
{
    u8 *xs = s;
    while(count--)*xs++=c;
}
//内存管理初始化
//memx:所属内存块
void my_mem_init(u8 memx)
{
		mymemset(mallco_dev.memmap[memx], 0, memtblsize[memx]*2);//内存状态表数据清零
		mymemset(mallco_dev.membase[memx], 0,memsize[memx]);	//内存池所有数据清零
		mallco_dev.memrdy[memx]=1;								//内存管理初始化OK
}
//获取内存使用率
//memx:所属内存块
//返回值:使用率(0~100)
u8 my_mem_perused(u8 memx)
{
    u32 used=0;
    u32 i;
    for(i=0;i<memtblsize[memx];i++)
    {
        if(mallco_dev.memmap[memx][i])used++;
    }
    return (used*100)/(memtblsize[memx]);
}
//内存分配(内部调用)
//memx:所属内存块
//size:要分配的内存大小(字节)
//返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址
u32 my_mem_malloc(u8 memx,u32 size)
{
    signed long offset=0;
    u32 nmemb;	//需要的内存块数
    u32 cmemb=0;    //连续空内存块数
    u32 i;
    if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化
    if(size==0)return 0XFFFFFFFF;//不需要分配
    nmemb=size/memblksize[memx];  	//获取需要分配的连续内存块数
    if(size%memblksize[memx])nmemb++;
    for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区
    {
        if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加
        else cmemb=0;								//连续内存块清零

        if(cmemb==nmemb)						//找到了连续nmemb个空内存块
	{
            for(i=0;i<nmemb;i++)  					//标注内存块非空
            {
                mallco_dev.memmap[memx][offset+i]=nmemb;
            }
            return (offset*memblksize[memx]);//返回偏移地址
	}
    }  

    return 0XFFFFFFFF;//未找到符合分配条件的内存块
}
//释放内存(内部调用)
//memx:所属内存块
//offset:内存地址偏移
//返回值:0,释放成功;1,释放失败;
u8 my_mem_free(u8 memx,u32 offset)
{
    int i;
    if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化
    {
	mallco_dev.init(memx);
        return 1;//未初始化
    }  

    if(offset<memsize[memx])//偏移在内存池内.
    {
        int index=offset/memblksize[memx];			//偏移所在内存块号码
        int nmemb=mallco_dev.memmap[memx][index];	//内存块数量
        for(i=0;i<nmemb;i++)  						//内存块清零
        {
            mallco_dev.memmap[memx][index+i]=0;
        }
        return 0;
    }else return 2;//偏移超区了.
}  

//释放内存(外部调用)
//memx:所属内存块
//ptr:内存首地址
void myfree(u8 memx,void *ptr)
{
    u32 offset;
    if(ptr==NULL)return;//地址为0.
    offset=(u32)ptr-(u32)mallco_dev.membase[memx]; // 计算当前指针在内存块中的偏移地址
    my_mem_free(memx,offset);	//释放内存
}  

//分配内存(外部调用)
//memx:所属内存块
//size:内存大小(字节)
//返回值:分配到的内存首地址.
void *mymalloc(u8 memx,u32 size)
{
    u32 offset;
    offset=my_mem_malloc(memx,size);
    if(offset==0XFFFFFFFF)return NULL;
    else return (void*)((u32)mallco_dev.membase[memx]+offset);
}  

//重新分配内存(外部调用)
//memx:所属内存块
//*ptr:旧内存首地址
//size:要分配的内存大小(字节)
//返回值:新分配到的内存首地址.
void *myrealloc(u8 memx,void *ptr,u32 size)
{
    u32 offset;
    offset=my_mem_malloc(memx,size);
    if(offset==0XFFFFFFFF)return NULL;
    else
    {
        mymemcpy((void*)((u32)mallco_dev.membase[memx]+offset),ptr,size);	//拷贝旧内存内容到新内存
        myfree(memx,ptr);  											  		//释放旧内存
        return (void*)((u32)mallco_dev.membase[memx]+offset);  				//返回新内存首地址
    }
}

通过内存管理控制器 malloc_dev 结构体实现对两个内存池的管理控制。

//内存管理控制器
struct _m_mallco_dev
{
	void (*init)(u8);					//初始化
	u8 (*perused)(u8);		  	    	//内存使用率
	u8 	*membase[SRAMBANK];				//内存池 管理SRAMBANK个区域的内存
	u16 *memmap[SRAMBANK]; 				//内存管理状态表
	u8  memrdy[SRAMBANK]; 				//内存管理是否就绪
};
extern struct _m_mallco_dev mallco_dev;	 //在mallco.c里面定义

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

以下是内存池和内存管理表的定义：

//定义两个内存池
#define SRAMIN	 0		//内部内存池
#define SRAMEX   1		//外部内存池 

#define SRAMBANK 	2	//定义支持的SRAM块数.	

//mem1内存参数设定.mem1完全处于内部SRAM里面.
#define MEM1_BLOCK_SIZE			32  	  						//内存块大小为32字节
#define MEM1_MAX_SIZE			40*1024  						//最大管理内存 40K
#define MEM1_ALLOC_TABLE_SIZE	MEM1_MAX_SIZE/MEM1_BLOCK_SIZE 	//内存表大小

//mem2内存参数设定.mem2的内存池处于外部SRAM里面
#define MEM2_BLOCK_SIZE			32  	  						//内存块大小为32字节
#define MEM2_MAX_SIZE			960 *1024  						//最大管理内存960K
#define MEM2_ALLOC_TABLE_SIZE	MEM2_MAX_SIZE/MEM2_BLOCK_SIZE 	//内存表大小 

定义了两个内存池，一个是内部内存池，一个是外部内存池，在 mallo.c 文件中有对内存池的划分：

//内存池(32字节对齐)
__align(32) u8 mem1base[MEM1_MAX_SIZE];													//内部SRAM内存池
__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000)));					//外部SRAM内存池
//内存管理表
u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];													//内部SRAM内存池MAP
u16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE)));	//外部SRAM内存池MAP
//内存管理参数
const u32 memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE};			//内存表大小
const u32 memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE};						//内存分块大小
const u32 memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE};								//内存总大小

疑问外部内存池指定地址是 0X68000000，是从哪里得出来的这个地址？

内部内存则由编译器自动分配。

此部分代码的核心函数为 mem_malloc 和 mem_free，这两个函数只是内部调用，外部调用则使用 mymalloc 和 myfree 两个函数。

我的笔记###

必须要弄懂 malloc_dev 的定义，它在程序内部使用，对用户是透明的，必须要知道它管理这几块内存池，及其对应的管理表，弄懂 my_mem_malloc 和 my_mem_free 函数，这两个函数都是内部使用的。