cortex_m3_stm32嵌入式学习笔记（二十四）：内存管理实验（动态内存）

有用过C语言编程的童鞋对动态管理内存肯定有点了解。。好处就不多说了今天实现STM32的动态内存管理

内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。内存管理的实现方法有很多种，他们其实最终都是要实现两个函数：malloc 和 free（好熟悉）； 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 个内存管理表项目的值都清零，标记释放，完成一次内存释放。

代码：外用两个函数 mymalloc(int size) 参数为申请内存的大小，返回申请的内存的首地址，若申请失败则返回NULL；

myfree（void *p）释放p为首的指针；

malloc.h

#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

malloc.c

#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_Configuration();
	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,"[email protected]");
	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;
 		}
	}
}

时间： 2024-10-08 20:14:22

cortex_m3_stm32嵌入式学习笔记（二十四）：内存管理实验（动态内存）

cortex_m3_stm32嵌入式学习笔记（二十四）：内存管理实验（动态内存）的相关文章

cortex_m3_stm32嵌入式学习笔记（十四）：RTC实时时钟（秒中断）

Android学习笔记二十四之ListView列表视图二

马哥学习笔记二十四——分布式复制快设备drbd

angular学习笔记(二十四)-$http(2)-设置http请求头

（转）【D3D11游戏编程】学习笔记二十四：切线空间（Tangent Space）

cortex_m3_stm32嵌入式学习笔记（十二）：TFTLCD显示（深入库函数）

cortex_m3_stm32嵌入式学习笔记（十九）：DMA实验（高速传输）

[傅里叶变换及其应用学习笔记] 二十四. 级联，脉冲响应

Android学习笔记二十四.Service入门(二)绑定本地Service并与之通信

Java基础学习笔记二十四 MySQL安装图解