内存管理算法，支持malloc,realloc,align_alloc，配有内存碎片合并算法

wzh12

今天查看RTX5的内存分配源码，发现其内部实现中并没有内存碎片合并的算法，这样在随机大小分配内存时就会产生内存碎片的问题，不是很完美。而FreeRTOS的Heap4及Heap5的内存算法带有内存碎片的合并算法，但是其可移植性不好，没有对realloc、align_alloc的支持，不是很完美。
        基于这个原因，仿照了FreeRTOS中合并内存碎片的算法，自己编写了一套内存控制算法，编写完成后使用vs2015编写了相应的测试代码，测试结果较为理想。
        下面是算法源码及测试工程
        源码
        mem_manage.h

1. <blockquote>/********************************************************************************

复制代码

mem_manage.c

1. /********************************************************************************
   
2. * @File name: mem_manage.c
   
3. * @Author: wzh
   
4. * @Version: 1.1
   
5. * @Date: 2021-8-14
   
6. * @Description: 内存管理算法，带有内存碎片合并算法，支持malloc、align_alloc、
   
7. *                                realloc、free等常见的内存管理函数，支持多块内存合并管理，支持多线程
   
8. ********************************************************************************/
   
9. #include <stdint.h>
   
10. #include <stdio.h>
    
11. #include <string.h>
    
12. #include "mem_manage.h"
    
13. 
    
14. #define MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT                8
    
15. #define MEM_MANAGE_BITS_PER_BYTE                                8
    
16. #define MEM_MANAGE_MEM_STRUCT_SIZE                                Mem_Manage_Align_Up(sizeof(Mem_Node),MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT)
    
17. #define MEM_MANAGE_MINUM_MEM_SIZE                                (MEM_MANAGE_MEM_STRUCT_SIZE<<1)
    
18. #define MEM_MANAGE_ALLOCA_LABAL                                        ((size_t)(1<<(sizeof(size_t)*MEM_MANAGE_BITS_PER_BYTE-1)))
    
19. 
    
20. 
    
21. static inline size_t Mem_Manage_Align_Down(size_t data, size_t align_byte) {
    
22.         return data&~(align_byte - 1);
    
23. }
    
24. 
    
25. static inline size_t Mem_Manage_Align_Up(size_t data, size_t align_byte) {
    
26.         return (data + align_byte - 1)&~(align_byte - 1);
    
27. }
    
28. 
    
29. static inline Mem_Node* Mem_Manage_Addr_To_Mem(const void* addr) {
    
30.         return (Mem_Node*)((const uint8_t*)addr - MEM_MANAGE_MEM_STRUCT_SIZE);
    
31. }
    
32. 
    
33. static inline void* Mem_Manage_Mem_To_Addr(const Mem_Node* mem_node) {
    
34.         return (void*)((const uint8_t*)mem_node + MEM_MANAGE_MEM_STRUCT_SIZE);
    
35. }
    
36. 
    
37. //将内存节点插入空闲列表中
    
38. static inline void Mem_Insert_Node_To_FreeList(Mem_Root* pRoot, Mem_Node* pNode) {
    
39.         Mem_Node* pPriv_Node;
    
40.         Mem_Node* pNext_Node;
    
41.         //寻找地址与pNode相近的节点
    
42.         for (pPriv_Node = pRoot->pStart; pPriv_Node->next_node < pNode; pPriv_Node = pPriv_Node->next_node);
    
43.         pNext_Node = pPriv_Node->next_node;
    
44.         //尝试pNode与前一个块进行合并
    
45.         if ((uint8_t*)Mem_Manage_Mem_To_Addr(pPriv_Node) + pPriv_Node->mem_size == (uint8_t*)pNode) {
    
46.                 if (pPriv_Node != pRoot->pStart) {//不是Start块的话可以合并
    
47.                         pPriv_Node->mem_size += MEM_MANAGE_MEM_STRUCT_SIZE + pNode->mem_size;
    
48.                         pNode = pPriv_Node;
    
49.                 }
    
50.                 else {//后面如果是Start块不进行合并，以免浪费内存
    
51.                         pRoot->pStart->next_node = pNode;
    
52.                 }
    
53.         }
    
54.         else {//不能合并时直接插入到空闲单链表中
    
55.                 pPriv_Node->next_node = pNode;
    
56.         }
    
57.         //尝试后面一个块与pNode进行合并
    
58.         if ((uint8_t*)Mem_Manage_Mem_To_Addr(pNode) + pNode->mem_size == (uint8_t*)pNext_Node) {
    
59.                 if (pNext_Node != pRoot->pEnd) {//不是end块的话可以进行块合并
    
60.                         pNode->mem_size += MEM_MANAGE_MEM_STRUCT_SIZE + pNext_Node->mem_size;
    
61.                         pNode->next_node = pNext_Node->next_node;
    
62.                 }
    
63.                 else {//后面如果是end块不进行合并，以免浪费内存
    
64.                         pNode->next_node = pRoot->pEnd;
    
65.                 }
    
66.         }
    
67.         else {//不能合并时直接插入到空闲单链表中
    
68.                 pNode->next_node = pNext_Node;
    
69.         }
    
70. }
    
71. 
    
72. //获取管理内存的状态
    
73. void Mem_Manage_Get_State(Mem_Root* pRoot,Mem_State* pState) {
    
74.         MEM_MANAGE_ASSERT(pRoot->pStart != NULL);
    
75.         MEM_MANAGE_ASSERT(pRoot->pEnd != NULL);
    
76.         pState->max_node_size = pRoot->pStart->next_node->mem_size;
    
77.         pState->min_node_size = pRoot->pStart->next_node->mem_size;
    
78.         pState->remain_size = 0;
    
79.         pState->free_node_num = 0;
    
80.         MEM_MANAGE_LOCK();
    
81.         for (Mem_Node* pNode = pRoot->pStart->next_node; pNode->next_node != NULL; pNode = pNode->next_node) {
    
82.                 pState->remain_size += pNode->mem_size;
    
83.                 pState->free_node_num ++;
    
84.                 if (pNode->mem_size > pState->max_node_size)
    
85.                         pState->max_node_size = pNode->mem_size;
    
86.                 if (pNode->mem_size < pState->min_node_size)
    
87.                         pState->min_node_size = pNode->mem_size;
    
88.         }
    
89.         MEM_MANAGE_UNLOCK();
    
90. }
    
91. 
    
92. //对齐分配内存
    
93. void* Mem_Manage_Align_Alloc(Mem_Root* pRoot,size_t align_size, size_t want_size) {
    
94.         void* pReturn = NULL;
    
95.         Mem_Node* pPriv_Node,*pNow_Node;
    
96. 
    
97.         MEM_MANAGE_ASSERT(pRoot->pStart != NULL);
    
98.         MEM_MANAGE_ASSERT(pRoot->pEnd != NULL);
    
99.         
    
100.         
     
101.         if (want_size == 0) {
     
102.                 return NULL;
     
103.         }
     
104. 
     
105.         if ((want_size&MEM_MANAGE_ALLOCA_LABAL) != 0) {//内存过大
     
106.                 MEM_MANAGE_MALLOC_FAIL();
     
107.                 return NULL;
     
108.         }
     
109. 
     
110.         if (align_size&(align_size - 1)) {//内存对齐输入非法值
     
111.                 MEM_MANAGE_MALLOC_FAIL();
     
112.                 return NULL;
     
113.         }
     
114.         
     
115.         MEM_MANAGE_LOCK();
     
116.         if (want_size < MEM_MANAGE_MINUM_MEM_SIZE)
     
117.                 want_size = MEM_MANAGE_MINUM_MEM_SIZE;
     
118.         if (align_size < MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT)
     
119.                 align_size = MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT;
     
120.         //确保分配的单元都是MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT的整数倍
     
121.         want_size = Mem_Manage_Align_Up(want_size, MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT);
     
122. 
     
123.         pPriv_Node = pRoot->pStart;
     
124.         pNow_Node = pRoot->pStart->next_node;
     
125.         
     
126.         while (pNow_Node->next_node != NULL) {
     
127.                 if (pNow_Node->mem_size >= want_size+ MEM_MANAGE_MEM_STRUCT_SIZE) {
     
128.                         size_t use_align_size;
     
129.                         size_t new_size;
     
130.                         pReturn = (void*)Mem_Manage_Align_Up((size_t)Mem_Manage_Mem_To_Addr(pNow_Node), align_size);//计算出对齐的地址
     
131.                         use_align_size = (uint8_t*)pReturn-(uint8_t*)Mem_Manage_Mem_To_Addr(pNow_Node);//计算对齐所消耗的内存
     
132.                         if (use_align_size != 0) {//内存不对齐
     
133.                                 if (use_align_size < MEM_MANAGE_MINUM_MEM_SIZE+ MEM_MANAGE_MEM_STRUCT_SIZE) {//不对齐的值过小
     
134.                                         pReturn = (void*)Mem_Manage_Align_Up(\
     
135.                                                 (size_t)Mem_Manage_Mem_To_Addr(pNow_Node)+ MEM_MANAGE_MINUM_MEM_SIZE+ MEM_MANAGE_MEM_STRUCT_SIZE, align_size);
     
136.                                         use_align_size = (uint8_t*)pReturn - (uint8_t*)Mem_Manage_Mem_To_Addr(pNow_Node);
     
137.                                 }
     
138.                                 if (use_align_size <= pNow_Node->mem_size) {
     
139.                                         new_size = pNow_Node->mem_size - use_align_size;//计算去除对齐消耗的内存剩下的内存大小
     
140.                                         if (new_size >= want_size) {//满足条件，可以进行分配
     
141.                                                 Mem_Node* pNew_Node = Mem_Manage_Addr_To_Mem(pReturn);
     
142.                                                 pNow_Node->mem_size -= new_size + MEM_MANAGE_MEM_STRUCT_SIZE;//分裂节点
     
143.                                                 pNew_Node->mem_size = new_size;//新节点本来也不在空闲链表中，不用从空闲链表中排出
     
144.                                                 pNew_Node->next_node = NULL;
     
145.                                                 pNow_Node = pNew_Node;
     
146.                                                 break;
     
147.                                         }
     
148.                                 }
     
149.                         }
     
150.                         else {//内存直接就是对齐的
     
151.                                 pPriv_Node->next_node = pNow_Node->next_node;//排出空闲链表
     
152.                                 pNow_Node->next_node = NULL;
     
153.                                 break;
     
154.                         }
     
155.                 }
     
156.                 pPriv_Node = pNow_Node;
     
157.                 pNow_Node = pNow_Node->next_node;
     
158.         }
     
159. 
     
160.         if (pNow_Node == pRoot->pEnd){//分配失败
     
161.                 MEM_MANAGE_UNLOCK();
     
162.                 MEM_MANAGE_MALLOC_FAIL();
     
163.                 return NULL;
     
164.         }
     
165. 
     
166.         if (pNow_Node->mem_size >= MEM_MANAGE_MINUM_MEM_SIZE+ MEM_MANAGE_MEM_STRUCT_SIZE + want_size) {//节点内存还有富余
     
167.                 Mem_Node* pNew_Node =(Mem_Node*)((uint8_t*)Mem_Manage_Mem_To_Addr(pNow_Node) + want_size);//计算将要移入空闲链表的节点地址
     
168.                 pNew_Node->mem_size = pNow_Node->mem_size - want_size - MEM_MANAGE_MEM_STRUCT_SIZE;
     
169.                 pNew_Node->next_node = NULL;
     
170.                 pNow_Node->mem_size = want_size;
     
171.                 Mem_Insert_Node_To_FreeList(pRoot, pNew_Node);
     
172.         }
     
173.         pNow_Node->mem_size |= MEM_MANAGE_ALLOCA_LABAL;//标记内存已分配
     
174.         MEM_MANAGE_UNLOCK();
     
175.         return pReturn;
     
176. }
     
177. 
     
178. void* Mem_Manage_Malloc(Mem_Root* pRoot, size_t want_size) {
     
179.         return Mem_Manage_Align_Alloc(pRoot, MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT, want_size);
     
180. }
     
181. 
     
182. void* Mem_Manage_Realloc(Mem_Root* pRoot, void* src_addr, size_t want_size) {
     
183.         void* pReturn = NULL;
     
184.         Mem_Node* pNext_Node,*pPriv_Node;
     
185.         Mem_Node* pSrc_Node;
     
186.         MEM_MANAGE_ASSERT(pRoot->pStart != NULL);
     
187.         MEM_MANAGE_ASSERT(pRoot->pEnd != NULL);
     
188.         if (src_addr == NULL) {
     
189.                 return Mem_Manage_Align_Alloc(pRoot, MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT, want_size);
     
190.         }
     
191.         if (want_size == 0) {
     
192.                 Mem_Manage_Free(pRoot, src_addr);
     
193.                 return NULL;
     
194.         }
     
195. 
     
196.         MEM_MANAGE_LOCK();
     
197.         if ((want_size&MEM_MANAGE_ALLOCA_LABAL) != 0){
     
198.                 MEM_MANAGE_UNLOCK();
     
199.                 MEM_MANAGE_MALLOC_FAIL();
     
200.                 return NULL;
     
201.         }
     
202. 
     
203.         pSrc_Node = Mem_Manage_Addr_To_Mem(src_addr);
     
204. 
     
205.         if ((pSrc_Node->mem_size&MEM_MANAGE_ALLOCA_LABAL) == 0) {//源地址未被分配，调用错误
     
206.                 MEM_MANAGE_UNLOCK();
     
207.                 MEM_MANAGE_ASSERT((pSrc_Node->mem_size&MEM_MANAGE_ALLOCA_LABAL) != 0);
     
208.                 MEM_MANAGE_MALLOC_FAIL();
     
209.                 return NULL;
     
210.         }
     
211. 
     
212.         pSrc_Node->mem_size &= ~MEM_MANAGE_ALLOCA_LABAL;//清除分配标记
     
213.         if (pSrc_Node->mem_size >= want_size) {//块预留地址足够大
     
214.                 pSrc_Node->mem_size |= MEM_MANAGE_ALLOCA_LABAL;//恢复分配标记
     
215.                 pReturn = src_addr;
     
216.                 MEM_MANAGE_UNLOCK();
     
217.                 return pReturn;
     
218.         }
     
219.         //开始在空闲列表中寻找与本块相近的块
     
220.         for (pPriv_Node = pRoot->pStart; pPriv_Node->next_node <pSrc_Node; pPriv_Node = pPriv_Node->next_node);
     
221.         pNext_Node = pPriv_Node->next_node;
     
222. 
     
223.         if (pNext_Node != pRoot->pEnd && \
     
224.                 ((uint8_t*)src_addr + pSrc_Node->mem_size == (uint8_t*)pNext_Node) && \
     
225.                 (pSrc_Node->mem_size + pNext_Node->mem_size + MEM_MANAGE_MEM_STRUCT_SIZE >= want_size)) {
     
226.                 //满足下一节点非end，内存连续，内存剩余足够
     
227.                 pReturn = src_addr;
     
228.                 pPriv_Node->next_node = pNext_Node->next_node;//排出空闲列表
     
229.                 pSrc_Node->mem_size += MEM_MANAGE_MEM_STRUCT_SIZE + pNext_Node->mem_size;
     
230.                 want_size = Mem_Manage_Align_Up(want_size, MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT);
     
231.                 if (pSrc_Node->mem_size >= MEM_MANAGE_MINUM_MEM_SIZE+ MEM_MANAGE_MEM_STRUCT_SIZE+ want_size) {//去除分配的剩余空间足够开辟新块
     
232.                         Mem_Node* pNew_Node = (Mem_Node*)((uint8_t*)Mem_Manage_Mem_To_Addr(pSrc_Node) + want_size);
     
233.                         pNew_Node->next_node = NULL;
     
234.                         pNew_Node->mem_size = pSrc_Node->mem_size - want_size - MEM_MANAGE_MEM_STRUCT_SIZE;
     
235.                         pSrc_Node->mem_size = want_size;
     
236.                         Mem_Insert_Node_To_FreeList(pRoot, pNew_Node);
     
237.                 }
     
238.                 pSrc_Node->mem_size |= MEM_MANAGE_ALLOCA_LABAL;//恢复分配标记
     
239.                 MEM_MANAGE_UNLOCK();
     
240.         }
     
241.         else {
     
242.                 MEM_MANAGE_UNLOCK();
     
243.                 pReturn = Mem_Manage_Align_Alloc(pRoot, MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT, want_size);
     
244.                 if (pReturn == NULL){
     
245.                         pSrc_Node->mem_size |= MEM_MANAGE_ALLOCA_LABAL;//恢复分配标记
     
246.                         MEM_MANAGE_MALLOC_FAIL();
     
247.                         return NULL;
     
248.                 }
     
249.                 MEM_MANAGE_LOCK();
     
250.                 memcpy(pReturn, src_addr, pSrc_Node->mem_size);
     
251.                 pSrc_Node->mem_size |= MEM_MANAGE_ALLOCA_LABAL;//恢复分配标记
     
252.                 MEM_MANAGE_UNLOCK();
     
253.                 Mem_Manage_Free(pRoot, src_addr);
     
254.         }
     
255.         return pReturn;
     
256. }
     
257. 
     
258. //释放内存
     
259. void Mem_Manage_Free(Mem_Root* pRoot,void* addr) {
     
260.         Mem_Node* pFree_Node;
     
261.         MEM_MANAGE_ASSERT(pRoot->pStart != NULL);
     
262.         MEM_MANAGE_ASSERT(pRoot->pEnd != NULL);
     
263.         MEM_MANAGE_LOCK();
     
264.         if (addr == NULL) {
     
265.                 MEM_MANAGE_UNLOCK();
     
266.                 return;
     
267.         }
     
268.         pFree_Node = Mem_Manage_Addr_To_Mem(addr);
     
269. 
     
270.         if ((pFree_Node->mem_size&MEM_MANAGE_ALLOCA_LABAL) == 0) {//释放错误，没有标记
     
271.                 MEM_MANAGE_UNLOCK();
     
272.                 MEM_MANAGE_ASSERT((pFree_Node->mem_size&MEM_MANAGE_ALLOCA_LABAL) != 0);
     
273.                 return;
     
274.         }
     
275. 
     
276.         if (pFree_Node->next_node != NULL) {//释放错误
     
277.                 MEM_MANAGE_UNLOCK();
     
278.                 MEM_MANAGE_ASSERT(pFree_Node->next_node == NULL);
     
279.                 return;
     
280.         }
     
281.         pFree_Node->mem_size &= ~MEM_MANAGE_ALLOCA_LABAL;//清除分配标记
     
282.         Mem_Insert_Node_To_FreeList(pRoot, pFree_Node);//插入到空闲链表中
     
283.         MEM_MANAGE_UNLOCK();
     
284. }
     
285. 
     
286. void Mem_Manage_Heap_Init(Mem_Root* pRoot,const Mem_Region* pRegion) {
     
287.         Mem_Node* align_addr;
     
288.         size_t align_size;
     
289.         Mem_Node* pPriv_node=NULL;
     
290. 
     
291.         pRoot->total_size = 0;
     
292.         pRoot->pEnd = NULL;
     
293.         pRoot->pStart = NULL;
     
294. 
     
295.         for (; pRegion->addr != NULL; pRegion++) {
     
296.                 align_addr = (Mem_Node*)Mem_Manage_Align_Up((size_t)pRegion->addr, MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT);//计算内存块对齐后的地址
     
297.                 if ((uint8_t*)align_addr > pRegion->mem_size+ (uint8_t*)pRegion->addr)//对齐消耗的内存超过内存区
     
298.                         continue;
     
299.                 align_size = pRegion->mem_size - ((uint8_t*)align_addr - (uint8_t*)pRegion->addr);//计算对齐后剩下的内存大小
     
300.                 if (align_size < MEM_MANAGE_MINUM_MEM_SIZE+ MEM_MANAGE_MEM_STRUCT_SIZE)//对齐剩下的内存太小
     
301.                         continue;
     
302.                 align_size -= MEM_MANAGE_MEM_STRUCT_SIZE;//求除去掉表头后内存块的大小
     
303.                 align_addr->mem_size = align_size;
     
304.                 align_addr->next_node = NULL;
     
305.                 if (pRoot->pStart == NULL) {//如果是初始化
     
306.                         pRoot->pStart = align_addr;//将当前内存块地址记为start
     
307.                         if (align_size >= MEM_MANAGE_MINUM_MEM_SIZE+ MEM_MANAGE_MEM_STRUCT_SIZE) {//若剩下的块足够大
     
308.                                 align_size -= MEM_MANAGE_MEM_STRUCT_SIZE;//去掉下一个块的表头剩下的内存大小
     
309.                                 align_addr = (Mem_Node*)((uint8_t*)pRoot->pStart + MEM_MANAGE_MEM_STRUCT_SIZE);//下一个块的表头地址
     
310.                                 align_addr->mem_size = align_size;
     
311.                                 align_addr->next_node = NULL;
     
312.                                 pRoot->pStart->mem_size = 0;
     
313.                                 pRoot->pStart->next_node = align_addr;
     
314.                                 pRoot->total_size = align_addr->mem_size;
     
315.                         }
     
316.                         else {//内存太小了，将当前内存块地址记为start
     
317.                                 pRoot->total_size = 0;
     
318.                                 pRoot->pStart->mem_size = 0;
     
319.                         }
     
320.                 }
     
321.                 else {
     
322.                         pPriv_node->next_node = align_addr;//更新上一节点的next_node
     
323.                         pRoot->total_size += align_size;
     
324.                 }
     
325.                 pPriv_node = align_addr;
     
326.         }
     
327.         //此时，pPriv_node为最后一个块，接下来在块尾放置表尾end
     
328.         //求出放置end块的地址,end块仅是方便遍历使用，因此尽量小，分配为MEM_MANAGE_MEM_STRUCT_SIZE
     
329.         align_addr = (Mem_Node*)Mem_Manage_Align_Down(\
     
330.                 (size_t)Mem_Manage_Mem_To_Addr(pPriv_node) + pPriv_node->mem_size - MEM_MANAGE_MEM_STRUCT_SIZE, MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT);
     
331.         align_size = (uint8_t*)align_addr-(uint8_t*)Mem_Manage_Mem_To_Addr(pPriv_node);//求出分配出end块后，前一个块剩余大小
     
332.         if (align_size >= MEM_MANAGE_MINUM_MEM_SIZE) {//若剩下的块足够大
     
333.                 pRoot->total_size -= pPriv_node->mem_size - align_size;//去掉分配end块消耗的内存
     
334.                 pRoot->pEnd = align_addr;                        //更新表尾的地址
     
335.                 pPriv_node->next_node = align_addr;
     
336.                 pPriv_node->mem_size = align_size;
     
337.                 align_addr->next_node = NULL;
     
338.                 align_addr->mem_size = 0;//end块不参与内存分配，因此直接为0就可以
     
339.         }
     
340.         else {//最后一个块太小了，直接作为end块
     
341.                 pRoot->pEnd = pPriv_node;
     
342.                 pRoot->total_size -= pPriv_node->mem_size;
     
343.         }
     
344.         MEM_MANAGE_ASSERT(pRoot->pStart != NULL);
     
345.         MEM_MANAGE_ASSERT(pRoot->pEnd != NULL);
     
346. }
     
347. 
     
348. 
     

复制代码

测试工程已上传到附件中。
        算法管理内存的方式是通过单链表的形式进行管理，每个空闲块按地址顺序进行排列，算法内部通过宏定义MEM_MANAGE_ALIGNMENT_BYTE_DEFAULT控制对齐，所有的内存元素都会以这个参数进行内存对齐，代表了算法中数据的最小单元，因此以该值作为对齐分配的参数，算法效率最高。
        算法中初始化内存管理区的函数为void Mem_Manage_Heap_Init(Mem_Root* pRoot,const Mem_Region* pRegion) ，支持管理不连续的内存，适合像STM32H7这样内存单元不连续的情况，具体使用说明可以看头文件的说明。
        算法支持malloc、realloc、align_alloc等常见的内存管理函数，在使用align_alloc时注意其中align_size输入，此参数指定了分配内存的对齐字节，如输入为1024，则算法保证分配的地址是1024字节对齐的，注意此参数输入只能为2的整数次幂，也就是诸如4、8、16、32这样的数值，输入值非法会直接返回NULL。
        算法支持多线程，通过重定义头文件的MEM_MANAGE_LOCK()与MEM_MANAGE_UNLOCK()即可实现。
        算法采用句柄的方式管理内存区，内部无全局变量，因此可支持多个内存区分别管理，只需要使用不同的句柄即可。
        在仿真工程中有过对算法效率的统计，当malloc或realloc返回值出现NULL时计算内存使用率，平均下来内存使用率大致在99%左右。
        仿真工程是使用vs2015进行测试，内部共有三个文件，其中mem_manage.c、mem_manage.h为算法源码，main.c为测试程序。
        程序开源，大家放心使用，也欢迎大家来帖子下面讨论算法中不完善的地方。
测试工程百度网盘链接：https://pan.baidu.com/s/1YApS5MNBjCp_gMjtTB_HzA提取码：02xf

zzk111

感谢分享

a604922959

没有附件，楼主很强

wzh12

a604922959 发表于 2021-8-24 10:32
没有附件，楼主很强

sorry，没弄明白怎么上传附件，附上百度网盘链接：https://pan.baidu.com/s/1YApS5MNBjCp_gMjtTB_HzA
提取码：02xf

CKJJJJ

博主的文章看起来很有质量，想问一下有放到gitee上做一些维护吗？想看看大家有没有在用的过程发现一些问题。

勿忘初心

这个比较厉害