1. #ifndef __MALLOC_H
   % ~0 B: \5 R/ I  t+ W
2. #define __MALLOC_H
   
3. #include "stm32f10x.h"
   , B) u' C5 X; s- E. t8 h: w
4. //////////////////////////////////////////////////////////////////////////////////     
   6 ~% E2 W9 I5 B& H' p
5. //本程序只供学习使用，未经作者许可，不得用于其它任何用途
   9 G& P% ]* s) l2 z! U
6. //ALIENTEK战舰STM32开发板V3
   
7. //内存管理 驱动代码      
   " N+ I/ J. a8 s0 [6 R" y# a
8. //正点原子@ALIENTEK
   9 ?1 t& o/ T7 ]! |) G
9. //技术论坛:www.openedv.com
   4 v. [* \" @# H. D3 i# R" Q0 ]
10. //修改日期:2015/1/20
    ; P! |$ B5 ^! a9 V7 \5 L" x
11. //版本：V1.0
    
12. //版权所有，盗版必究。
    6 R2 d# |. y1 E
13. //Copyright(C) 广州市星翼电子科技有限公司 2009-2019
    
14. //All rights reserved                                      
    + P0 H: s8 f7 q0 f
15. //////////////////////////////////////////////////////////////////////////////////
    
16. 
    
17. 
    
18. #ifndef NULL
    
19. #define NULL 0
    
20. #endif
    
21.   
    
22. //定义两个内存池
    
23. #define SRAMIN     0        //内部内存池
    . q. n3 m( C% t, Q9 ?0 C  R' B% [
24. #define SRAMEX   1        //外部内存池
    
25. 
    + k' t2 l0 J7 z% P4 m+ {
26. #define SRAMBANK     2    //定义支持的SRAM块数.   
    
27. 
    
28. 
    
29. //mem1内存参数设定.mem1完全处于内部SRAM里面.
    
30. #define MEM1_BLOCK_SIZE            32                                //内存块大小为32字节
    
31. #define MEM1_MAX_SIZE            35*1024                          //最大管理内存 40K
    2 Z( g. H3 g3 d$ e5 _* G
32. #define MEM1_ALLOC_TABLE_SIZE    MEM1_MAX_SIZE/MEM1_BLOCK_SIZE     //内存表大小
    
33. 
    . P; Y1 X( T% C+ A
34. //mem2内存参数设定.mem2的内存池处于外部SRAM里面
    + }/ a% n8 [3 s* M8 J
35. #define MEM2_BLOCK_SIZE            32                                //内存块大小为32字节
    2 d# v; J& ?  v& G  p+ R& [  f
36. #define MEM2_MAX_SIZE            800 *1024                          //最大管理内存960K
    
37. #define MEM2_ALLOC_TABLE_SIZE    MEM2_MAX_SIZE/MEM2_BLOCK_SIZE     //内存表大小
    ' x- L% h$ k+ _6 g1 U9 }" x: k
38.          
    % P9 x; V% L$ f+ H
39. 
    6 |( d+ s. G0 \  a, J! W( V: W6 v1 O
40. //内存管理控制器
    
41. struct _m_mallco_dev
    
42. {
    
43.     void (*init)(u8);                    //初始化
    . i& i' p, y/ [
44.     u8 (*perused)(u8);                      //内存使用率
    
45.     u8     *membase[SRAMBANK];                //内存池 管理SRAMBANK个区域的内存
    
46.     u16 *memmap[SRAMBANK];                 //内存管理状态表
    " T' J; ^9 \2 J* z1 H; C
47.     u8  memrdy[SRAMBANK];                 //内存管理是否就绪
    1 V! n- T* y8 ^! G0 i
48. };
    
49. extern struct _m_mallco_dev mallco_dev;     //在mallco.c里面定义
    
50. 
    
51. void mymemset(void *s,u8 c,u32 count);    //设置内存
    , G9 S3 B9 g* \/ n2 z3 ]" s6 Z
52. void mymemcpy(void *des,void *src,u32 n);//复制内存     
    
53. void my_mem_init(u8 memx);                //内存管理初始化函数(外/内部调用)
    
54. u32 my_mem_malloc(u8 memx,u32 size);    //内存分配(内部调用)
    ; X: J* a/ \8 I6 Q
55. u8 my_mem_free(u8 memx,u32 offset);        //内存释放(内部调用)
    4 h; ]& `5 _  d0 R2 P
56. u8 my_mem_perused(u8 memx);                //获得内存使用率(外/内部调用)
    
57. ////////////////////////////////////////////////////////////////////////////////
    
58. //用户调用函数
    
59. void myfree(u8 memx,void *ptr);              //内存释放(外部调用)
    
60. void *mymalloc(u8 memx,u32 size);            //内存分配(外部调用)
    
61. void *myrealloc(u8 memx,void *ptr,u32 size);//重新分配内存(外部调用)
    
62. #endif

复制代码

1. #include "malloc.h"        
   
2. //////////////////////////////////////////////////////////////////////////////////     
   
3. //本程序只供学习使用，未经作者许可，不得用于其它任何用途
   $ Q1 b; L. K" ^, Y' h6 N
4. //ALIENTEK战舰STM32开发板V3
   + Z4 S( P5 T: z4 E* K
5. //内存管理 驱动代码      
   
6. //正点原子@ALIENTEK
   
7. //技术论坛:www.openedv.com
   
8. //修改日期:2015/1/20
   
9. //版本：V1.0
   
10. //版权所有，盗版必究。
    ( S8 j5 Y, O# B2 _
11. //Copyright(C) 广州市星翼电子科技有限公司 2009-2019
    6 M2 R. e7 I% D
12. //All rights reserved                                      
    
13. //////////////////////////////////////////////////////////////////////////////////
    0 `0 z" C2 p) j
14. 
    
15. 
    
16. //内存池(32字节对齐)
    
17. __align(32) u8 mem1base[MEM1_MAX_SIZE];                                                    //内部SRAM内存池
    
18. __align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000)));                    //外部SRAM内存池
    ; Q, w, O' J6 H
19. //内存管理表
    & H) A' v5 T0 H, Y* I5 m
20. u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                    //内部SRAM内存池MAP
    
21. u16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE)));    //外部SRAM内存池MAP
    
22. //内存管理参数      
    
23. const u32 memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE};            //内存表大小
    
24. const u32 memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE};                        //内存分块大小
    
25. const u32 memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE};                                //内存总大小
    
26. 
    4 B4 w) b9 v& j+ P+ Z3 w: s+ {
27. 
    
28. //内存管理控制器
    
29. struct _m_mallco_dev mallco_dev=
    - l9 K2 s) G' _- v9 x( l1 d# L0 ^
30. {
    $ C7 _/ m) b! T' x8 I  k3 L
31.     my_mem_init,                //内存初始化
    ' ?* C5 b' p# |+ b7 ^
32.     my_mem_perused,                //内存使用率
    
33.     mem1base,mem2base,            //内存池
    
34.     mem1mapbase,mem2mapbase,    //内存管理状态表
    
35.     0,0,                           //内存管理未就绪
    7 y$ f' {# }4 \" S
36. };
    
37. 
    
38. //复制内存
    " ^2 N/ R# g5 @" e% B
39. //*des:目的地址
    
40. //*src:源地址
    
41. //n:需要复制的内存长度(字节为单位)
    ) N% L, T  F( u' }! Q
42. void mymemcpy(void *des,void *src,u32 n)  
    
43. {  
    & N' h: F: G5 w- P+ Y7 ~# ^% Z
44.     u8 *xdes=des;
    - O. B4 f' u" J8 N' }
45.     u8 *xsrc=src;
    9 F, X" C0 ]) \% B: w% j! y: V. o
46.     while(n--)*xdes++=*xsrc++;  
    2 a5 ~+ Z9 v2 x7 {( V+ m% V
47. }  
    * u- m5 `' D. E/ S: u9 C6 H4 e* `
48. //设置内存
    ; d# C0 f- [( t3 N& b; b3 Q) i
49. //*s:内存首地址
    
50. //c :要设置的值
    / a5 R7 P) ?1 O) V) f* H) C8 b
51. //count:需要设置的内存大小(字节为单位)
    4 N1 ]& C5 r+ q' r6 ~
52. void mymemset(void *s,u8 c,u32 count)  
    
53. {  
    * d6 N! H$ r. a0 l6 N* \; h3 ?
54.     u8 *xs = s;  
    ; y9 \" J$ p: }# p0 q+ d$ d
55.     while(count--)*xs++=c;  
    " H& v' ]) T+ Z$ Y3 r
56. }      
    
57. //内存管理初始化  
    4 T& ~8 J/ z! C5 n" E/ s
58. //memx:所属内存块
    ! @8 S# x5 {" R* Y( k5 q
59. void my_mem_init(u8 memx)  
    
60. {  
    " `2 i' ]: l4 h3 i/ c% ]
61.     mymemset(mallco_dev.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零  
    1 _' ]9 B8 }! _3 c8 U
62.     mymemset(mallco_dev.membase[memx], 0,memsize[memx]);    //内存池所有数据清零  
    ! U4 E2 W' Y- Q
63.     mallco_dev.memrdy[memx]=1;                                //内存管理初始化OK  
    
64. }  
    
65. //获取内存使用率
    " @5 a* Y& z! m! n9 T" N
66. //memx:所属内存块
    / z: \4 E% l0 O2 l
67. //返回值:使用率(0~100)
    ' y( W6 `+ q5 n, h' V% f
68. u8 my_mem_perused(u8 memx)  
    
69. {  
    
70.     u32 used=0;  
    
71.     u32 i;  
    , H2 `9 e5 P' K  A! u
72.     for(i=0;i<memtblsize[memx];i++)  
    " f0 E8 u2 C; J5 g4 z3 |/ ^+ y- r! a
73.     {  
    
74.         if(mallco_dev.memmap[memx][i])used++;
    0 e' b- ]4 m0 u! h! _. n
75.     }
    
76.     return (used*100)/(memtblsize[memx]);  
    
77. }  
    
78. //内存分配(内部调用)
    + j2 P' q: k5 r* h1 K0 Z0 a: w
79. //memx:所属内存块
    ( W5 p4 n* U0 x' R3 w9 j( {
80. //size:要分配的内存大小(字节)
    
81. //返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址
    
82. u32 my_mem_malloc(u8 memx,u32 size)  
    ' ^9 g& U2 O" E, d
83. {  
    / [2 r; e  N. [0 y: \/ D% l
84.     signed long offset=0;  
    ; t: Q( {9 R$ e$ v4 N& X
85.     u32 nmemb;    //需要的内存块数  
    * l& R! G+ b" e$ S+ P
86.     u32 cmemb=0;//连续空内存块数
    3 V$ X2 {# z, p, ]  e
87.     u32 i;  
    
88.     if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化
    
89.     if(size==0)return 0XFFFFFFFF;//不需要分配
    
90.     nmemb=size/memblksize[memx];      //获取需要分配的连续内存块数
    
91.     if(size%memblksize[memx])nmemb++;  
    ) }3 ]$ z6 u, \9 K
92.     for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区  
    
93.     {     
    
94.         if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加
    
95.         else cmemb=0;                                //连续内存块清零
    
96.         if(cmemb==nmemb)                            //找到了连续nmemb个空内存块
    
97.         {
    
98.             for(i=0;i<nmemb;i++)                      //标注内存块非空
    
99.             {  
    
100.                 mallco_dev.memmap[memx][offset+i]=nmemb;  
     
101.             }  
     / b* E( }7 W" Y8 O' A: G
102.             return (offset*memblksize[memx]);//返回偏移地址  
     
103.         }
     
104.     }  
     
105.     return 0XFFFFFFFF;//未找到符合分配条件的内存块  
     
106. }  
     
107. //释放内存(内部调用)
     * ?1 U# c' Q* L. |' r
108. //memx:所属内存块
     
109. //offset:内存地址偏移
     
110. //返回值:0,释放成功;1,释放失败;  
     ) c6 n# o9 d! D
111. u8 my_mem_free(u8 memx,u32 offset)  
     / D  f/ T1 g5 ^4 y# q' X! F* z" `
112. {  
     6 ^0 b7 L6 B# l4 i
113.     int i;  
     
114.     if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化
     
115.     {
     % {  u  O( d: q4 ^1 B
116.         mallco_dev.init(memx);   
     
117.         return 1;//未初始化  
     0 T$ |5 f- s% {0 m+ p5 n
118.     }  
     " u( ?4 D9 W  E
119.     if(offset<memsize[memx])//偏移在内存池内.
     
120.     {  
     
121.         int index=offset/memblksize[memx];            //偏移所在内存块号码  
     + R- q2 F7 ~) k9 l+ j% d% q' n+ m; I
122.         int nmemb=mallco_dev.memmap[memx][index];    //内存块数量
     & Y5 i/ K$ |3 \& v. ^0 ]
123.         for(i=0;i<nmemb;i++)                          //内存块清零
     
124.         {  
     
125.             mallco_dev.memmap[memx][index+i]=0;  
     ) K+ u! J/ b' I7 v% O
126.         }  
     3 I% I; \8 @. ?7 Y: L
127.         return 0;  
     
128.     }else return 2;//偏移超区了.  
     
129. }  
     5 w3 v/ g) b  H! S$ |0 @
130. //释放内存(外部调用)
     1 u7 _4 n0 u% `' R1 {
131. //memx:所属内存块
     
132. //ptr:内存首地址
     
133. void myfree(u8 memx,void *ptr)  
     % U2 `2 n* ?  A2 W3 x
134. {  
       v- G6 D, G/ I$ b- j
135.     u32 offset;   
     & n! ~. o: P3 e0 r/ Z  m
136.     if(ptr==NULL)return;//地址为0.  
     
137.      offset=(u32)ptr-(u32)mallco_dev.membase[memx];     
     , o: K3 T/ n" n- q  d
138.     my_mem_free(memx,offset);    //释放内存      
     & Z# ~0 e: r2 {( y# y0 i% z
139. }  
     ! Y0 E2 @: n% T/ T6 P
140. //分配内存(外部调用)
     3 {  o. j5 p% P- W
141. //memx:所属内存块
     
142. //size:内存大小(字节)
     & f5 E) C  V" Q  J
143. //返回值:分配到的内存首地址.
     
144. void *mymalloc(u8 memx,u32 size)  
     7 a( T3 L4 n' D+ r8 e
145. {  
     3 P& X' @3 A3 a2 G7 b* k
146.     u32 offset;   
     
147.     offset=my_mem_malloc(memx,size);                     
     " m* b6 ]' {' A" W& f+ Y
148.     if(offset==0XFFFFFFFF)return NULL;  
     
149.     else return (void*)((u32)mallco_dev.membase[memx]+offset);  
     
150. }  
     $ l/ B0 G, q8 f( u: |2 |
151. //重新分配内存(外部调用)
     $ M" c( d1 F; X# b9 t! U- Q
152. //memx:所属内存块
     # {# P, h+ U: ?: w. \
153. //*ptr:旧内存首地址
     9 v) ?, Q: J$ m: N
154. //size:要分配的内存大小(字节)
     2 {% l: w3 [1 V4 Z
155. //返回值:新分配到的内存首地址.
     
156. void *myrealloc(u8 memx,void *ptr,u32 size)  
     
157. {  
     + [3 S( b  T: ]( k1 }$ r
158.     u32 offset;   
     : X  X* f2 e/ o& M% b# {) }
159.     offset=my_mem_malloc(memx,size);      
     + F5 @) r$ ~% h% F- Q
160.     if(offset==0XFFFFFFFF)return NULL;     
     
161.     else  
     $ L/ ^* B8 i/ j
162.     {                                         
     
163.         mymemcpy((void*)((u32)mallco_dev.membase[memx]+offset),ptr,size);    //拷贝旧内存内容到新内存   
     
164.         myfree(memx,ptr);                                                        //释放旧内存
     
165.         return (void*)((u32)mallco_dev.membase[memx]+offset);                  //返回新内存首地址
     - N4 Z; \, W! I; t! T. h
166.     }  
     
167. }

复制代码

* X; ~, x# N. {' R3 n- ]

. }) o7 T9 G2 a" r, h7 y4 w7 E: D

战舰板和迷你板的内存管理有一点差别，迷你板只管理内部没有外部，思想完全一样

1. 思想：将内存池分为块，首先定义每个块的字节数，和内存池的总字节数，用总字节数除以每个块的字节数得到块数

2. 内存池，实际上就是一个数组

3. 内存管理块，实际也是一个数组，总元素个数为内存块数，每个元素对应一个内存块，该元素非零时表示该内存块没有被占用

4. 将第一步中的信息用数组保存起来，方便后面的函数调用

5. 将内存抽象为一个结构体，传入的参数分别是，初始化函数，占用率函数，两个内存池（数组）的基地址，两个内存管理状态表（两个u16数组），两个内存池的就绪布尔值

9 R; |, m: {  n6 o! r% ?

6. 初始化函数，实际上就是将指定内存池（数组）内面的内容全部用0填充，将内存状态表（u16数组）全部用0填充，然后将该内存池的就绪布尔变量置一

7. 计算内存使用率，注意：得到的是块使用的比率，而不是字节使用的比率

8. 复制，就是按字节依次赋值内容

9. 从起始位置将连续count个字节的区域用c填充

10. 分配内存（内部调用），成功：返回相对于数组首地址的偏移地址。

　　->判断指定的内存池是否已经初始化

　　->若传入参数为0，表示不需要分配，直接返回

　　->通过所需字节数对每个块的字节数分别取整，取余得到所需的连续块数

　　->从最后一个块往前面寻找所需的连续块，例如所需的块为3，当找到连续2块而，下一块已经被使用时，则将已经找的的连续块数清零，再在前面找连续的3块

　　->返回的偏移地址为所需连续块的起始块相对于内存池的偏移地址

　　->将即将用到的内存块对应的内存管理表中的元素置为所需的连续块数

11. 分配内存，首先判断偏移地址是否正确，然后返回连续块的首地址

12. 扩大分配内存，首先分配一个指定的内存，再将旧内存里面的内容拷贝到新内存（这里感觉战舰的源码有问题，旧的内存里面原来没有size个元素，却拷贝size个元素到新的空间），

　　最后释放旧的内存空间，返回新的内存（块）首地址

13. 清除连续的内存块，成功：返回0

　　->首先通过偏移地址除以每个块的字节数，得到起始块的序号

　　->读取起始块对应的内存控制表元素，得到从起始块开始共要清除多少个连续的块

　　->所谓的清除，实际上只是将对应的内存控制表的元素清零，内存中的值未清零。

　　->为某个对象分配元素时，是分配的连续块，清除时，也是清除这几个连续块，不同对象占用不同的连续块，清除时，不会影响其他对象。

8 A  Y5 A3 F5 ^

14. 内存释放函数，首先得出偏移地址，然后，调用上一步的函数释放内存