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

malloc的全称是”memory allocation”，即动态内存分配。当无法事先确定内存位置时，可以使用动态分配内存的方式来绑定真实的内存空间。

动态内存分配在嵌入式开发中经常被使用，但也容易出错或被忽略。有时会忘记释放已分配的内存，导致程序出现内存泄漏或崩溃等问题。

在工作中，我整理了一份通用的内存管理驱动代码。

一些基本定义

我们定义了一个内存池，并将其对齐到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;iif(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;ireturn (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(offsetfor(i=0;ireturn 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);      //返回新内存首地址
    }  
}

以上就是良许教程网为各位朋友分享的Linu系统相关内容。想要了解更多Linux相关知识记得关注公众号“良许Linux”，或扫描下方二维码进行关注，更多干货等着你 ！