malloc.c正点原子编写内存管理的学习笔记

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

上来的第一个点就是对齐问题，align(m)即这个地址值一定是m的整数倍。并且其占用的空间，即大小,也是m的整数倍。 为啥要对齐呢？我简单的理解一下就是单片机一次想取4字节的大小的数，如果变量地址是4的整数倍呢，那单片机就取一次就够了，如果变量地址不是4的整数倍呢，那单片机就得取两次，效率低了。

内存池是由内存块组成，此处内存块大小是32B，内存管理表的大小是内存池的大小除以内存块的大小，即MEM1_ALLOC_TABLE_SIZE = MEM1_MAX_SIZE/MEM1_BLOCK_SIZE;那么当MEM1_BLOCK_SIZE等于1B的时候，内存池就和内存管理表一样大了。在这个例子中，内存池大小是100K，而内存管理表大小为100K/32B = 3200B，也就是3K多。
//内存管理表
u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE]; //内部SRAM内存池MAP
u16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] attribute((at(0X68000000+MEM2_MAX_SIZE))); //外部SRAM内存池MAP
u16 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
{
void (*init)(u8); //初始化，这个是函数指针，以后填函数名称
u8 (*perused)(u8); //内存使用率，这个是函数指针，以后填函数名称
u8 *membase[SRAMBANK]; //内存池 ，这是个指针数组，以后填数组名
u16 *memmap[SRAMBANK]; //内存管理状态表 ，这是个指针数组，以后填数组名
u8 memrdy[SRAMBANK]; //内存管理是否就绪
};
****************************************************************/
填好了就是下面这个样子了。
//内存管理控制器
struct _m_mallco_dev mallco_dev=
{
my_mem_init, //内存初始化
my_mem_perused, //内存使用率
mem1base,mem2base,mem3base, //内存池
mem1mapbase,mem2mapbase,mem3mapbase,//内存管理状态表
0,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时，那么这个函数应该改写为
void my_mem_init(0)
{ //乘2是因为数组里的数据是16位的
mymemset(mem1mapbase, 0,MEM1_ALLOC_TABLE_SIZE2);//内存状态表数据清零
mymemset(mem1base, 0,MEM1_MAX_SIZE); //内存池所有数据清零
mallco_dev.memrdy[0]=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 (used100)/(memtblsize[memx]);
}
/
我给他改写一下，当参数memx=0时，那么这个函数应该改写为
u8 my_mem_perused(0)
{
u32 used=0;
u32 i;
for(i=0;i<MEM1_ALLOC_TABLE_SIZE;i++)
{
if(mem1mapbase[i])used++;
//这句话意思就是说这个内存表中的第i项如果不等于0，说明已经用了
}
return (used100)/(MEM1_ALLOC_TABLE_SIZE);
}
*************************************************************************/

//内存分配(内部调用)
//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(size0)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(cmembnmemb) //找到了连续nmemb个空内存块
{
for(i=0;i<nmemb;i++) //标注内存块非空
{
mallco_dev.memmap[memx][offset+i]=nmemb;
}
return (offset*memblksize[memx]);//返回偏移地址
}
}
return 0XFFFFFFFF;//未找到符合分配条件的内存块
}

/************************************************************************
我给他改写一下，当参数memx=0时，那么这个函数应该改写为
u32 my_mem_malloc(0,u32 size)
{
signed long offset=0;
u32 nmemb; //需要的内存块数
u32 cmemb=0;//连续空内存块数
u32 i;
if(!mallco_dev.memrdy[0])mallco_dev.init(0);//未初始化,先执行初始化
if(size0)return 0XFFFFFFFF;//不需要分配
nmemb=size/MEM1_BLOCK_SIZE; //获取需要分配的连续内存块数
if(size%MEM1_BLOCK_SIZE)nmemb++;
for(offset=MEM1_ALLOC_TABLE_SIZE-1;offset>=0;offset–)//搜索整个内存控制区 ，从顶向底的分配方向
{
if(!mem1mapbase[offset])cmemb++;//连续空内存块数增加
else cmemb=0; //连续内存块清零
if(cmembnmemb) //找到了连续nmemb个空内存块
{
for(i=0;i<nmemb;i++) //标注内存块非空
{
mem1mapbase[offset+i]=nmemb; //把连续的内存管理表的项都赋值为nmemb
}
return (offset*MEM1_BLOCK_SIZE);//返回偏移地址
}
}
return 0XFFFFFFFF;//未找到符合分配条件的内存块
}

不用指针感觉看着清晰了！！！！！我再画张图

*************************************************************************/

//释放内存(内部调用)
//memx:所属内存块
//offset:内存地址偏移
//返回值:0,释放成功;1,释放失败;
//直接把参数memx改成0
u8 my_mem_free(u8 memx,u32 offset)
{
int i;
if(!mallco_dev.memrdy[0])//未初始化,先执行初始化
{
mallco_dev.init(0);
return 1;//未初始化
}
if(offset<MEM1_MAX_SIZE)//偏移在内存池内.
{
int index=offset/MEM1_BLOCK_SIZE; //偏移所在内存块号码
int nmemb=mem1mapbase[index]; //内存块数量
for(i=0;i<nmemb;i++) //内存块清零
{
mem1mapbase[index+i]=0;
}
return 0;
}else return 2;//偏移超区了.
}

//释放内存(外部调用)
//memx:所属内存块
//ptr:内存首地址
//直接把参数memx改成0
void myfree(0,void *ptr)
{
u32 offset;
if(ptr==NULL)return;//地址为0.
offset=(u32)ptr-(u32)mem1base;
my_mem_free(0,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);
}