内存管理详解
1、介绍
内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。
内存管理的实现方法有很多种，他们其实最终都是要实现 2 个函数： malloc 和 free； malloc 函数用于内存申请， free 函数用于内存释放。
介绍一种简单的实现方法，分块式内存管理：
原理：
malloc分析
首先确定要开辟的内存大小n,从表的最后向前找n个空单元，找到后将其对应的内存地址返回，那么[p,p+n]就是空闲的n个单元。
free函数
free函数不是真的将内存数据清0，而是将其内存管理表清0，表示没有被占用，可以用作开辟内存。
程序理解
//---------------------By xiaowei
/*
头文件，定义了内存池开辟的地址，内存块大小和数目等；
*/
//---------------------
#ifndef _malloc_H
#define _malloc_H
#include "system.h"
#ifndef NULL
#define NULL 0
#endif
//定义2个内存池
#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 //内存表大小，此处为1280，代表有多少块内存;
//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 //内存表大小，此处大小30720
//内存管理控制器 函数指针
struct malloc_cortol_struct
{
void (*init)(u8); //初始化，函数入口指针
u8 (*perused)(u8); //内存使用率，带返回值函数入口指针
u8 *membase[SRAMBANK]; //内存池 管理SRAMBANK个区域的内存，是内存池的入口地址
u16 *memmap[SRAMBANK]; //内存管理状态表，内存管理表的地址
u8 memrdy[SRAMBANK]; //内存管理是否就绪
};
extern struct malloc_cortol_struct malloc_cortol; //在mallco.c里面定义
void my_mem_set(void *s,u8 c,u32 num) ; //设置内存
void my_mem_cpy(void *des,void *src,u32 len) ;//复制内存
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 *paddr) ; //内存释放(外部调用)
void *mymalloc(u8 memx,u32 size); //内存分配(外部调用)
void *myrealloc(u8 memx,void *paddr,u32 size) ;//重新分配内存(外部调用)
#endif
//---------------------By xiaowei
/*
此代码为.c文件，内部为具体内存实现；
*/
//---------------------
#include "malloc.h"
//内存池(32字节对齐)
__align(32) u8 mem1base[MEM1_MAX_SIZE]; //内部SRAM内存池，数组个数40K，类型U8
//使用的FSMC的bank1,区域3,
__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000))); //外部SRAM内存池,绝对位置定位;
//内存管理表
u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE]; //内部SRAM内存池MAP，数组数量为内存块个数，类型U16
u16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE))); //外部SRAM内存池MAP，在开辟的内存后，开辟内存块个数个u16类型
//内存管理参数
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 malloc_cortol_struct malloc_cortol=
{
my_mem_init, //内存初始化
my_mem_perused, //内存使用率
mem1base,mem2base, //内存池，把内存池的地址赋值给.membase
mem1mapbase,mem2mapbase,//内存管理状态表,把状态表地址赋值给.memmap
0,0, //内存管理未就绪
};
//复制内存
//*des:目的地址
//*src:源地址
//len:需要复制的内存长度(字节为单位)
void my_mem_cpy(void *des,void *src,u32 len)
{
u8 *xdes=des;
u8 *xsrc=src;
while(len--)*xdes++=*xsrc++;
}
//设置内存
//*s:内存首地址
//c :要设置的值
//num:需要设置的内存大小(字节为单位)
void my_mem_set(void *s,u8 c,u32 num)
{
u8 *xs = s;
while(num--)*xs++=c;
}
//内存管理初始化
//memx:所属内存块
//memx取值为SRAMIN(0),或SRAMEX(1)，表示对内部或外部SRAM初始化
void my_mem_init(u8 memx)
{ //内存表基地址 设置的值
//这里为什么要*2：内存表是u16类型的数组，而my_mem_set中xs是u8类型，每次擦除一位，擦除完状态表需要擦两次
my_mem_set(malloc_cortol.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零
my_mem_set(malloc_cortol.membase[memx], 0,memsize[memx]); //内存池所有数据清零
malloc_cortol.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++)
{
//memmap[memx]是内存表数组;
if(malloc_cortol.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 xmemb; //需要的内存块数
u32 kmemb=0;//连续空内存块数
u32 i;
if(!malloc_cortol.memrdy[memx])malloc_cortol.init(memx);//未初始化,先执行初始化
if(size==0)return 0XFFFFFFFF;//不需要分配
xmemb=size/memblksize[memx]; //获取需要分配的连续内存块数
if(size%memblksize[memx])xmemb++; //如果所需内存不够一块，则取一块
for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区
{
if(!malloc_cortol.memmap[memx][offset])kmemb++;//连续空内存块数增加
else kmemb=0; //连续内存块清零
if(kmemb==xmemb) //找到了连续nmemb个空内存块
{
for(i=0;i<xmemb;i++) //标注内存块非空
{
malloc_cortol.memmap[memx][offset+i]=xmemb;
}
return (offset*memblksize[memx]);//返回偏移地址
}
}
return 0XFFFFFFFF;//未找到符合分配条件的内存块
}
//释放内存(内部调用)
//memx:所属内存块
//offset:内存地址偏移
//返回值:0,释放成功;1,释放失败;
u8 my_mem_free(u8 memx,u32 offset)
{
int i;
if(!malloc_cortol.memrdy[memx])//未初始化,先执行初始化
{
malloc_cortol.init(memx);
return 1;//未初始化
}
if(offset<memsize[memx])//偏移在内存池内.
{
int index=offset/memblksize[memx]; //偏移所在内存块号码
int nmemb=malloc_cortol.memmap[memx][index]; //内存块数量
for(i=0;i<nmemb;i++) //内存块清零
{
malloc_cortol.memmap[memx][index+i]=0;
}
return 0;
}else return 2;//偏移超区了.
}
//释放内存(外部调用)
//memx:所属内存块
//ptr:内存首地址
void myfree(u8 memx,void *paddr)
{
u32 offset;
if(paddr==NULL)return;//地址为0.
offset=(u32)paddr-(u32)malloc_cortol.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)malloc_cortol.membase[memx]+offset);
} //基地址+偏移地址
//重新分配内存(外部调用)
//memx:所属内存块
//*ptr:旧内存首地址
//size:要分配的内存大小(字节)
//返回值:新分配到的内存首地址.
void *myrealloc(u8 memx,void *paddr,u32 size)
{
u32 offset;
offset=my_mem_malloc(memx,size);
if(offset==0XFFFFFFFF)return NULL;
else
{
my_mem_cpy((void*)((u32)malloc_cortol.membase[memx]+offset),paddr,size); //拷贝旧内存内容到新内存
myfree(memx,paddr); //释放旧内存
return (void*)((u32)malloc_cortol.membase[memx]+offset); //返回新内存首地址
}
}
程序知识点
动态内存开辟的原理就是先开辟一个大块内存，作为动态开辟的区间；将开辟的空间划分为内存区和管理区；
内存区就是用来开辟数组的地方，管理区就是存放管理表，即内存块信息的地方；
开辟内存的方法，就是找到一块连续的足够大的空间，将其首地址传回来。
而释放内存的方法是将内存信息管理表清空，而非物理清0；
1、attribute((at(0X68000000)))
在本处，使用了两部分内存，一部分是32内部自带的内存，__align(32) u8 mem1base[MEM1_MAX_SIZE];，这部分由编译器随机分配出来。
另一部分使用外部扩展的SRAM，需要强制从SRAM里开辟出内存来，
__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000)));
这段程序就是在SRAM内部开辟内存，并保证数据32字节对齐；
2、__align(n)
1.__align(num)
这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
对齐,但是不能让4字节的对象2字节对齐。
__align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
3、SRAM地址
为什么定位到at(0X68000000)
SRAM使用FSMC进行控制，FSMC分为四个区，这里使用的是NOR/SRAM去区，即BANK1，区域3。对应地址是6800 0000-6BFF FFFF，因此绝对定位到6800 0000；
4、内部内存大小
stm32是32位单片机，其可寻址范围为2^32为4G，但是其物理内存大小与芯片的类型有关。具体为STM32F103RBT6,其中B代表128K字节内部Flash容量。
5、外部内存大小
stm32外扩内存芯片为IS62WV51216，存储容量为16位宽512K的芯片，即512K*2个字节，1M字节容量。