SEGGER提供的malloc，calloc，realloc，free重定义源文件完整代码

eric2013

Embedded Sutudio安装目录路径：SEGGER\SEGGER Embedded Studio for ARM 5.10\source

1. // **********************************************************************
   
2. // *                    SEGGER Microcontroller GmbH                     *
   
3. // *                        The Embedded Experts                        *
   
4. // **********************************************************************
   
5. // *                                                                    *
   
6. // *            (c) 2014 - 2020 SEGGER Microcontroller GmbH             *
   
7. // *            (c) 2001 - 2020 Rowley Associates Limited               *
   
8. // *                                                                    *
   
9. // *           www.segger.com     Support: support@segger.com           *
   
10. // *                                                                    *
    
11. // **********************************************************************
    
12. // *                                                                    *
    
13. // * All rights reserved.                                               *
    
14. // *                                                                    *
    
15. // * Redistribution and use in source and binary forms, with or         *
    
16. // * without modification, are permitted provided that the following    *
    
17. // * condition is met:                                                  *
    
18. // *                                                                    *
    
19. // * - Redistributions of source code must retain the above copyright   *
    
20. // *   notice, this condition and the following disclaimer.             *
    
21. // *                                                                    *
    
22. // * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
    
23. // * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
    
24. // * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
    
25. // * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
    
26. // * DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
    
27. // * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
    
28. // * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
    
29. // * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
    
30. // * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
    
31. // * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
    
32. // * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
    
33. // * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
    
34. // * DAMAGE.                                                            *
    
35. // *                                                                    *
    
36. // **********************************************************************
    
37. 
    
38. #include "stdlib.h"
    
39. #include "string.h"
    
40. #include "__libc.h"
    
41. 
    
42. #if defined(__CROSSWORKS_ARM) || defined(__SES_ARM) || defined(__SES_RISCV)
    
43. 
    
44. void *calloc(size_t nobj, size_t size)__attribute__((weak));
    
45. void *malloc(size_t size)__attribute__((weak));
    
46. void free(void *addr)__attribute__((weak));
    
47. void *realloc(void *p, size_t size)__attribute__((weak));
    
48. 
    
49. #endif
    
50. 
    
51. typedef struct heap_tag
    
52. {
    
53.   struct heap_tag *next;
    
54.   unsigned size;
    
55. } heap_t;
    
56. 
    
57. extern heap_t __heap_start__;
    
58. static heap_t *heap = &__heap_start__;
    
59. 
    
60. #define HEAP_CHUNK_SIZE  16   /* Must be a power of two. */
    
61. #define ADDADR(x,n)  ((void *)((unsigned char *)(x)+(n)))
    
62. 
    
63. #if defined(__CROSSWORKS_ARM) || defined(__SES_ARM) || defined(__SES_RISCV)
    
64. extern char __heap_end__[];
    
65. static size_t
    
66. raw_heap_size(void)
    
67. {
    
68.   return __heap_end__ - (char *)&__heap_start__;
    
69. }
    
70. static int
    
71. in_heap(void *addr)
    
72. {  
    
73.   return addr >= (void*)&__heap_start__ && addr <= (void*)__heap_end__;
    
74. }
    
75. #endif
    
76. 
    
77. void *
    
78. calloc(size_t nobj, size_t size)
    
79. {
    
80.   size_t arrsize = nobj * size;
    
81.   void *m = malloc(arrsize);
    
82.   if (m)
    
83.     memset(m, 0, arrsize);
    
84.   return m;
    
85. }
    
86. 
    
87. void *
    
88. malloc(size_t size)
    
89. {         
    
90.   heap_t *p, *q, *best;
    
91.   unsigned best_size;   
    
92. 
    
93. #if defined(__CROSSWORKS_ARM) || defined(__SES_ARM) || defined(__SES_RISCV)
    
94.   // Protect against small heaps requested by the user/IDE.
    
95.   if (raw_heap_size() <= HEAP_CHUNK_SIZE)
    
96.     return 0;
    
97. #endif
    
98. 
    
99.   __heap_lock();
    
100. 
     
101.   /* Round up to a multiple of HEAP_CHUNK_SIZE and account for size word. */
     
102.   size = (size + sizeof(unsigned) + HEAP_CHUNK_SIZE-1) & (unsigned)(-HEAP_CHUNK_SIZE);
     
103. 
     
104.   /* Find first block that could satisfy request. */
     
105.   p = heap;
     
106.   q = 0;
     
107. 
     
108.   /* No best-fit block. */
     
109.   best_size = ~0U;
     
110.   best = 0;
     
111. 
     
112.   /* Search for best-fit block. */
     
113.   while (p)
     
114.     {
     
115. 
     
116.       /* Check whether block is correct size. */
     
117.       if (p->size == size)
     
118.         {
     
119.           /* Exact fit - remove block from the free list. */
     
120.           if (q)
     
121.             q->next = p->next;
     
122.           else
     
123.             heap = p->next;
     
124. 
     
125.           /* Short-cut return. */
     
126.           *((unsigned *)p) = size;
     
127.           __heap_unlock();
     
128.           return ((char *)p) + sizeof(unsigned);
     
129.         }
     
130. 
     
131.       /* Check whether block can be split. */
     
132.       else if (p->size > size && p->size < best_size)
     
133.         {
     
134.           best = p;
     
135.           best_size = p->size;
     
136.         }
     
137. 
     
138.       /* Consider next block. */
     
139.       q = p;
     
140.       p = p->next;
     
141.     }
     
142. 
     
143.   /* Block must be split; take free memory from top of block. */
     
144.   if (best)
     
145.     {
     
146.       best->size -= size;
     
147.       p = ADDADR(best, best_size - size);
     
148.       *((unsigned *)p) = size;  
     
149.       //memset((char*)p+sizeof(unsigned), 0xAE, size-2);
     
150.       __heap_unlock();
     
151.       return ((char *)p) + sizeof(unsigned);
     
152.     }
     
153.   else
     
154.     {
     
155.       __heap_unlock();
     
156.       return 0;
     
157.     }
     
158. }
     
159. 
     
160. void
     
161. free(void *addr)
     
162. {
     
163.   heap_t *p, *rover, *prev;
     
164.   unsigned size;  
     
165. 
     
166.   if (addr == 0)
     
167.     return;
     
168. 
     
169. #if defined(__CROSSWORKS_ARM) || defined(__SES_ARM) || defined(__SES_RISCV)
     
170.   if (!in_heap(addr))
     
171.     return;
     
172. #endif
     
173. 
     
174.   __heap_lock();
     
175. 
     
176.   /* Adjust backwards to actual memory block origin. */
     
177.   addr = ((char *)addr) - sizeof(unsigned);
     
178. 
     
179.   /* Recover size */
     
180.   size = *((unsigned *)addr);
     
181.   
     
182.   if (addr)
     
183.     {
     
184.       //memset(addr, 0xFE, size);  
     
185. 
     
186.       /* Deallocated onto non-existent heap? */
     
187.       if (heap == 0)
     
188.         {
     
189.           /* Yes, add this floating block to the heap. */
     
190.           heap = addr;
     
191.           heap->next = 0;
     
192.           heap->size = size;
     
193.         }
     
194.       else
     
195.         {
     
196.           /* Search for block adjacent to p, but with lower address. */
     
197.           p = addr; rover = heap; prev = 0;
     
198.           while (rover && rover < (heap_t *)addr)
     
199.             {
     
200.               prev = rover; rover = rover->next;
     
201.             }
     
202. 
     
203.           /* Check for double-dispose of a pointer. */
     
204.           /* For efficiency, this could be removed. */
     
205.     #if 0
     
206.           if ((rover = addr) ||
     
207.               prev & (DIFADR(addr, ADDADR(prev, prev->size)) < 0))
     
208.             HALT(DOUBLEDISPOSE);
     
209.           END;
     
210.     #endif
     
211. 
     
212.           /* Return block to free list */
     
213.           p->next = rover;
     
214.           p->size = size;
     
215.           if (prev)
     
216.             prev->next = p;
     
217.           else
     
218.             heap = p;
     
219. 
     
220.           /* See if can join with block to right. */
     
221.           if (rover && (ADDADR(p, size) == rover))
     
222.             {
     
223.               p->size += rover->size;
     
224.               p->next = rover->next;
     
225.             }
     
226. 
     
227.           /* See if can join with block to left. */
     
228.           if (prev && ADDADR(prev, prev->size) == p)
     
229.             {
     
230.               prev->size += p->size;
     
231.               prev->next = p->next;
     
232.             }
     
233.         }
     
234.     }
     
235.   __heap_unlock();
     
236. }
     
237. 
     
238. void *
     
239. realloc(void *p, size_t size)
     
240. {
     
241.   /* Allocate area of requested size. */
     
242.   void *pp = malloc(size);
     
243.   
     
244.   /* If no memory, keep existing block and indicate failure to reallocate. */
     
245.   if (pp == 0)
     
246.     return pp;
     
247. 
     
248.   /* Copy existing block if we were given one. */
     
249.   if (p)
     
250.     {
     
251.       /* Recover size */
     
252.       size_t existing_size = ((unsigned *)p)[-1];
     
253. 
     
254.       /* Limit size to copy. */
     
255.       if (existing_size < size)
     
256.         size = existing_size;
     
257. 
     
258.       /* Make copy of data. */
     
259.       memcpy(pp, p, size);
     
260. 
     
261.       /* And we're done with the original block. */
     
262.       free(p);
     
263.     }
     
264. 
     
265.   /* Return newly allocated block. */
     
266.   return pp;
     
267. }
     

复制代码

hexenzhou

这个有单独下载的地方吗？想把它移植到自己的项目中，又不想安装Segger的Embedded Sutudio

hpdell

你好，请问下，这个内存管理的实际使用效果如何啊 ？

eric2013

hpdell 发表于 2020-9-2 16:08
你好，请问下，这个内存管理的实际使用效果如何啊 ？

实际用的是这个，貌似还可以

Embedded Studio带的malloc，使用的buddy算法
http://www.armbbs.cn/forum.php?m ... 9463&fromuid=58
(出处: 硬汉嵌入式论坛)