目的：高效、快速的分配，并在适当的时候回收内存资源。最终就是实现malloc和free函数。（实现方法参考原子哥）

% A+ E8 |, @6 R, g( B/ [

1. #define CONFIG_SRAM_OUT_ENABLE     0
   " n, b& z3 p7 ?+ {7 a
2. 
   
3. typedef enum
   0 }0 w- r$ `+ q+ @& n$ L
4. {
   
5.   SRAM_TYPE_IN,   // 内部内存池
   
6. #if(CONFIG_SRAM_OUT_ENABLE == 1)
   ' I- }* ^: S/ m
7.   SRAM_YPE_OUT,   // 外部内存池(SDRAM)
   3 g+ a2 s+ Y" }1 ^* W
8. #endif
   # v5 o4 L; b/ B
9.   SRAM_TYPE_DTCM, // DTCM内存池(此部分SRAM仅仅CPU可以访问!!!)
   
10.   SRAM_TYPE_MAX,  // 最多支持的SRAM块数.
    & ~5 t$ o; \0 p9 h
11. } sram_type_t;
    
12. 
    6 i" j7 R# r2 V6 Q
13. // 内部SRAM
    
14. #define SRAM_IN_BLOCK_SIZE        64            // 内存块大小为64字节
    ! ?/ s" T' b1 M3 h; ?5 `8 Z8 u) t# z
15. #define SRAM_IN_MAX_SIZE          (160 * 1024)  // 最大管理内存160K
    
16. #define SRAM_IN_ALLOC_TABLE_SIZE  (SRAM_IN_MAX_SIZE / SRAM_IN_BLOCK_SIZE)
    
17. 
    
18. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    5 Q1 U- v& _2 C# d
19. // 外部SDRAM里面
    ) l% v! v; ?% z, f1 C) w
20. #define SRAM_OUT_BLOCK_SIZE       64            // 内存块大小为64字节
    
21. #define SRAM_OUT_MAX_SIZE         (100 *1024)   // 最大管理内存100K
    9 d& ~( z0 D3 P1 g
22. #define SRAM_OUT_ALLOC_TABLE_SIZE (SRAM_OUT_MAX_SIZE / SRAM_OUT_BLOCK_SIZE)
    
23. #endif
    ) A% \$ Y3 \1 G6 P* b6 s% d
24. 
    0 N- M% c: w5 t7 F3 }0 R
25. // CCM,用于管理DTCM(特别注意,这部分SRAM,仅CPU可以访问!!)
    , x# A  `# y3 Y- h
26. #define SRAM_DTCM_BLOCK_SIZE      64                  //内存块大小为64字节
    ( z8 k1 U' e3 H, J7 ~
27. #define SRAM_DTCM_MAX_SIZE        (100 *1024)             //最大管理内存60K
    ! }  t# d5 c3 Q: J0 @1 G: j; g
28. #define SRAM_DTCM_ALLOC_TABLE_SIZE  (SRAM_DTCM_MAX_SIZE/SRAM_DTCM_BLOCK_SIZE)
    
29. //内存池(32字节对齐)
    
30. __align(32) uint8_t sram_in_base[SRAM_IN_MAX_SIZE];                                      // 内部SRAM内存池
    
31. uint32_t sram_in_map_base[SRAM_IN_ALLOC_TABLE_SIZE];
    1 |# f/ }$ H- v8 o! @4 \9 L
32. 
    5 w* Q/ z4 _9 T9 Q( o7 }7 _; }. r# t
33. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    
34. __align(32) uint8_t sram_out_base[SRAM_OUT_MAX_SIZE] __attribute__((at(0xC01F4000)));   // 外部SDRAM内存池
    
35. uint32_t sram_out_map_base[SRAM_OUT_ALLOC_TABLE_SIZE] __attribute__((at(0xC01F4000 + SRAM_OUT_MAX_SIZE))); // 外部SRAM内存池MAP
    
36. #endif
    
37. 
    
38. __align(32) uint8_t sram_dtcm_base[SRAM_DTCM_MAX_SIZE] __attribute__((at(0x20000000))); // 内部DTCM内存池
    
39. uint32_t sram_dtcm_map_base[SRAM_DTCM_ALLOC_TABLE_SIZE] __attribute__((at(0x20000000 + SRAM_DTCM_MAX_SIZE))); //内部DTCM内存池MAP
    
40. 
    # w6 y; H9 u6 \
41. static const uint32_t memtblsize[SRAM_TYPE_MAX] = {SRAM_IN_ALLOC_TABLE_SIZE,
    / G/ {% x; m. F; G1 x, Z' z
42. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    
43.                                             SRAM_OUT_ALLOC_TABLE_SIZE,
    " _* m( J7 W. P: P
44. #endif
    " c& F: z6 Q$ w
45.                                             SRAM_DTCM_ALLOC_TABLE_SIZE
    
46.                                            }; //内存表大小
    
47. 
    3 ^4 b, d4 ?. ^2 y0 b1 p
48. static const uint32_t memblksize[SRAM_TYPE_MAX] = {SRAM_IN_BLOCK_SIZE,
    ) X  R( q5 _2 b9 B3 p9 o
49. #if(CONFIG_SRAM_OUT_ENABLE == 1)
      y8 n6 U0 k1 Z( w* X
50.                                             SRAM_OUT_BLOCK_SIZE,
    
51. #endif
    1 s" N' m; H0 F8 r
52.                                             SRAM_DTCM_BLOCK_SIZE
    1 U! J: z( s- d& a) X2 e8 S3 i
53.                                            };     //内存分块大小
    
54. 
    1 n. M. H& z  y
55. static const uint32_t memsize[SRAM_TYPE_MAX] = {SRAM_IN_MAX_SIZE,
    
56. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    
57.                                          SRAM_OUT_MAX_SIZE,
    , T# P" h& X/ q' Q# P
58. #endif
    6 W! y( B& e" R+ g9 l
59.                                          SRAM_DTCM_MAX_SIZE
    ; |5 S9 U: B! k6 `! e5 l' e" \+ `
60.                                         };          //内存总大小
    , z8 \. h* V3 ~- e" z8 I
61. 
    ! |. G9 m: h. W; T: B& Q
62. void mymem_init(uint8_t type);
    
63. uint16_t mymem_perused(uint8_t type);
    8 C! ~9 C! N$ f, M
64. 
    . W  P% W7 v6 y/ [& W( L" `. {
65. typedef struct
    
66. {
    3 @  n" D5 i4 U/ C$ ^$ N
67.         void (* init)(uint8_t );
    1 t0 u1 {# I( N9 |# S
68.         uint16_t (* perused)(uint8_t);                 // 内存使用率
    
69.         uint8_t         *membase[SRAM_TYPE_MAX]; // 内存池 管理SRAMBANK个区域的内存
    ; M# N8 D  W3 T6 R
70.         uint32_t *memmap[SRAM_TYPE_MAX];          // 内存管理状态表
    
71.         uint8_t  memrdy[SRAM_TYPE_MAX];    // 内存管理是否就绪
    
72. } sram_dev_t;
    ! X7 E2 p# |  l- `, [6 [
73. 
    
74. //内存管理控制器
    
75. static sram_dev_t sram_dev =
    6 Y7 H; d6 ?- u
76. {
    - C% n/ y* }) i  l. b. ~3 |
77.   mymem_init,        // 内存初始化
    8 G( R! O6 h! ]# z- {( L
78.   mymem_perused,     // 内存使用率
    
79.   sram_in_base,
    
80. 
    5 h' ?5 Q9 W# p* x+ H8 b- m
81. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    
82.   sram_out_base,
    
83. #endif
    
84.   sram_dtcm_base,  // 内存池
    
85.   sram_in_map_base,
    $ C' g) h; G$ T5 J
86. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    3 V& M7 |) H4 g
87.   sram_out_map_base,
    8 |4 e" z1 n' h5 B
88. #endif
    ( ~  ^0 X0 k! B7 `
89.   sram_dtcm_map_base,
    2 V# |+ D* J$ P0 V9 @9 g3 S
90.   0,
      s* _  a* L( H4 ?
91. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    ( N. Y% D8 H# l2 q/ c
92.   0,
    ( Q: r: P- t0 D2 |: B" l0 h: w
93. #endif
    
94.   0,
    
95. };
    
96. 
    1 K! S: H# Z4 f, ^  }
97. // 内存管理初始化
    
98. static void mymem_init(uint8_t memx)
    # u/ |( l+ T: g7 J! t; G
99. {
    # K$ N" Q! Y, X
100.   memset(sram_dev.memmap[memx], 0, memtblsize[memx] * 4); // 内存状态表数据清零
     
101.   sram_dev.memrdy[memx] = 1;                              // 内存管理初始化OK
     
102. }
     
103. 
     
104. // 获取内存使用率
     
105. // type:所属内存块
     : h0 p% B! T7 N8 i/ B
106. // 返回值:使用率(扩大了10倍,0~1000,代表0.0%~100.0%)
     
107. static uint16_t mymem_perused(uint8_t type)
     
108. {
     $ W3 K1 U5 N. A. E3 i
109.   uint32_t used = 0;
     
110.   uint32_t i;
     
111.   for(i = 0; i < memtblsize[type]; ++i)
     
112.   {
     
113.     if(sram_dev.memmap[type]<i>)</i>
     
114.     {
     
115.       used++;
     
116.     }
     ' }8 a+ {0 w9 d/ u1 Q# K
117.   }
     , q$ ^2 u+ Q3 ?) |
118.         
     1 P' w; C6 b* Q
119.   return (used * 1000) / (memtblsize[type]);
     . f' O+ `; R7 s2 C9 K- S% U- Z( d8 _/ L
120. }
     
121. 
     
122. // 内存分配(内部调用)
     % J2 M' U6 m/ c1 s9 o" N( R
123. // type:所属内存块
     
124. // size:要分配的内存大小(字节)
     
125. // 返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址
     
126. static uint32_t mymem_malloc(uint8_t type, uint32_t size)
     ' f% r$ ]" g$ Q; o" _9 L
127. {
     7 b% y' ~  f+ {1 G, T. J
128.   signed long offset = 0;
     
129.   uint32_t nmemb;     // 需要的内存块数
     $ K  k4 C% U4 {
130.   uint32_t cmemb = 0; // 连续空内存块数
     
131.   uint32_t i;
     
132. 
     
133.   if(!sram_dev.memrdy[type])
     
134.   {
     
135.     sram_dev.init(type);  // 未初始化,先执行初始化
     
136.   }
     
137.   if(size == 0)
     ) n* a( |$ R+ O  y; @) A
138.   {
     - b8 q4 B0 s; ?! G: }' t
139.     return 0xFFFFFFFF;  // 不需要分配
     
140.   }
     6 R2 Q/ i+ u$ I8 o8 C$ a
141.   nmemb = size / memblksize[type]; // 获取需要分配的连续内存块数
     4 X$ R2 z# {  D; q1 {( ?
142.   if(size % memblksize[type])
     : T4 b" e4 @$ w! n
143.   {
     # D! J$ l% {, F& I  Z. c1 y
144.     nmemb++;
     & v$ z& t# `% Z' `5 N
145.   }
     : q- ]# L1 R% h
146.   for(offset = memtblsize[type] - 1; offset >= 0; offset--) // 搜索整个内存控制区
     1 ^9 N, o! Y6 g% J7 V
147.   {
     ! E6 q! Y3 Y0 I
148.     if(!sram_dev.memmap[type][offset])
     
149.     {
     
150.       cmemb++;    // 连续空内存块数增加
     
151.     }
     5 a) Y5 W/ d0 @4 R5 \4 r
152.     else
     
153.     {
     * l, u( `5 }7 R' w5 ]
154.       cmemb = 0;  // 连续内存块清零
     
155.     }
     
156.     if(cmemb == nmemb)                // 找到了连续nmemb个空内存块
     1 j* P( _5 t/ n! G
157.     {
     3 T# T  A1 v6 h( ~. `
158.       for(i = 0; i < nmemb; i++)      // 标注内存块非空
     - y2 I* ?! i, ]
159.       {
     
160.         sram_dev.memmap[type][offset + i] = nmemb;
     
161.       }
     ; P) ?: o  u" E4 b& K
162.       return (offset * memblksize[type]); // 返回偏移地址
     
163.     }
     
164.   }
     5 a( R# }( Z  [& P
165.   return 0xFFFFFFFF; // 未找到符合分配条件的内存块
     # _" K' W( I% T1 W" a
166. }
     
167. 
       U0 A8 D9 W) G' l0 E" ^2 ~
168. // 释放内存(内部调用)
     + ~3 k4 G4 x2 N5 h2 H
169. // type:所属内存块
     
170. // offset:内存地址偏移
     
171. // 返回值:0,释放成功;1,释放失败;
     * @; _4 p! ?" x; T# ]
172. static uint8_t mymem_free(uint8_t type, uint32_t offset)
     , t, s, i7 D: J5 ]  l' V
173. {
     
174.   int i;
     
175.   if(!sram_dev.memrdy[type])// 未初始化,先执行初始化
     
176.   {
     
177.     sram_dev.init(type);
     6 L- g4 V- ^4 d# N0 l, k
178.     return 1;// 未初始化
     
179.   }
     7 D/ k1 c; Z. G1 L: D8 J1 a8 R! g
180.   if(offset < memsize[type]) // 偏移在内存池内.
     
181.   {
     - D! t0 X. P6 f5 W( A9 K8 W' Z/ j. m
182.     int index = offset / memblksize[type];    // 偏移所在内存块号码
     4 J+ X9 H8 X0 j5 E" m4 B9 K
183.     int nmemb = sram_dev.memmap[type][index]; // 内存块数量
     . u3 F' e: X% b9 U* L5 l
184.     for(i = 0; i < nmemb; i++)                // 内存块清零
     
185.     {
     $ ?, Q0 C8 W; b8 A. A* J1 a& J
186.       sram_dev.memmap[type][index + i] = 0;
     
187.     }
     
188.     return 0;
     
189.   }
     
190.   else
     1 v7 X; ~$ l! t5 b
191.   {
     
192.     return 2;  // 偏移超区了.
     ; z- J$ u$ x3 a% q. T% q. t
193.   }
     7 ~4 f" z# D/ S
194. }
     / r9 @/ u6 V* G# F
195. 
     
196. void MemInit(uint8_t type)
     
197. {
     
198.   memset(sram_dev.memmap[type], 0, memtblsize[type] * 4); // 内存状态表数据清零
     " G' ?2 j. O+ g
199.   sram_dev.memrdy[type] = 1;              // 内存管理初始化OK
     ' [. ?- f+ x1 h: j  G
200. }
     
201. 
     
202. // 释放内存(外部调用)
     5 M) f& j% v, u  \* ~3 ^: X
203. // type:所属内存块
     
204. // ptr:内存首地址
     
205. void MemFree(uint8_t type, void *ptr)
     " I1 g- X/ b: H% J7 @% O2 F
206. {
     + f: d# I, n+ }5 e7 F( \
207.   uint32_t offset;
     & X/ x3 R! z( s( ~9 a9 f/ S; O
208.   if(ptr == NULL)
     & o5 y4 J: x7 |  v
209.   {
     
210.     return;  // 地址为0.
     - r) u/ S* ~' U1 m" G: p! t! ~5 W/ P5 W
211.   }
     8 u2 N# p. x$ R# s) J- Z: l% C
212.   offset = (uint32_t)ptr - (uint32_t)sram_dev.membase[type];
     
213.   mymem_free(type, offset); // 释放内存
     
214. }
     
215. 
     
216. // 分配内存
     
217. void *MemAlloc(uint8_t type, uint32_t size)
     : O. Y% D7 d6 U7 U8 @0 b
218. {
     0 f: t' y  G$ |' }; D
219.   uint32_t offset;
     
220.   offset = mymem_malloc(type, size);
     4 o' Q. \( ~8 w0 I+ a( T3 q
221.   if(offset == 0XFFFFFFFF)
     
222.   {
     
223.     return NULL;
     
224.   }
     ' @' |( _. [7 }$ w1 V
225.   else
     . q) |+ P3 f& o/ f& S2 B* D2 g
226.   {
     8 }! i. W/ J. o3 |, }
227.     return (void*)((uint32_t)sram_dev.membase[type] + offset);
     
228.   }
     / R1 ^5 |" d; `0 Q& Z2 l$ [& a
229. }
     
230. 
     
231. // 重新分配内存
     , x; X" t/ R6 s
232. void *MemRealloc(uint8_t type, void *ptr, uint32_t size)
     
233. {
     8 e5 |1 j" D" j- q% h+ M5 \
234.   uint32_t offset;
     
235.   offset = mymem_malloc(type, size);
     $ Q  i, a5 i8 _: {7 b# l# ]
236.   if(offset == 0xFFFFFFFF)
     
237.   {
     
238.     return NULL;
     $ e3 _0 A3 k1 }8 ^- R& h8 L3 F
239.   }
     
240.   else
     9 l; i& J1 l/ Z6 F
241.   {
     
242.     memcpy((void*)((uint32_t)sram_dev.membase[type] + offset), ptr, size); // 拷贝旧内存内容到新内存
     
243.     MemFree(type, ptr);                                                     // 释放旧内存
     
244.     return (void*)((uint32_t)sram_dev.membase[type] + offset);              // 返回新内存首地址
     * r8 J( r3 s& }3 L# h
245.   }
     
246. }
     * T5 J4 t% y( Y( T% c) F
247. 
     

复制代码