STM32Fxx 内存管理

目录：

1.内存管理的原理

2.解析程序

3.程序（在stm32系列单片机开发中都可以使用）

内容：

一：内存管理的原理

内存管理，是指软件运行时对计算机内存资源的分配和使用。

内存管理的实现方法有很多种，他们其实最终都是要实现 2 个函数：malloc 函数（用于内存申请），free函数（ 用于内存释放）

本程序实现的是分块式内存管理。原理如下：

分块式内存管理由内存池和内存管理表两部分组成。内存池被等分为 n块，对应的内存管理表，大小也为 n，内存管理表的每一个项对应内存池的一块内存。

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

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

分配原理

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

释放原理

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

二、解析程序

1.内存管理控制器

struct _m_mallco_dev mallco_dev=

{

my_mem_init, //内存初始化

my_mem_perused, //内存使用率

mem1base,mem2base, //内存池

mem1mapbase,mem2mapbase, //内存管理状态表

0,0, //内存管理未就绪

};

2.内存管理初始化

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

}

3.内存分配(内部调用)

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;//未找到符合分配条件的内存块

}

4.分配内存(外部调用)

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

}

5.释放内存(内部调用)

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;//偏移超区了.

}

6.释放内存(外部调用)

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); //释放内存

}

三、程序

/*malloc.c*/

#include "malloc.h"

//内存池(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, //内存管理未就绪

};

void mymemcpy(void *des,void *src,u32 n)

{

u8 *xdes=des;

u8 *xsrc=src;

while(n--)*xdes++=*xsrc++;

}

void mymemset(void *s,u8 c,u32 count)

{

u8 *xs = s;

while(count--)*xs++=c;

}

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

}

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

}

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;//未找到符合分配条件的内存块

}

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;//偏移超区了.

}

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); //释放内存

}

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

}

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.h*/

#ifndef __MALLOC_H

#define __MALLOC_H

#ifndef NULL

#define NULL 0

#endif

//定义两个内存池

#define SRAMIN 0 //内部内存池

#define SRAMEX 1 //外部内存池

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

//mem1内存参数设定.mem1完全处于内部SRAM里面.

#define MEM1_BLOCK_SIZE 32 //内存块大小为32字节

#define MEM1_MAX_SIZE 10*1024 //最大管理内存 4K

#define MEM1_ALLOC_TABLE_SIZE MEM1_MAX_SIZE/MEM1_BLOCK_SIZE //内存表大小

//mem2内存参数设定.mem2的内存池处于外部SRAM里面

#define MEM2_BLOCK_SIZE 32 //内存块大小为32字节

#define MEM2_MAX_SIZE 800 *1024 //最大管理内存960K

#define MEM2_ALLOC_TABLE_SIZE MEM2_MAX_SIZE/MEM2_BLOCK_SIZE //内存表大小

//内存管理控制器

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里面定义

void mymemset(void *s,u8 c,u32 count); //设置内存

void mymemcpy(void *des,void *src,u32 n);//复制内存

void my_mem_init(u8 memx); //内存管理初始化函数(外/内部调用)

u32 my_mem_malloc(u8 memx,u32 size); //内存分配(内部调用)

u8 my_mem_free(u8 memx,u32 offset); //内存释放(内部调用)

u8 my_mem_perused(u8 memx); //获得内存使用率(外/内部调用)

//外部调用函数

void myfree(u8 memx,void *ptr); //内存释放(外部调用)

void *mymalloc(u8 memx,u32 size); //内存分配(外部调用)

void *myrealloc(u8 memx,void *ptr,u32 size);//重新分配内存(外部调用)

#endif