STM32学习笔记一一内存管理

版权声明：原创文章转载请注明出处。 https://blog.csdn.net/wwt18811707971/article/details/80503420

1.简介

内存管理：指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。 内存管理的实现方法有很多种，最终都是要实现两个函数： malloc 和 free。

malloc ：函数用于内存申请；
free： 函数用于内存释放。

1.1 分块式内存管理原理

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

内存管理表的项值代表的意义：当该项值为 0 的时候，代表对应的内存块未被占用；当该项值非零的时候，代表该项对应的内存块已经被占用，其数值则代表被连续占用的内存块数。

比如：某项值为 10，那么说明包括本项对应的内存块在内，总共分配了 10 个内存块给外部的某
个指针。内寸分配方向如图所示，是从顶—>底的分配方向。即首先从最末端开始找空内存。当内存管理刚初始化的时候，内存表全部清零，表示没有任何内存块被占用。

1.2 分配原理

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

注：如果当内存不够的时候（找到最后也没找到连续的 m 块空闲内存），则返回 NULL 给 p，表示分配失败。

1.2 释放原理

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

2.软件分析

头文件:

#ifndef __MALLOC_H
#define __MALLOC_H
#include "stm32f10x.h"

#ifndef NULL
#define NULL 0
#endif

//内存参数设定.
#define MEM_BLOCK_SIZE          32                              //内存块大小为32字节
#define MEM_MAX_SIZE            42*1024                         //最大管理内存 42K
#define MEM_ALLOC_TABLE_SIZE    MEM_MAX_SIZE/MEM_BLOCK_SIZE     //内存表大小


//内存管理控制器
struct _m_mallco_dev
{
    void (*init)(void);             //初始化
    u8 (*perused)(void);            //内存使用率
    u8  *membase;                   //内存池 
    u16 *memmap;                    //内存管理状态表
    u8  memrdy;                     //内存管理是否就绪
};
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 mem_init(void);                     //内存管理初始化函数(外/内部调用)
u32 mem_malloc(u32 size);               //内存分配(内部调用)
u8 mem_free(u32 offset);                //内存释放(内部调用)
u8 mem_perused(void);                   //得内存使用率(外/内部调用) 
////////////////////////////////////////////////////////////////////////////////
//用户调用函数
void myfree(void *ptr);                 //内存释放(外部调用)
void *mymalloc(u32 size);               //内存分配(外部调用)
void *myrealloc(void *ptr,u32 size);    //重新分配内存(外部调用)
#endif

参考例程：

#include "malloc.h"     

//内存池(4字节对齐)
__align(4) u8 membase[MEM_MAX_SIZE];            //SRAM内存池
//内存管理表
u16 memmapbase[MEM_ALLOC_TABLE_SIZE];           //SRAM内存池MAP
//内存管理参数       
const u32 memtblsize=MEM_ALLOC_TABLE_SIZE;      //内存表大小
const u32 memblksize=MEM_BLOCK_SIZE;            //内存分块大小
const u32 memsize=MEM_MAX_SIZE;                 //内存总大小


//内存管理控制器
struct _m_mallco_dev mallco_dev=
{
    mem_init,           //内存初始化
    mem_perused,        //内存使用率
    membase,            //内存池
    memmapbase,         //内存管理状态表
    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;  
}      
//内存管理初始化  
void mem_init(void)  
{  
    mymemset(mallco_dev.memmap, 0,memtblsize*2);//内存状态表数据清零  
    mymemset(mallco_dev.membase, 0,memsize);    //内存池所有数据清零  
    mallco_dev.memrdy=1;                        //内存管理初始化OK  
}  
//获取内存使用率
//返回值:使用率(0~100)
u8 mem_perused(void)  
{  
    u32 used=0;  
    u32 i;  

    for(i=0;i<memtblsize;i++)  
    {  
        if(mallco_dev.memmap[i])
            used++; 
    } 
    return (used*100)/(memtblsize);  
}  
//内存分配(内部调用)
//memx:所属内存块
//size:要分配的内存大小(字节)
//返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址 
u32 mem_malloc(u32 size)  
{  
    signed long offset=0;  
    u16 nmemb;  //需要的内存块数  
    u16 cmemb=0;//连续空内存块数
    u32 i;  

    if(!mallco_dev.memrdy)
        mallco_dev.init();  //未初始化,先执行初始化 
    if(size==0)
        return 0XFFFFFFFF;              //不需要分配
    nmemb=size/memblksize;                      //获取需要分配的连续内存块数
    if(size%memblksize)
        nmemb++;  
    for(offset=memtblsize-1;offset>=0;offset--) //搜索整个内存控制区  
    {     
        if(!mallco_dev.memmap[offset])
            cmemb++;    //连续空内存块数增加
        else 
            cmemb=0;                            //连续内存块清零
        if(cmemb==nmemb)                        //找到了连续nmemb个空内存块
        {
            for(i=0;i<nmemb;i++)                //标注内存块非空 
            {  
                mallco_dev.memmap[offset+i]=nmemb;  
            }  
            return (offset*memblksize);         //返回偏移地址  
        }
    }  
    return 0XFFFFFFFF;//未找到符合分配条件的内存块  
}  
//释放内存(内部调用) 
//offset:内存地址偏移
//返回值:0,释放成功;1,释放失败;  
u8 mem_free(u32 offset)  
{  
    int i;  
    if(!mallco_dev.memrdy)//未初始化,先执行初始化
    {
        mallco_dev.init();    
        return 1;//未初始化  
    }  
    if(offset<memsize)//偏移在内存池内. 
    {  
        int index=offset/memblksize;        //偏移所在内存块号码  
        int nmemb=mallco_dev.memmap[index]; //内存块数量
        for(i=0;i<nmemb;i++)                //内存块清零
        {  
            mallco_dev.memmap[index+i]=0;  
        }
        return 0;  
    }
    else
        return 2;//偏移超区了.  
}  
//释放内存(外部调用) 
//ptr:内存首地址 
void myfree(void *ptr)  
{  
    u32 offset;  
    if(ptr==NULL)
        return;//地址为0.  
    offset=(u32)ptr-(u32)mallco_dev.membase;  
    mem_free(offset);   //释放内存     
}  
//分配内存(外部调用)
//size:内存大小(字节)
//返回值:分配到的内存首地址.
void *mymalloc(u32 size)  
{  
    u32 offset;     

    offset=mem_malloc(size);                       
    if(offset==0XFFFFFFFF)
        return NULL;  
    else 
        return (void*)((u32)mallco_dev.membase+offset);  
}  
//重新分配内存(外部调用)
//*ptr:旧内存首地址
//size:要分配的内存大小(字节)
//返回值:新分配到的内存首地址.
void *myrealloc(void *ptr,u32 size)  
{  
    u32 offset;  

    offset=mem_malloc(size);  
    if(offset==0XFFFFFFFF)
        return NULL;     
    else  
    {                                      
        mymemcpy((void*)((u32)mallco_dev.membase+offset),ptr,size); //拷贝旧内存内容到新内存   
        myfree(ptr);                                                //释放旧内存
        return (void*)((u32)mallco_dev.membase+offset);             //返回新内存首地址
    }  
}

主函数测试：

#include "led.h"
#include "delay.h"
#include "sys.h"
#include "usart.h"
#include "lcd.h"
#include "key.h"
#include "malloc.h" 
#include "usmart.h" 

 int main(void)
 { 
    u8 key;      
    u8 i=0;     
    u8 *p=0;
    u8 *tp=0;
    u8 paddr[18];           //存放P Addr:+p地址的ASCII值 

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2
    delay_init();            //延时函数初始化    
    uart_init(9600);        //串口初始化为9600
    LED_Init();             //初始化与LED连接的硬件接口
    LCD_Init();             //初始化LCD    
    usmart_dev.init(72);    //初始化USMART 
    KEY_Init();             //按键初始化   
    mem_init();             //初始化内存池

    POINT_COLOR=RED;//设置字体为红色 
    LCD_ShowString(60,50,200,16,16,"Mini STM32");   
    LCD_ShowString(60,70,200,16,16,"MALLOC TEST");  
    LCD_ShowString(60,90,200,16,16,"ATOM@ALIENTEK");
    LCD_ShowString(60,110,200,16,16,"2014/3/12");  
    LCD_ShowString(60,130,200,16,16,"KEY0:Malloc");
    LCD_ShowString(60,150,200,16,16,"KEY1:Write Data");
    LCD_ShowString(60,170,200,16,16,"WK_UP:Free");

    POINT_COLOR=BLUE;//设置字体为蓝色  
    LCD_ShowString(60,190,200,16,16,"SRAM USED:   %");  
    while(1)
    {   
        key=KEY_Scan(0);//不支持连按 
        switch(key)
        {
            case 0:     //没有按键按下    
                break;
            case 1:     //KEY0按下
                p=mymalloc(2048);   //申请2K字节
                if(p!=NULL)
                    sprintf((char*)p,"Memory Malloc Test%03d",i);//向p写入一些内容
                break;
            case 2:     //KEY1按下       
                if(p!=NULL)
                {
                    sprintf((char*)p,"Memory Malloc Test%03d",i);//更新显示内容    
                    LCD_ShowString(60,250,200,16,16,p);          //显示P的内容
                }
                break;
            case 3:     //WK_UP按下     
                myfree(p);  //释放内存
                p=0;        //指向空地址
                break; 
        }
        if(tp!=p)
        {
            tp=p;
            sprintf((char*)paddr,"P Addr:0X%08X",(u32)tp);
            LCD_ShowString(60,230,200,16,16,paddr); //显示p的地址
            if(p)LCD_ShowString(60,250,200,16,16,p);//显示P的内容
            else LCD_Fill(60,250,239,266,WHITE);    //p=0,清除显示
        }
        delay_ms(10);   
        i++;
        if((i%20)==0)//DS0闪烁.
        {
            LCD_ShowNum(60+80,190,mem_perused(),3,16);//显示内存使用率
            LED0=!LED0;
        }
    }          
}

---

参考：

1.原子库函数教程

2.STM32-内存管理