单片机malloc，高效利用ram，不再有内存碎片
单片机应用中，malloc/free产生内存碎片的原因：标准内存动态分配是动态链表进行管理。由于malloc返回的是一个指针再加上单片机没有mmu，使得分配的指针就像一个个钉子钉在内存中了。这就导致内存管理非常困难，从而产生我们常说的内存碎片。我们来举一个极端的例子，导致大量内存碎片：1. 单片机的RAM为1Kbyte，为了说明和计算方便我们忽略掉链表占用的空间，只计算实际存储空间大小。2. 申请64块内存空间，每块是16字节，那么就会分配完1k字节的空间。即：for(int i=0; i<64; i++){
ptr = malloc(16);
}3. 然后释放掉偶数块内存空间，即：
for(int i=0; i<64; i+=2){
free(ptr );
}4. 于是我们释放掉了一半的RAM空间，即有512字节的空间，但是都是非连续的。32块16字节的非连续空间，所以要分配出大于16字节的内存块是分配不出来的。有512字节的空间但只能分配小于16字节的连续空间(除非使用calloc分配非连续空间)，在某些场合原本单片机RAM空间就很急，再加上这种不充分的使用使得程序稳定性大打折扣。鉴于各中原因本人自己编写了一个内存管理，适合单片机使用的内存管理分配。算法原理：
定义一个数组作为动态分配的堆空间，低地址空间保存管理数据，高地址空间实际分配给用户的缓存(类似堆栈使用，分配是往中间靠拢)，free时移动高地址用户空间(以时间换空间)，腾出多余未使用的空间，等待malloc来分配。#include "mem_malloc.h"
static unsigned int sum = 0;
static char mem;
#define DEBUG_EN 0
#define MEM_START &mem
#define MEM_END &mem
#define BLK_SIZE sizeof(mem_block)
void print_mem_info(void){
printf("------------mem_info--------------\n");
printf("sizeof(mem_block)=%d\n", BLK_SIZE);
printf("MEM_START = %d(0x%x)\n", (int)MEM_START, (int)MEM_START);
printf("MEM_END = %d(0x%x)\n", (int)MEM_END, (int)MEM_END);
printf("MEM_SIZE= %d(0x%x)\n", (int)MEM_SIZE, (int)MEM_SIZE);
printf("----------------------------------\n");
}
void print_hex(char *data, int len){
for(int i=0; i<len; i++){
printf("%02x ", (unsigned char)data);
if((i+1)%12 == 0) printf("\n");
}
printf("\n");
}
void print_mem_hex(int size){
print_hex(mem, size);
}
int mem_malloc(unsigned int msize){
unsigned int all_size = msize + sizeof(mem_block);
mem_block tmp_blk;
if(msize == 0) return 0;
if(sum){
mem_block *ptr_blk = (mem_block *)(MEM_START + BLK_SIZE*(sum-1));
int free_blk = (char *)ptr_blk->mem_ptr-(MEM_START + BLK_SIZE*sum);
if(all_size <= free_blk){
tmp_blk.mem_ptr = ptr_blk->mem_ptr - msize;
tmp_blk.mem_size = msize;
tmp_blk.mem_index = ptr_blk->mem_index + 1;
memcpy(MEM_START + BLK_SIZE*sum, &tmp_blk, BLK_SIZE);
sum = sum + 1;
#if DEBUG_EN
printf("mem_ptr = 0x%x\n", (int)tmp_blk.mem_ptr);
printf("mem_size = 0x%x\n", tmp_blk.mem_size);
printf("mem_index = 0x%x\n", tmp_blk.mem_index);
#endif
return tmp_blk.mem_index;
}
}else{
if(all_size <= MEM_SIZE){
tmp_blk.mem_ptr = MEM_END - msize;
tmp_blk.mem_size = msize;
tmp_blk.mem_index = 1;
memcpy(MEM_START, &tmp_blk, BLK_SIZE);
sum = 1;
#if DEBUG_EN
printf("mem_ptr = 0x%x\n", (int)tmp_blk.mem_ptr);
printf("mem_size = 0x%x\n", tmp_blk.mem_size);
printf("mem_index = 0x%x\n", tmp_blk.mem_index);
#endif
return 1;
}
}
return 0;
}
void *mem_buffer(int id){
for(int i=0; i<sum; i++){
mem_block *ptr_blk = (mem_block *)(MEM_START + BLK_SIZE*i);
if(id == ptr_blk->mem_index){
return ptr_blk->mem_ptr;
}
}
return NULL;
}
void mem_free(int id){
for(int i=0; i<sum; i++){
mem_block *ptr_blk = (mem_block *)(MEM_START + BLK_SIZE*i);
if(id == ptr_blk->mem_index){
mem_block *ptr_old;
if(i != (sum-1)){
int offset = ptr_blk->mem_size;
int move_size = 0;
int n = sum - i;
mem_block *ptr_tmp;
for(int j=1; j<n; j++){
ptr_tmp = (mem_block *)(MEM_START + BLK_SIZE*(i+j));
move_size += ptr_tmp->mem_size;
}
//memmove();
char *dst_addr = ptr_tmp->mem_ptr + move_size + offset - 1;
char *src_addr = ptr_tmp->mem_ptr + move_size - 1;
for(int j=move_size; j>0; j--){
*dst_addr-- = *src_addr--;
}
int len = dst_addr - src_addr + 1;
memset(src_addr, 0, len);
for(int j=0; j<(n-1); j++){
ptr_tmp = (mem_block *)(MEM_START + BLK_SIZE*(i+j));
ptr_old = (mem_block *)(MEM_START + BLK_SIZE*(i+j+1));
memcpy(ptr_tmp, ptr_old, BLK_SIZE);
ptr_tmp->mem_ptr += offset;
}
}else{
ptr_old = (mem_block *)(MEM_START + BLK_SIZE*i);
memset(ptr_old->mem_ptr, 0, ptr_old->mem_size);
}
memset(ptr_old, 0, BLK_SIZE);
sum = sum - 1;
break;
}
}
}源码：https://github.com/chenqy2018/mem_malloc
c语言中malloc是什么?怎么用? c++中malloc的含义与用法 具体点儿 单片机malloc的size仅仅为申请内存字节大小，与申请内存块中存储的数据类型无关 如何自己编写malloc这个代码呢？ malloc()之后,内核发生了什么? malloc 向系统申请分配指定size个字节的内存空间。 c语言中的malloc()包含在哪个库函数中 malloc 向系统申请分配指定size个字节的内存空间 malloc的全称是memory allocation，中文叫动态内存分配，用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址，当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存。 malloc()用于单片机主要问题体现在容易产生内存碎片。 内存碎片一般是由于空闲的连续空间比要申请的空间小，导致这些小内存块不能被利用.产生内存碎片的方法很简单，
举个例：
假设有一块一共有100个单位的连续空闲内存空间，
范围是0~99.如果你从中申请一块内存，如10个单位，
那么申请出来的内存块就为0~9区间.这时继续申请一块内存，
比如说5个单位大，第二块得到的内存块就应该为10~14区间.
如果把第一块内存块释放，然后再申请一块大于10个单位的内存块，
比如说20个单位.因为刚被释放的内存块不能满足新的请求，
所以只能从15 开始分配出20个单位的内存块.现在整个内存空间的状态是0~9空闲，
10~14被占用，15~24被占用，25~99空闲。
其中0~9就是一个内存碎片了.如果10~14一直被占用，
而以后申请的空间都大于10个单位，那么0~9就永远用不上了，
造成内存浪费.
本帖最后由 labasi 于 2022-11-7 13:28 编辑
和楼主同问 alloc()函数其实就在内存中找一片指定大小的空间，然后将这个空间的首地址范围给一个指针变量，这里的指针变量可以是一个单独的指针，也可以是一个数组的首地址，这要看malloc()函数中参数size的具体内容。 malloc分配的内存空间在逻辑上连续的，而在物理上可以连续也可以不连续。 头文件：#include <malloc.h> 或 #include <alloc.h> (注意：alloc.h 与 malloc.h 的内容是完全一致的。)
功能：分配长度为num_bytes字节的内存块
说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。
当内存不再使用时，应使用free()函数将内存块释放。
页:
[1]