内存管理实验_STM32F1开发指南_第四十二章

来源：互联网发布：微信可以打开淘宝编辑：程序博客网时间：2024/05/21 15:39

第四十二章内存管理实验

序言

本章将学习内存管理，实现对内存的动态管理。

本章分为如下几部分：

42.1 内存管理简介

42.2 硬件设计

42.3 软件设计

42.4 下载验证

42.1 内存管理简介

内存管理是什么？

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

内存管理的目的是什么？

高效、快速地分配，并且在适当的时候释放和回收内存资源。

内存管理的实现方法是什么？

有很多，但最终都是实现两个函数：

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个内存管理表项目的值清零，标记释

放，完成一次内存释放。

42.2 硬件设计

本章实验功能简介：

① 开机后，显示提示信息，等待外部输入。

② KEY0用于申请内存，每次申请2k字节内存。KEY1用于写数据到申请的内存里面。KEY2用于

释放内存。WK_UP用于切换操作内存区(内部内存/外部内存)。DS0用于指示程序运行状态。

③ 本章还可以通过USMART调试，测试内存管理函数。

本实验用到的硬件资源：

1）指示灯DS0；

2）四个按键；

3）串口；

4）TFTLCD模块；

5）IS62WV51216

42.3 软件设计

本章，我们将内存管理部分单独做一个分组，在工程目录下新建一个MALLOC文件夹，

然后在其下面新建malloc.c和malloc.h两个文件。

malloc.h文件代码如下：

#ifndef __MALLOC_H#define __MALLOC_H#ifndef NULL#defein 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             40*1024                         //最大管理内存 40k#define MEM1_MALLOC_TABLE_SIZE    MEM1_MAX_SIZE/MEM1_BLOCK_SIZE   //内存表的大小//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     //内存表的大小//内存管理控制器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;          //在malloc.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 size);             //内粗释放(内部调用)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

分析：从上面可以看出，如果内存分块越小，那么内存管理表就越大，当分块为2字节1个块的

时候，内存管理表就和内存池一样大了(管理表的每项都是u16类型)。显然是不合适的，我们

这里取32字节，比例为1：16，内存管理表相对就比较小了。

mallco.c文件代码如下：

.h"//内存池(4字节对齐)__align(4) u8 mem1base[MEM1_MAX_SIZE];                                    //内部SRAM内存池(掉电丢失)__align(4) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0x68000000)));    //外部SRAM内存池(掉电丢失)//1.内存管理表u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                    //内部SRAM内存池MAPu16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0x68000000 + MEM2_MAX_SIZE)));    //外部SRAM内存池MAP//2.内存管理参数const u32 memblsize[2] = {MEM1_ALLOC_TABLE_SIZE, MEM2_ALLOC_TABLE_SIZE};    //内存表的大小const u32 memblksize[2] = {MEM1_BLOCK_SIZE, MEM2_BLOCK_SIZE};               //内存分块大小const u32 memsize[2] = {MEM1_MAX_SIZE, MEM2_MAX_SIZE};                      //内存总大小//3.内存管理控制器struct _m_mallco_dev mallco_dev = {    mem_init,                 //内存初始化    mem_perused,              //内存使用率    mem1base, mem2base,       //内存池    mem1mapbase, mem2mapbase, //内存管理状态表    0， 0，                    //内存管理未就绪};//4.复制内存/*入  参： *des:目的地址；*src:源地址；n:需要复制的内存长度返回值：无*/void mymemcpy(void * des, void *src, u32 n){    u8 * xdes = des;    u8 * xsrc = src;}//5.设置内存/*入  参：*s：内存首地址； c：要设置的值；count：需要设置的内存的大小(字节为单位)返回值：无*/void mymemset(void *s, u8 c, u32 count){    u8 * xs = s;    while(count--)    {        *xs++ = c;    }}//6.内存管理初始化/*入  参：memx：所属内存块返回值：无*/void 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}//7.获得内存使用率/*入  参：memx：所属内存块返回值：使用率(0~100)*/u8 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]);}//8.内存分配(内部调用)/*入  参：memx：所属内存块；size：所要分配的内存的大小(字节)返回值：0xffff ffff表示错误，其他，内存偏移地址*/u32 mem_malloc(u8 memx, u32 size){    signed long offset = 0;    u16 nmemb;              //需要的内存块数    u16 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++)  //标注内存块非空            {                malloc_dev.memmap[memx][offset + i] = nmemb;            }            return (offset * memblksize[memx]);    //返回偏移地址        }    }    return 0xffffffff;    //未找到符合分配条件的内存块}//9.释放内存(内部调用)/*入  参：memx：所属内存块；offset:内存地址偏移返回值：0：释放成功；1：释放失败*/u8 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;  //偏移超区了    }}//10.释放内存(外部调用)/*入  参：memx：所属内存块；ptr:内存首地址返回值：无*/void myfree(u8 memx, void *ptr){    u32 offset;    if(ptr == NULL)        return;                //地址为0    offset = (u32)ptr - (u32)mallco_dev.membase[memx];    mem_free(memx, offset);    //释放内存}//11.分配内存(外部调用)/*入  参：memx：所属内存块；size:内存大小(字节)返回值：分配到的内存首地址*/void * mymalloc(u8 memx, u32 size){    u32 offset;    offset = mem_malloc(memx, size);    if(offset == 0xffffffff)        return NULL;    else        return (void *)((u32)mallco_dev.membase[memx] + offset);}//12.重新分配内存(外部调用)/*入  参：memx:所属内存块；*ptr:旧内存首地址；size：要分配的内存大小(字节)返回值：新分配到内存首地址*/void *myrealloc(u8 memx, void *ptr, u32 size){    u32 offset;    offset = 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);               //返回新内存首地址    }}

这里，通过内存管理控制器mallco_dev结构体，实现对两个内存池的管理控制。

一个是内部SRAM内存池，定义为：

__align(32) u8 mem1base[MEM1_MAX_SIZE];

另一个是外部SRAM内存池，定义为：

__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0x68000000)));

其中，MEM1_MAX_SIZE和MEM2_MAX_SIZE为内存池的大小，外部内存池指定地址为0x68000000，

即从外部SRAM首地址开始，内部内存则由编译器自动分配。__align(32)定义内存池为32字节对齐，以

适应各种不同场合的需求。

此部分代码核心函数为:mem_malloc和mem_free，分别用于内存申请和释放。不过这两个函数都只是

内部调用，外部调用我们使用mymalloc和myfree两个函数。

main.c文件代码如下：

int main(void){    u8 key;    u8 i = 0;    u8 *p = 0;    u8 *tp = 0;    u8 paddr[18];     //存放paddr+p地址的ASCII值    u8 sramx = 0;    //默认为内部sram    delay_init();        //延时函数初始化    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置中断优先级分组为组2    uart_init(115200);       //串口初始化为115200    LED_init();    KEY_init();    LCD_init();    FSMC_SRAM_Init();           //初始化外部SRAM    my_mem_init(SRAMIN);     //初始化内部内存池    my_mem_init(SRAMEX);    //初始化外部内存池    while()   {       key = KEY_Scan(0);        //不支持连按       switch(key)       {            case 0:                          //没有按键按下                break;            case KEY0_PRES:        //KEY0按下               p = mymalloc(sramx, 2048);    //申请2k字节               if(p != NULL)                    sprintf((char*)p, "Memory Malloc Test%03d", i);    //向p写入一些内容                break;            case KEY2_PRES:        //KEY2按下                myfree(sramx, p);        //释放内存                p = 0;                break;            case WKUP_PRES:        //KEY_UP按下                sramx = !sramx;           //切换当前malloc/free操作对象                break;       }       if(tp != p)       {            tp = p;            sprintf((char*)paddr, "paddr:0x%08x", (u32)tp);       }       delay_ms(10);       i++;       if((i%20) == 0)    //DS0闪烁       {           LED0 = !LED0;       }   }}

这部分代码比较简单，主要是对mymalloc和myfree的调用。不过要注意，申请的内存，在用完后

一定要释放。否则多次申请未释放，会造成“内存泄漏”，久而久之，导致无内存可用。

另外本章希望利用USMART调用内存管理，所以在USMART里面添加mymalloc和myfree两个函数，

用于测试内存分配和内存释放。