21ic电子技术开发论坛 › 单片机与嵌入式系统 › ChipON MCU › 单片机malloc，高效利用ram，不再有内存碎片 ...
返回列表 发新帖我要提问

[示例代码] 单片机malloc，高效利用ram，不再有内存碎片

[复制链接]
2656|15
 楼主| hudi008 发表于 2022-10-26 21:54 | 显示全部楼层 |阅读模式
RAM, 内存, 单片机

单片机应用中，malloc/free产生内存碎片的原因：

70.jpg

标准内存动态分配是动态链表进行管理。由于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来分配。

复制
  1. #include "mem_malloc.h"
    


  2. 

  3. static unsigned int sum = 0;
    

  4. static char                     mem[MEM_SIZE];
    


  5. 

  6. #define DEBUG_EN        0
    

  7. #define MEM_START       &mem[0]
    

  8. #define MEM_END         &mem[MEM_SIZE]  
    

  9. #define BLK_SIZE        sizeof(mem_block) 
    


  10. 

  11. void print_mem_info(void){
    

  12.         printf("------------mem_info--------------\n");
    

  13.         printf("sizeof(mem_block)=%d\n", BLK_SIZE);
    

  14.         printf("MEM_START = %d(0x%x)\n", (int)MEM_START, (int)MEM_START);
    

  15.         printf("MEM_END   = %d(0x%x)\n", (int)MEM_END, (int)MEM_END);
    

  16.         printf("MEM_SIZE  = %d(0x%x)\n", (int)MEM_SIZE, (int)MEM_SIZE);
    

  17.         printf("----------------------------------\n");
    

  18. }
    


  19. 

  20. void print_hex(char *data, int len){
    

  21.         for(int i=0; i<len; i++){
    

  22.                 printf("%02x ", (unsigned char)data[i]);
    

  23.                 if((i+1)%12 == 0)   printf("\n");
    

  24.         }
    

  25.         printf("\n");
    

  26. }
    


  27. 

  28. void print_mem_hex(int size){
    

  29.         print_hex(mem, size);
    

  30. }
    


  31. 

  32. int mem_malloc(unsigned int msize){
    

  33.         unsigned int all_size = msize + sizeof(mem_block);
    

  34.         mem_block tmp_blk;
    

  35.         if(msize == 0) return 0;
    

  36.         if(sum){
    

  37.                 mem_block *ptr_blk = (mem_block *)(MEM_START + BLK_SIZE*(sum-1));
    

  38.                 int free_blk = (char *)ptr_blk->mem_ptr-(MEM_START + BLK_SIZE*sum);
    

  39.                 if(all_size <= free_blk){
    

  40.                         tmp_blk.mem_ptr = ptr_blk->mem_ptr - msize;
    

  41.                         tmp_blk.mem_size = msize;
    

  42.                         tmp_blk.mem_index = ptr_blk->mem_index + 1;
    

  43.                         memcpy(MEM_START + BLK_SIZE*sum, &tmp_blk, BLK_SIZE);
    

  44.                         sum = sum + 1;
    

  45.                 #if DEBUG_EN
    

  46.                         printf("mem_ptr = 0x%x\n", (int)tmp_blk.mem_ptr);
    

  47.                         printf("mem_size = 0x%x\n", tmp_blk.mem_size);
    

  48.                         printf("mem_index = 0x%x\n", tmp_blk.mem_index);
    

  49.                 #endif
    

  50.                         return tmp_blk.mem_index;
    

  51.                 }
    

  52.         }else{
    

  53.                 if(all_size <= MEM_SIZE){
    

  54.                         tmp_blk.mem_ptr = MEM_END - msize;
    

  55.                         tmp_blk.mem_size = msize;
    

  56.                         tmp_blk.mem_index = 1;
    

  57.                         memcpy(MEM_START, &tmp_blk, BLK_SIZE);
    

  58.                         sum = 1;
    

  59.         #if DEBUG_EN
    

  60.                         printf("mem_ptr = 0x%x\n", (int)tmp_blk.mem_ptr);
    

  61.                         printf("mem_size = 0x%x\n", tmp_blk.mem_size);
    

  62.                         printf("mem_index = 0x%x\n", tmp_blk.mem_index);
    

  63.         #endif
    

  64.                         return 1;
    

  65.                 }
    

  66.         }
    

  67.         return 0;
    

  68. }
    


  69. 

  70. void *mem_buffer(int id){
    

  71.         for(int i=0; i<sum; i++){
    

  72.                 mem_block *ptr_blk = (mem_block *)(MEM_START + BLK_SIZE*i);
    

  73.                 if(id == ptr_blk->mem_index){
    

  74.                         return ptr_blk->mem_ptr;
    

  75.                 }
    

  76.         }
    

  77.         return NULL;
    

  78. }
    


  79. 

  80. void mem_free(int id){
    

  81.         for(int i=0; i<sum; i++){
    

  82.                 mem_block *ptr_blk = (mem_block *)(MEM_START + BLK_SIZE*i);
    

  83.                 if(id == ptr_blk->mem_index){
    

  84.                         mem_block *ptr_old;
    

  85.                         if(i != (sum-1)){
    

  86.                                 int offset = ptr_blk->mem_size;
    

  87.                                 int move_size = 0; 
    

  88.                                 int n = sum - i;
    

  89.                                 mem_block *ptr_tmp;
    

  90.                                 for(int j=1; j<n; j++){
    

  91.                                         ptr_tmp = (mem_block *)(MEM_START + BLK_SIZE*(i+j));
    

  92.                                         move_size += ptr_tmp->mem_size;
    

  93.                                 }
    

  94.                                 //memmove();
    

  95.                                 char *dst_addr = ptr_tmp->mem_ptr + move_size + offset - 1;
    

  96.                                 char *src_addr = ptr_tmp->mem_ptr + move_size - 1;
    

  97.                                 for(int j=move_size; j>0; j--){
    

  98.                                         *dst_addr-- = *src_addr--;
    

  99.                                 }
    

  100.                                 int len = dst_addr - src_addr + 1;
    

  101.                                 memset(src_addr, 0, len);
    

  102.                                 for(int j=0; j<(n-1); j++){
    

  103.                                         ptr_tmp = (mem_block *)(MEM_START + BLK_SIZE*(i+j));
    

  104.                                         ptr_old = (mem_block *)(MEM_START + BLK_SIZE*(i+j+1));
    

  105.                                         memcpy(ptr_tmp, ptr_old, BLK_SIZE);
    

  106.                                         ptr_tmp->mem_ptr += offset;
    

  107.                                 }
    

  108.                         }else{
    

  109.                                 ptr_old = (mem_block *)(MEM_START + BLK_SIZE*i);
    

  110.                                 memset(ptr_old->mem_ptr, 0, ptr_old->mem_size);
    

  111.                         }
    

  112.                         memset(ptr_old, 0, BLK_SIZE);
    

  113.                         sum = sum - 1;
    

  114.                         break; 
    

  115.                 }
    

  116.         }
    

  117. }

源码：https://github.com/chenqy2018/mem_malloc





回复

收藏 举报

相关帖子
lzbf 发表于 2022-11-1 09:38 | 显示全部楼层
c语言中malloc是什么?怎么用?
回复

收藏 举报

wwppd 发表于 2022-11-1 09:53 | 显示全部楼层
c++中malloc的含义与用法 具体点儿  
回复

收藏 举报

cemaj 发表于 2022-11-1 10:10 | 显示全部楼层
单片机malloc的size仅仅为申请内存字节大小，与申请内存块中存储的数据类型无关
回复

收藏 举报

sdlls 发表于 2022-11-1 10:35 | 显示全部楼层
如何自己编写malloc这个代码呢？
回复

收藏 举报

elsaflower 发表于 2022-11-1 11:10 | 显示全部楼层
malloc()之后,内核发生了什么?  
回复

收藏 举报

yeates333 发表于 2022-11-1 11:52 | 显示全部楼层
malloc 向系统申请分配指定size个字节的内存空间。
回复

收藏 举报

lzbf 发表于 2022-11-1 14:28 | 显示全部楼层
c语言中的malloc()包含在哪个库函数中
回复

收藏 举报

Henryko 发表于 2022-11-5 20:15 | 显示全部楼层
malloc 向系统申请分配指定size个字节的内存空间
回复

收藏 举报

tpgf 发表于 2022-11-7 10:30 | 显示全部楼层
malloc的全称是memory allocation，中文叫动态内存分配，用于申请一块连续的指定大小的内存块区域以void*类型返回分配的内存区域地址，当无法知道内存具体位置的时候，想要绑定真正的内存空间，就需要用到动态的分配内存。
回复

收藏 举报

heimaojingzhang 发表于 2022-11-7 10:41 | 显示全部楼层
malloc()用于单片机主要问题体现在容易产生内存碎片。
回复

收藏 举报

keaibukelian 发表于 2022-11-7 11:44 | 显示全部楼层
  内存碎片一般是由于空闲的连续空间比要申请的空间小，导致这些小内存块不能被利用.产生内存碎片的方法很简单，
  举个例：   
  假设有一块一共有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 11:55 | 显示全部楼层
本帖最后由 labasi 于 2022-11-7 13:28 编辑

和楼主同问
回复

收藏 举报

paotangsan 发表于 2022-11-7 12:08 | 显示全部楼层
alloc()函数其实就在内存中找一片指定大小的空间，然后将这个空间的首地址范围给一个指针变量，这里的指针变量可以是一个单独的指针，也可以是一个数组的首地址，这要看malloc()函数中参数size的具体内容。
回复

收藏 举报

renzheshengui 发表于 2022-11-7 13:06 | 显示全部楼层
malloc分配的内存空间在逻辑上连续的，而在物理上可以连续也可以不连续。
回复

收藏 举报

wakayi 发表于 2022-11-7 13:28 | 显示全部楼层
头文件：#include <malloc.h> 或 #include <alloc.h> (注意：alloc.h 与 malloc.h 的内容是完全一致的。)

功能：分配长度为num_bytes字节的内存块

说明：如果分配成功则返回指向被分配内存的指针，否则返回空指针NULL。

当内存不再使用时，应使用free()函数将内存块释放。
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

hudi008

253

主题

9898

帖子

11

粉丝
快速回复 在线客服 返回列表 返回顶部