整理了一份通用的内存管理驱动代码

malloc的全称是memory allocation，即动态内存分配，当无法知道内存具体位置的时候，想要绑定真正的内存空间的时候，就需要用到动态的分配内存。

可以说动态内存分配在嵌入式开发中是经常用到的，也是比较容易出错和被忽略的，经常忘了free，导致分配失败程序死机等等。

这里在工作的时候整理了一份通用的内存管理驱动代码。

一些基本定义

定义内存池(32字节对齐)

__align(32) u8 mem1base[MEM1_MAX_SIZE];             //内部SRAM内存池
__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0XC01F4000)));     //外部SDRAM内存池,前面2M给LTDC用了(1280*800*2)
__align(32) u8 mem3base[MEM3_MAX_SIZE] __attribute__((at(0X10000000)));     //内部CCM内存池

定义内存管理表

u32 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];             //内部SRAM内存池MAP
u32 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0XC01F4000+MEM2_MAX_SIZE))); //外部SRAM内存池MAP
u32 mem3mapbase[MEM3_ALLOC_TABLE_SIZE] __attribute__((at(0X10000000+MEM3_MAX_SIZE))); //内部CCM内存池MAP

定义内存管理参数

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

一个结构体来定义内存管理控制器

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

重写函数

需要复制的内存长度(字节为单位)，复制内存，重写一个memcpy

void mymemcpy(void *des,void *src,u32 n)  
{  
    u8 *xdes=des;
 u8 *xsrc=src; 
    while(n--)*xdes++=*xsrc++;  
}  

需要设置的内存大小(字节为单位)，设置内存，重写一个memset

void mymemset(void *s,u8 c,u32 count)  
{  
    u8 *xs = s;  
    while(count--)*xs++=c;  
} 

常用模块函数

获取内存使用率

u16 my_mem_perused(u8 memx)  
{  
    u32 used=0;  
    u32 i;  
    for(i=0;i    {  
        if(mallco_dev.memmap[memx][i])used++; 
    } 
    return (used*1000)/(memtblsize[memx]);  
} 

内存分配(内部调用)

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            {  
                mallco_dev.memmap[memx][offset+i]=nmemb;  
            }  
            return (offset*memblksize[memx]);//返回偏移地址  
  }
    }  
    return 0XFFFFFFFF;//未找到符合分配条件的内存块  
}  

释放内存

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

当然也可以把上面的函数封装为外部调用的，方便使用，比如重新分配内存(外部调用)

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);      //返回新内存首地址
    }  
}