一个简单而强大的单片机内存管理器-不带内存碎片整理

单片机简单内存管理器

本代码基于无操作系统的STM32单片机开发，功能强大，可申请到地址空间连续的不同大小的内存空间，且用户接口简单，使用方便

转载请注明出处：http://blog.csdn.net/u011833609/article/details/46834203

memory.h

[cpp]  view plain  copy

 print ?

1. #ifndef __MEMORY_H__  
2. #define __MEMORY_H__  
3.   
4. #include "stdio.h"  
5. #include "string.h"  
6. #include "includes.h"  
7. //用户使用  
8. typedef struct  
9. {  
10.     void    *addr;      //申请到的内存的起始地址  
11.     uint32_t size;      //申请到的内存的大小，按照块大小分配，大于等于申请大小  
12.     uint16_t  tb;        //申请表序号，申请内存时分配，释放内存时使用，用户不使用  
13. }DMEM;  
14.   
15. //若返回空，则申请失败  
16. DMEM *DynMemGet(uint32_t size);  
17.   
18. void DynMemPut(DMEM *pDmem);  
19.   
20.   
21. #endif //__MEMORY_H__  

memory.c

[html]  view plain  copy

 print ?

1. #include "memory.h"  
2.   
3. #define DMEM_BLOCK_SIZE         256      //内存块大小为128字节  
4. #define DMEM_BLOCK_NUM          20       //内存块个数为40个  
5. #define DMEM_TOTAL_SIZE         (DMEM_BLOCK_SIZE*DMEM_BLOCK_NUM)    //内存总大小  
6.   
7. typedef enum  
8. {  
9.     DMEM_FREE   = 0,  
10.     DMEM_USED   = 1,  
11. }DMEM_USED_ITEM;  
12.   
13. typedef struct  
14. {  
15.     DMEM_USED_ITEM   used;       //使用状态  
16.     uint16_t         blk_s;      //起始块序号  
17.     uint16_t         blk_num;    //块个数  
18. }DMEM_APPLY;  
19.   
20. typedef struct  
21. {  
22.     DMEM_USED_ITEM  tb_blk[DMEM_BLOCK_NUM];  
23.     DMEM            tb_user[DMEM_BLOCK_NUM];        //用户申请内存信息  
24.     DMEM_APPLY      tb_apply[DMEM_BLOCK_NUM];       //系统分配内存信息  
25.     uint16_t        apply_num;      //内存申请表占用数目  
26.     uint16_t        blk_num;        //内存块占用数目  
27. }DMEM_STATE;  
28.   
29. static uint8_t DMEMORY[DMEM_TOTAL_SIZE];  
30. static DMEM_STATE DMEMS = {0};  

[html]  view plain  copy

 print ?

1. DMEM *DynMemGet(uint32_t size)  
2. {  
3.     uint16_t loop = 0;  
4.     uint16_t find = 0;  
5.     uint16_t blk_num_want = 0;  
6.     DMEM * user = NULL;  
7.     DMEM_APPLY *apply = NULL;  
8.       
9.     //申请内存大小不能为0  
10.     if(size == 0)               {   return NULL;    }  
11.     //申请内存不可超过总内存大小  
12.     if(size > DMEM_TOTAL_SIZE)  {   return NULL;    }  
13.     //申请内存不可超过剩余内存大小  
14.     if(size > (DMEM_BLOCK_NUM - DMEMS.blk_num) * DMEM_BLOCK_SIZE)   {   return NULL;    }  
15.     //申请表必须有空余  
16.     if(DMEMS.apply_num >= DMEM_BLOCK_NUM)   {   return NULL;    }  
17.       
18.     //计算所需连续块的个数  
19.     blk_num_want = (size + DMEM_BLOCK_SIZE - 1) / DMEM_BLOCK_SIZE;  
20.       
21.     //寻找申请表  
22.     for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)  
23.     {  
24.         if(DMEMS.tb_apply[loop].used == DMEM_FREE)  
25.         {  
26.             apply = &DMEMS.tb_apply[loop];                  //申请表已找到  
27.             user = &DMEMS.tb_user[loop];                    //用户表对应找到  
28.             user->tb = loop;                                //申请表编号记录  
29.             user->size = blk_num_want * DMEM_BLOCK_SIZE;    //分配大小计算  
30.             break;  
31.         }  
32.     }  
33.       
34.     //没有找到可用申请表，理论上是不会出现此现象的，申请表剩余已在上面校验  
35.     if(loop == DMEM_BLOCK_NUM)  {   return NULL;    }  
36.       
37.     //寻找连续内存块  
38.     for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)  
39.     {  
40.         if(DMEMS.tb_blk[loop] == DMEM_FREE)  
41.         {//找到第一个空闲内存块  
42.             for(find = 1; (find < blk_num_want) && (loop + find < DMEM_BLOCK_NUM); find ++)  
43.             {//找到下一个空闲内存块  
44.                 if(DMEMS.tb_blk[loop + find] != DMEM_FREE)  
45.                 {//发现已使用内存块  
46.                     break;  
47.                 }  
48.             }  
49.             if(find >= blk_num_want)  
50.             {//寻找到的空闲内存块数目已经够用  
51.                 user->addr = DMEMORY + loop * DMEM_BLOCK_SIZE;  //计算申请到的内存的地址  
52.                 apply->blk_s = loop;                            //记录申请到的内存块首序号  
53.                 apply->blk_num = blk_num_want;                  //记录申请到的内存块数目  
54.                 for(find = 0 ; find < apply->blk_num; find++)  
55.                 {  
56.                     DMEMS.tb_blk[loop + find] = DMEM_USED;  
57.                 }  
58.                 apply->used = DMEM_USED;                        //标记申请表已使用  
59.                 DMEMS.apply_num += 1;  
60.                 DMEMS.blk_num += blk_num_want;  
61.                   
62.                 return user;  
63.             }  
64.             else  
65.             {//寻找到的空闲内存块不够用，从下一个开始找  
66.                 loop += find;  
67.             }  
68.         }  
69.     }  
70.       
71.     //搜索整个内存块，未找到大小适合的空间  
72.     return NULL;  
73. }  
74.   
75. void DynMemPut(DMEM *user)  
76. {  
77.     uint16_t loop = 0;  
78.     //若参数为空，直接返回  
79.     if(NULL == user)    {   return; }  
80.       
81.     //释放内存空间  
82.     for(loop = DMEMS.tb_apply[user->tb].blk_s; loop < DMEMS.tb_apply[user->tb].blk_s + DMEMS.tb_apply[user->tb].blk_num; loop++)  
83.     {  
84.         DMEMS.tb_blk[loop] = DMEM_FREE;  
85.         DMEMS.blk_num -= 1;  
86.     }  
87.     //释放申请表  
88.     DMEMS.tb_apply[user->tb].used = DMEM_FREE;  
89.     DMEMS.apply_num -= 1;  
90. }  

转自： http://blog.csdn.net/u011833609/article/details/46834203