内存管理
内存管理是计算机系统中重要的一个方面，它涉及到如何有效地分配、使用和释放计算机的内存资源。内存管理的主要目标是优化内存使用，确保程序能够在需要时访问到足够的内存，并在不再需要时及时释放已经使用的内存，以提高系统的性能、稳定性和安全性。主要可以分为以下几个方面：内存分配和释放、内存保护、内存碎片管理、虚拟内存管理、内存优化。
在嵌入式学习中，或者说STM32的学习中，我们只需要掌握简单的内存的分配和释放，即malloc和free即可。那么就会有人问了：为什么不直接使用<stdlib.h>，这不直接省事了，就像这样：
#include <stdlib.h>
int main() {
// 使用malloc动态分配内存
int *ptr = (int*)malloc(sizeof(int) * 10);
// 省略其它代码
// 释放内存
free(ptr);
return 0;
}
原因如下：总结下来，就是C库的内存释放和分配对于嵌入式芯片来说太过于庞大，占用大量系统资源，与其占用这些系统资源，还不如不进行内存分配。。。。
分块式内存管理
所以，在嵌入式系统中，我们往往会自己去实现简单的内存分配和释放，常用的方法叫做分块式内存管理。
具体实现原理如下：
- 首先会在单片机的RAM里面创建一个内存池，其中分为很多个大小一定的内存块，
- 接着会有一个内存管理表记录内存池的分配和释放情况，
- 每一个内存块在内存管理表都会有一个对应的项记录其使用情况。
- 当内存管理表的某一项为非0时，表示该项对应的内存块被分配。
- 内存管理表某一项值为X时，表示在该项开始，由顶向底的X块内存被占用。
- 当内存管理表的某一项值0时，表示该项对应的内存块被释放。
举个栗子：
内存管理表的第10项大小为5，共有32项：说明内存池中第5个到10个内存块被分配。
具体分配和释放原则如下：
代码实现
以下的代码来着正点原子提供的官方源码，经部分改动，用于适用STM32F103RCT6芯片，不带外部SRAM
- malloc.c
具体实现方法，感兴趣的自己去看代码，都有注释，很详细，我就不做介绍了。
#include "malloc.h"
//
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK NANO STM32开发板
//内存管理 驱动代码
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//修改日期:2018/3/27
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2018-2028
//All rights reserved
//
//内存池(4字节对齐)
__align(4) uint8_t membase[MEM_MAX_SIZE]; //SRAM内存池
//内存管理表
uint16_t memmapbase[MEM_ALLOC_TABLE_SIZE]; //SRAM内存池MAP
//内存管理参数
const uint32_t memtblsize=MEM_ALLOC_TABLE_SIZE; //内存表大小
const uint32_t memblksize=MEM_BLOCK_SIZE; //内存分块大小
const uint32_t 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,uint32_t n)
{
uint8_t *xdes=des;
uint8_t *xsrc=src;
while(n--)*xdes++=*xsrc++;
}
//设置内存
//*s:内存首地址
//c :要设置的值
//count:需要设置的内存大小(字节为单位)
void mymemset(void *s,uint8_t c,uint32_t count)
{
uint8_t *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)
uint8_t mem_perused(void)
{
uint32_t used=0;
uint32_t i;
for(i=0;i<memtblsize;i++)
{
if(mallco_dev.memmap[i])used++;
}
return (used*100)/(memtblsize);
}
//内存分配(内部调用)
//memx:所属内存块
//size:要分配的内存大小(字节)
//返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址
uint32_t mem_malloc(uint32_t size)
{
signed long offset=0;
uint16_t nmemb; //需要的内存块数
uint16_t cmemb=0;//连续空内存块数
uint32_t 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,释放失败;
uint8_t mem_free(uint32_t 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)
{
uint32_t offset;
if(ptr==NULL)return;//地址为0.
offset=(uint32_t)ptr-(uint32_t)mallco_dev.membase;
mem_free(offset); //释放内存
}
//分配内存(外部调用)
//size:内存大小(字节)
//返回值:分配到的内存首地址.
void *mymalloc(uint32_t size)
{
uint32_t offset;
offset=mem_malloc(size);
if(offset==0XFFFFFFFF)return NULL;
else return (void*)((uint32_t)mallco_dev.membase+offset);
}
//重新分配内存(外部调用)
//*ptr:旧内存首地址
//size:要分配的内存大小(字节)
//返回值:新分配到的内存首地址.
void *myrealloc(void *ptr,uint32_t size)
{
uint32_t offset;
offset=mem_malloc(size);
if(offset==0XFFFFFFFF)return NULL;
else
{
mymemcpy((void*)((uint32_t)mallco_dev.membase+offset),ptr,size); //拷贝旧内存内容到新内存
myfree(ptr); //释放旧内存
return (void*)((uint32_t)mallco_dev.membase+offset); //返回新内存首地址
}
}
- malloc.h
#ifndef __MALLOC_H
#define __MALLOC_H
#include "main.h"
//
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK NANO STM32开发板
//内存管理 驱动代码
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//修改日期:2018/3/27
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2018-2028
//All rights reserved
//
#ifndef NULL
#define NULL 0
#endif
//内存参数设定.
#define MEM_BLOCK_SIZE 32 //内存块大小为32字节
#define MEM_MAX_SIZE 10*1024 //最大管理内存10K
#define MEM_ALLOC_TABLE_SIZE MEM_MAX_SIZE/MEM_BLOCK_SIZE //内存表大小,指的是内存表内的内存块数，这里有320个内存块
//内存管理控制器
struct _m_mallco_dev
{
void (*init)(void); //初始化
unsigned char (*perused)(void); //内存使用率
unsigned char *membase; //内存池
uint16_t *memmap; //内存管理状态表
unsigned char memrdy; //内存管理是否就绪
};
extern struct _m_mallco_dev mallco_dev; //在mallco.c里面定义
void mymemset(void *s,unsigned char c,uint32_t count); //设置内存
void mymemcpy(void *des,void *src,uint32_t n);//复制内存
void mem_init(void); //内存管理初始化函数(外/内部调用)
uint32_t mem_malloc(uint32_t size); //内存分配(内部调用)
unsigned char mem_free(uint32_t offset); //内存释放(内部调用)
unsigned char mem_perused(void); //得内存使用率(外/内部调用)
//用户调用函数
void myfree(void *ptr); //内存释放(外部调用)
void *mymalloc(uint32_t size); //内存分配(外部调用)
void *myrealloc(void *ptr,uint32_t size); //重新分配内存(外部调用)
#endif
- 使用例程：
void Proc1sTask(void) //1s任务
{
uint8_t paddr[20]; /* 存放P Addr:+p地址的ASCII值 */
uint8_t *p = 0;
if(Get_1s_Flag() == 1) //获取1s标志位
{
Clear_1s_Flag(); //清除1s标志位
//1stask code
p = mymalloc(2048); //申请2K字节
if (p != NULL)sprintf((char *)p, "Memory Malloc 2048Byte"); //向p写入一些内容
printf("\r\nSRAM USED:%d%%\r\n", mem_perused()); //显示内存使用率
sprintf((char *)paddr, "P Addr:0X%08X", (uint32_t)p);
printf("%s\r\n", paddr); //显示p的地址
myfree(p); //释放内存
p = 0; //指向空地址
printf("\r\nSRAM USED:%d%%\r\n", mem_perused()); //显示内存使用率
}
}
这里我是直接放在main.cl里面的1s函数，运行结果如下图：
运行结果
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
