目的：高效、快速的分配，并在适当的时候回收内存资源。最终就是实现malloc和free函数。（实现方法参考原子哥）
- N% S6 O' w% j: ]8 M2 z

1. #define CONFIG_SRAM_OUT_ENABLE     0
   
2. 
   2 [- S9 O& Q2 u9 N$ h
3. typedef enum
   2 t% k7 B" e# V9 x4 M; [
4. {
   6 U4 L% ]9 i$ ~, b9 Q
5.   SRAM_TYPE_IN,   // 内部内存池
   6 t+ w' ]( @- z  k$ `5 i' d2 W
6. #if(CONFIG_SRAM_OUT_ENABLE == 1)
   + E0 C1 s6 H" X
7.   SRAM_YPE_OUT,   // 外部内存池(SDRAM)
   * W0 a7 o+ [- y/ a/ |* A
8. #endif
   : f4 y) z# E- @+ y& P
9.   SRAM_TYPE_DTCM, // DTCM内存池(此部分SRAM仅仅CPU可以访问!!!)
   
10.   SRAM_TYPE_MAX,  // 最多支持的SRAM块数.
    6 j6 D2 A( z( D1 W2 q0 P
11. } sram_type_t;
    9 i( W2 \6 D( V& h6 ~
12. 
    
13. // 内部SRAM
    3 m" ~6 Y8 `! D) M7 ?
14. #define SRAM_IN_BLOCK_SIZE        64            // 内存块大小为64字节
    
15. #define SRAM_IN_MAX_SIZE          (160 * 1024)  // 最大管理内存160K
    
16. #define SRAM_IN_ALLOC_TABLE_SIZE  (SRAM_IN_MAX_SIZE / SRAM_IN_BLOCK_SIZE)
    # t, |3 K  h  G$ v! a
17. 
    
18. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    
19. // 外部SDRAM里面
    9 C/ ^- T6 o: {- p. H
20. #define SRAM_OUT_BLOCK_SIZE       64            // 内存块大小为64字节
    6 N0 A8 W& I' q) A& ~
21. #define SRAM_OUT_MAX_SIZE         (100 *1024)   // 最大管理内存100K
    
22. #define SRAM_OUT_ALLOC_TABLE_SIZE (SRAM_OUT_MAX_SIZE / SRAM_OUT_BLOCK_SIZE)
    
23. #endif
    : z, T' S+ p; d( G; T0 ^
24. 
    5 V; N! a0 a3 Y+ Z, i8 n, e$ I
25. // CCM,用于管理DTCM(特别注意,这部分SRAM,仅CPU可以访问!!)
    ; a; _7 ?2 I* M6 _/ O9 k5 l/ X
26. #define SRAM_DTCM_BLOCK_SIZE      64                  //内存块大小为64字节
    3 S, o3 l9 B; l. K. m4 P1 t
27. #define SRAM_DTCM_MAX_SIZE        (100 *1024)             //最大管理内存60K
    $ c' B+ s9 ^# T
28. #define SRAM_DTCM_ALLOC_TABLE_SIZE  (SRAM_DTCM_MAX_SIZE/SRAM_DTCM_BLOCK_SIZE)
    3 p, w; A/ f) d, G8 G) {
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];
    
32. 
    9 ?6 l3 ^- I) D- R" P
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
    ; R! ]  `* m4 U
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
    2 }7 P( ]. p( v/ J( k1 A( A
40. 
    
41. static const uint32_t memtblsize[SRAM_TYPE_MAX] = {SRAM_IN_ALLOC_TABLE_SIZE,
    , V3 l$ _) f: {) @6 O% R7 p( t
42. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    ' `% Y3 X! N: S
43.                                             SRAM_OUT_ALLOC_TABLE_SIZE,
    
44. #endif
    5 T' ?& W/ [: p. `. N
45.                                             SRAM_DTCM_ALLOC_TABLE_SIZE
    0 t) `4 k  e1 z$ u
46.                                            }; //内存表大小
    
47. 
    
48. static const uint32_t memblksize[SRAM_TYPE_MAX] = {SRAM_IN_BLOCK_SIZE,
    ) A) i, R) H9 F# i! G. O
49. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    % T( m, T6 V$ ^7 X) K* ?
50.                                             SRAM_OUT_BLOCK_SIZE,
    
51. #endif
    ' j3 [: R6 A: ]0 K# Z
52.                                             SRAM_DTCM_BLOCK_SIZE
    * S- ~4 k1 T3 [7 N5 ~( x, K0 e
53.                                            };     //内存分块大小
    : {/ n* r! l; J+ V9 ^* u& {
54. 
    8 Z7 L3 R6 z6 [
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,
    
58. #endif
    
59.                                          SRAM_DTCM_MAX_SIZE
    2 v2 l5 w" O% m4 ^8 F4 v
60.                                         };          //内存总大小
    $ v+ {* Z6 {) _5 z: Q
61. 
    : h% ~2 x: `6 Q4 N1 T: n% U, F' m, x
62. void mymem_init(uint8_t type);
    ' z) p' v- W: J* F4 \$ j
63. uint16_t mymem_perused(uint8_t type);
    8 f( u& y) l$ P5 j6 v1 t
64. 
    0 x8 X: l0 J$ R; q+ G
65. typedef struct
    ( e. s4 R, B7 n! P  j# t" Z
66. {
    3 ]# y$ U- Q8 n) P6 V
67.         void (* init)(uint8_t );
    
68.         uint16_t (* perused)(uint8_t);                 // 内存使用率
    
69.         uint8_t         *membase[SRAM_TYPE_MAX]; // 内存池 管理SRAMBANK个区域的内存
    
70.         uint32_t *memmap[SRAM_TYPE_MAX];          // 内存管理状态表
    
71.         uint8_t  memrdy[SRAM_TYPE_MAX];    // 内存管理是否就绪
    & R! i, p1 I8 i- ?5 d* v
72. } sram_dev_t;
    
73. 
    1 S4 q6 t9 P( o( [
74. //内存管理控制器
    6 }9 n3 S6 @) Z  F
75. static sram_dev_t sram_dev =
    ) g6 {3 r$ A) V7 o' S
76. {
    . K, j( q, I0 ]# D7 m" P
77.   mymem_init,        // 内存初始化
    " ?- t  d, G) o( E0 u" G: L9 u, T
78.   mymem_perused,     // 内存使用率
    
79.   sram_in_base,
    2 O7 `5 ]4 O( ]  Z  i2 n5 W- o/ e
80. 
    8 e* H7 Q2 ~. _7 a  d) F0 y& `
81. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    6 r7 J7 j- B; V1 y3 Q0 k
82.   sram_out_base,
    ! U, x! T/ T% \% U# ~$ I0 n8 i
83. #endif
    ' G" o) d% x8 e: ?
84.   sram_dtcm_base,  // 内存池
    
85.   sram_in_map_base,
    
86. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    
87.   sram_out_map_base,
    
88. #endif
    : _1 i# n7 W4 {  z1 \& e( N# e
89.   sram_dtcm_map_base,
    
90.   0,
    % P- X: e  \2 Z4 @# ^* `- ]- g9 O
91. #if(CONFIG_SRAM_OUT_ENABLE == 1)
    ' r7 t: A% l+ N' L; k) p
92.   0,
    
93. #endif
    
94.   0,
    
95. };
    
96. 
    - g* l- o! r' H- U3 g! z$ d% `% \( {
97. // 内存管理初始化
    
98. static void mymem_init(uint8_t memx)
    & z; F' d8 f) L# _: v
99. {
    
100.   memset(sram_dev.memmap[memx], 0, memtblsize[memx] * 4); // 内存状态表数据清零
     " l4 i- W9 d* v6 X9 j- d; U5 g3 c
101.   sram_dev.memrdy[memx] = 1;                              // 内存管理初始化OK
     
102. }
     & d% h- s  j6 |2 N. Q
103. 
     
104. // 获取内存使用率
     + d& Q1 v, _6 S, `3 J
105. // type:所属内存块
     
106. // 返回值:使用率(扩大了10倍,0~1000,代表0.0%~100.0%)
     
107. static uint16_t mymem_perused(uint8_t type)
     
108. {
     
109.   uint32_t used = 0;
     5 U- m) m) a0 m* d. F3 b
110.   uint32_t i;
     + ?! G' F. y3 D. v& L7 p9 Y
111.   for(i = 0; i < memtblsize[type]; ++i)
     
112.   {
     
113.     if(sram_dev.memmap[type]<i>)</i>
     
114.     {
     $ b* |! J; Q. a3 s
115.       used++;
     
116.     }
     8 H6 w0 L8 P$ X; J% Y# U1 q
117.   }
     
118.         
     
119.   return (used * 1000) / (memtblsize[type]);
     
120. }
     4 Z- R2 Y% m! P0 O0 U' ~# n# w
121. 
     : }  E, X; z$ b5 `0 e
122. // 内存分配(内部调用)
     
123. // type:所属内存块
     5 k$ b5 y- Z" Y+ a% \0 \
124. // size:要分配的内存大小(字节)
     ) H% q$ J" C0 Y- P" Q; p- H
125. // 返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址
     7 y5 @2 Z- |+ d1 [. V* F
126. static uint32_t mymem_malloc(uint8_t type, uint32_t size)
     4 V1 g2 v* _- w
127. {
     
128.   signed long offset = 0;
     7 j. k& z: K0 u. l
129.   uint32_t nmemb;     // 需要的内存块数
     
130.   uint32_t cmemb = 0; // 连续空内存块数
     
131.   uint32_t i;
     
132. 
     # h7 D  m' H. S% |/ [: L
133.   if(!sram_dev.memrdy[type])
     
134.   {
     & P2 c! ~" q1 m2 w/ W1 w4 p1 C
135.     sram_dev.init(type);  // 未初始化,先执行初始化
     % p0 I4 d* Q8 Q- m8 ~6 z, ~# c
136.   }
       e6 ^- U% s0 ~1 A0 |* p) G
137.   if(size == 0)
     / L! {( W  s6 X6 r& s' G4 h
138.   {
     1 F( ]0 u7 C$ t' y
139.     return 0xFFFFFFFF;  // 不需要分配
     * j% }& b) S, H
140.   }
     
141.   nmemb = size / memblksize[type]; // 获取需要分配的连续内存块数
     
142.   if(size % memblksize[type])
     
143.   {
     
144.     nmemb++;
     
145.   }
     8 V1 u5 w8 h! f) w' T
146.   for(offset = memtblsize[type] - 1; offset >= 0; offset--) // 搜索整个内存控制区
     
147.   {
     3 n# E( B% L  X% n, W
148.     if(!sram_dev.memmap[type][offset])
     . [1 ^) H# v; P4 \0 b; ], l7 \5 w! e
149.     {
     
150.       cmemb++;    // 连续空内存块数增加
     6 ?" C2 f# m/ H" m' [7 A
151.     }
     
152.     else
     
153.     {
     
154.       cmemb = 0;  // 连续内存块清零
     
155.     }
     5 f/ Q! Q% J& P: @. A
156.     if(cmemb == nmemb)                // 找到了连续nmemb个空内存块
     6 O, w% O0 z/ O
157.     {
     . j1 U1 \8 D) j; l( k5 E. Q7 W
158.       for(i = 0; i < nmemb; i++)      // 标注内存块非空
     
159.       {
     
160.         sram_dev.memmap[type][offset + i] = nmemb;
     
161.       }
     2 N0 h+ u" h+ x5 p$ p. T1 [- W
162.       return (offset * memblksize[type]); // 返回偏移地址
     
163.     }
     
164.   }
     
165.   return 0xFFFFFFFF; // 未找到符合分配条件的内存块
       o- c8 u# Y! r, W2 V$ r7 o
166. }
     
167. 
     
168. // 释放内存(内部调用)
     
169. // type:所属内存块
     ' |1 @! I3 q5 f- ?
170. // offset:内存地址偏移
     
171. // 返回值:0,释放成功;1,释放失败;
     
172. static uint8_t mymem_free(uint8_t type, uint32_t offset)
     
173. {
     0 Z' ^2 t9 a5 q/ h) q
174.   int i;
     ( k9 ?2 z3 c9 ~5 f; Y3 E
175.   if(!sram_dev.memrdy[type])// 未初始化,先执行初始化
     " P% y9 Y3 J5 |9 b3 L
176.   {
     0 G0 t, C; n3 d: `; }4 r
177.     sram_dev.init(type);
     - x% T! Y# Z+ B. u2 l$ k
178.     return 1;// 未初始化
     
179.   }
       ?! b  ^8 Y, U, E0 X$ o/ U, A5 t
180.   if(offset < memsize[type]) // 偏移在内存池内.
     
181.   {
     # j" g0 y1 W, i; w. m1 d2 i
182.     int index = offset / memblksize[type];    // 偏移所在内存块号码
     
183.     int nmemb = sram_dev.memmap[type][index]; // 内存块数量
     2 z4 a  a2 Z; q  r* r$ F
184.     for(i = 0; i < nmemb; i++)                // 内存块清零
     
185.     {
     6 A0 m) g1 }: L
186.       sram_dev.memmap[type][index + i] = 0;
     9 t4 a0 D/ F; ^6 _
187.     }
     6 L! W9 \1 P' V
188.     return 0;
     / A% g& m7 y3 R5 p( A7 e  r  f: h
189.   }
     8 W/ ^0 G% F0 M1 M$ W: V/ g
190.   else
     
191.   {
     
192.     return 2;  // 偏移超区了.
     
193.   }
     5 I- x4 t9 l6 |9 B5 w- ]; m
194. }
     
195. 
     
196. void MemInit(uint8_t type)
     
197. {
     # z" _3 T5 F9 k
198.   memset(sram_dev.memmap[type], 0, memtblsize[type] * 4); // 内存状态表数据清零
     % E5 {, f% }! ~- w" T& i
199.   sram_dev.memrdy[type] = 1;              // 内存管理初始化OK
     
200. }
     2 J% @! Y0 p& }9 [5 l
201. 
     " D% [% e$ c( u& o# c
202. // 释放内存(外部调用)
     
203. // type:所属内存块
     
204. // ptr:内存首地址
     6 o5 }3 o9 G. j( r! a3 B) h
205. void MemFree(uint8_t type, void *ptr)
     
206. {
     
207.   uint32_t offset;
     - K( k+ f5 ^5 ]8 [* D$ Z
208.   if(ptr == NULL)
     
209.   {
     
210.     return;  // 地址为0.
     $ ^( H  T  ?4 n( M* @" S; J- G5 z3 J
211.   }
     
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)
     % C, D: g. F  |* ?' U2 a8 `; M
218. {
     
219.   uint32_t offset;
     
220.   offset = mymem_malloc(type, size);
     
221.   if(offset == 0XFFFFFFFF)
     3 j% h1 }4 H3 K1 Z. u& ~0 J
222.   {
     6 S9 D4 k  t9 C+ m6 X3 E
223.     return NULL;
     
224.   }
     % H$ D9 h1 t* D, c% {  y
225.   else
     & G) I2 d! ^% A; ?
226.   {
     
227.     return (void*)((uint32_t)sram_dev.membase[type] + offset);
     , ^) D( G/ a# X: j: [
228.   }
     7 J* ?; G; J# u5 [
229. }
     ! J4 w) ~; a+ p) I, w: O
230. 
     4 {# ^  H. Z5 x; y  ]9 V
231. // 重新分配内存
     
232. void *MemRealloc(uint8_t type, void *ptr, uint32_t size)
     1 A5 m( @  r& Z. v8 \3 l& F+ A
233. {
     
234.   uint32_t offset;
     ) f8 {, B; _6 U9 |" X
235.   offset = mymem_malloc(type, size);
     ) ?- ^# o  ]$ n8 m
236.   if(offset == 0xFFFFFFFF)
     $ j* e+ i( {0 J
237.   {
     . W6 N- ?' y) K1 h, H+ e5 i7 x
238.     return NULL;
     
239.   }
     # s2 p+ E9 ^8 u; R/ q
240.   else
     2 L% l' ^$ W/ n3 x
241.   {
     $ L( b& ]" }; X  D  M
242.     memcpy((void*)((uint32_t)sram_dev.membase[type] + offset), ptr, size); // 拷贝旧内存内容到新内存
     ! q& J8 C! j- X; v* C' F9 \' Q
243.     MemFree(type, ptr);                                                     // 释放旧内存
     
244.     return (void*)((uint32_t)sram_dev.membase[type] + offset);              // 返回新内存首地址
     4 i/ ^1 V4 f4 Q/ H
245.   }
     
246. }
     7 _( f, J6 N0 \: D* ~( T" R
247. 
     

复制代码