带你用纯C实现一个内存池（图文）

一路上

一、前言

本文从零到一，手把手实现一个内存池。比较出名的内存池有jemalloc和tcmalloc，这两个都是全局内存池，比较推荐使用tcmalloc。

二、为什么要用内存池

为什么要用内存池？首先，在7 * 24h的服务器中如果不使用内存池，而使用malloc和free，那么就非常容易产生内存碎片，早晚都会申请内存失败；并且在比较复杂的代码或者继承的屎山中，非常容易出现内存泄漏导致mmo的问题。

为了解决这两个问题，内存池就应运而生了。内存池预先分配一大块内存来做一个内存池，业务中的内存分配和释放都由这个内存池来管理，内存池内的内存不足时其内部会自己申请。所以内存碎片的问题就交由内存池的算法来优化，而内存泄漏的问题只需要遵守内存池提供的api，就非常容易避免内存泄漏了。

即使出现了内存泄漏，排查的思路也很清晰。1.检查是不是内存池的问题；2.如果不是内存池的问题，就检查是不是第三方库的内存泄漏。

三、内存池的使用场景

全局内存池，一个连接一个内存池(本文实现这个场景的内存池)

四、设计一个内存池

１.总体介绍

由于本文是一个连接一个内存池，所以后续介绍和代码都是以4k为分界线，大于4k的我们认为是大块内存；小于4k的我们认为是小块内存。并且注意这里的4k，并不是严格遵照4096，而是在描述上，用4k比较好描述。

在真正使用内存之前，内存池提前分配一定数量且大小相等的内存块以作备用，当真正被用户调用api分配内存的时候，直接从内存块中获取内存（指小块内存），当内存块不够用了，再有内存池取申请新的内存块。而如果是需要大块内存，则内存池直接申请大块内存再返回给用户。

内存池：就是将这些提前申请的内存块组织管理起来的数据结构，内存池实现原理主要分为分配，回收，扩容三部分。

内存池原理之小块内存：分配=> 内存池预申请一块4k的内存块，这里称为block，即block=4k内存块。当用户向内存池申请内存size小于4k时，内存池从block的空间中划分出去size空间，当再有新申请时，再划分出去。扩容=> 直到block中的剩余空间不足以分配size大小，那么此时内存池会再次申请一块block，再从新的block中划分size空间给用户。回收=> 每一次申请小内存，都会在对应的block中引用计数加1，每一次释放小内存时，都会在block中引用计数减1，只有当引用计数为零的时候，才会回收block使他重新成为空闲空间，以便重复利用空间。这样，内存池避免频繁向内核申请/释放内存，从而提高系统性能。

内存池原理之大块内存：分配=> 因为大块内存是大于4k的，所以内存池不预先申请内存，也就是用户申请的时候，内存池再申请内存，然后返回给用户。扩容=> 大块内存不存在扩容。回收=> 对于大块内存来说，回收就直接free掉即可。

上面理论讲完了，下面来介绍如何管理小块内存和大块内存。

２.小块内存的分配与管理

在创建内存池的时候，会预先申请一块4k的内存，并且在起始处将pool的结构体和node的结构体放进去，从last开始一直到end都是空闲内存，<last , end >中间的区域就用来存储小块内存。每一次mp_malloc，就将last指针后移，直到 e n d ? l a s t < s i z e end - last < size end?last<size 时，进行扩容，将新block的last后移即可。

初始状态：

分配内存：

扩容：

３.大块内存的分配与管理

对于大块内存，前面已经说了，用户申请的时候，内存池才申请

申请一块大内存：

再申请一块大内存：

五、内存池代码实现

１.向外提供的api

• mp_create_pool：创建一个线程池，其核心是创建struct mp_pool_s这个结构体，并申请4k内存，将各个指针指向上文初始状态的图一样。
• mp_destroy_pool：销毁内存池，遍历小块结构体和大块结构体，进行free释放内存
• mp_malloc：提供给用户申请内存的api
• mp_calloc：通过mp_malloc申请内存后置零，相当于calloc
• mp_free：释放由mp_malloc返回的内存
• mp_reset_pool：将block的last置为初始状态，销毁所有大块内存
• monitor_mp_poll：监控内存池状态
  

1. struct mp_pool_s *mp_create_pool(size_t size);
   
2. 
   
3. void mp_destroy_pool(struct mp_pool_s *pool);
   
4. 
   
5. void *mp_malloc(struct mp_pool_s *pool, size_t size);
   
6. 
   
7. void *mp_calloc(struct mp_pool_s *pool, size_t size);
   
8. 
   
9. void mp_free(struct mp_pool_s *pool, void *p);
   
10. 
    
11. void mp_reset_pool(struct mp_pool_s *pool);
    
12. 
    
13. void monitor_mp_poll(struct mp_pool_s *pool, char *tk);

复制代码

２.相关结构体的定义

mp_pool_s 就是整个内存池的管理结构，我们做的内存池是一个连接一个内存池，所以对于整个程序而言，内存池对象是有很多个的。

可能读者会有疑问，有了head，为什么还有current，是因为如果一个block剩余空间小于size超过一定次数后，将current指向下一个block，这样就加快内存分配效率，减少遍历次数。

1. //每4k一block结点
   
2. struct mp_node_s {
   
3.     unsigned char *end;//块的结尾
   
4.     unsigned char *last;//使用到哪了
   
5.     struct mp_node_s *next;//链表
   
6.     int quote;//引用计数
   
7.     int failed;//失效次数
   
8. };
   
9. 
   
10. struct mp_large_s {
    
11.     struct mp_large_s *next;//链表
    
12.     int size;//alloc的大小
    
13.     void *alloc;//大块内存的起始地址
    
14. };
    
15. 
    
16. struct mp_pool_s {
    
17.     struct mp_large_s *large;
    
18.     struct mp_node_s *head;
    
19.     struct mp_node_s *current;
    
20. };

复制代码

３.内存对齐

访问速度是内存对齐的原因之一，另外一个原因是某些平台(arm)不支持未内存对齐的访问

在4k里面划分内存，那么必然有很多地方是不对齐的，所以这里提供两个内存对齐的函数。那么为什么要内存对齐呢？其一：提高访问速度；其二：某些平台arm不支持未对其的内存访问，会出错。

1. #define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
   
2. #define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))

复制代码

４.创建与销毁内存池

创建一个线程池，其核心是创建struct mp_pool_s这个结构体，并申请4k内存，将各个指针指向上文初始状态的图一样。
销毁内存池，遍历小块结构体和大块结构体，进行free释放内存。

1. //创建内存池
   
2. struct mp_pool_s *mp_create_pool(size_t size) {
   
3.     struct mp_pool_s *pool;
   
4.     if (size < PAGE_SIZE || size % PAGE_SIZE != 0) {
   
5.         size = PAGE_SIZE;
   
6.     }
   
7.     //分配4k以上不用malloc，用posix_memalign
   
8.     /*
   
9.         int posix_memalign (void **memptr, size_t alignment, size_t size);
   
10.      */
    
11. 
    
12.     int ret = posix_memalign((void **) &pool, MP_ALIGNMENT, size); //4K + mp_pool_s
    
13.     if (ret) {
    
14.         return NULL;
    
15.     }
    
16.     pool->large = NULL;
    
17.     pool->current = pool->head = (unsigned char *) pool + sizeof(struct mp_pool_s);
    
18.     pool->head->last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
    
19.     pool->head->end = (unsigned char *) pool + PAGE_SIZE;
    
20.     pool->head->failed = 0;
    
21. 
    
22.     return pool;
    
23. }
    
24. 
    
25. //销毁内存池
    
26. void mp_destroy_pool(struct mp_pool_s *pool) {
    
27.     struct mp_large_s *large;
    
28.     for (large = pool->large; large; large = large->next) {
    
29.         if (large->alloc) {
    
30.             free(large->alloc);
    
31.         }
    
32.     }
    
33. 
    
34.     struct mp_node_s *cur, *next;
    
35.     cur = pool->head->next;
    
36. 
    
37.     while (cur) {
    
38.         next = cur->next;
    
39.         free(cur);
    
40.         cur = next;
    
41.     }
    
42.     free(pool);
    
43. }

复制代码

５.提供给用户的内存申请api

申请的内存以size做区分，如果大于4k就分配大块内存，小于4k就去block里面划分。

1. //分配内存
   
2. void *mp_malloc(struct mp_pool_s *pool, size_t size) {
   
3.     if (size <= 0) {
   
4.         return NULL;
   
5.     }
   
6.     if (size > PAGE_SIZE - sizeof(struct mp_node_s)) {
   
7.         //large
   
8.         return mp_malloc_large(pool, size);
   
9.     }
   
10.     else {
    
11.         //small
    
12.         unsigned char *mem_addr = NULL;
    
13.         struct mp_node_s *cur = NULL;
    
14.         cur = pool->current;
    
15.         while (cur) {
    
16.             mem_addr = mp_align_ptr(cur->last, MP_ALIGNMENT);
    
17.             if (cur->end - mem_addr >= size) {
    
18.                 cur->quote++;//引用+1
    
19.                 cur->last = mem_addr + size;
    
20.                 return mem_addr;
    
21.             }
    
22.             else {
    
23.                 cur = cur->next;
    
24.             }
    
25.         }
    
26.         return mp_malloc_block(pool, size);// open new space
    
27.     }
    
28. }
    
29. void *mp_calloc(struct mp_pool_s *pool, size_t size) {
    
30.     void *mem_addr = mp_malloc(pool, size);
    
31.     if (mem_addr) {
    
32.         memset(mem_addr, 0, size);
    
33.     }
    
34.     return mem_addr;
    
35. }

复制代码

６.小块内存block扩容

所有的block都 e n d ? l a s t < s i z e end - last < size end?last<size 时，进行扩容，将新block的last后移即可。

1. //new block 4k
   
2. void *mp_malloc_block(struct mp_pool_s *pool, size_t size) {
   
3.     unsigned char *block;
   
4.     int ret = posix_memalign((void **) &block, MP_ALIGNMENT, PAGE_SIZE); //4K
   
5.     if (ret) {
   
6.         return NULL;
   
7.     }
   
8.     struct mp_node_s *new_node = (struct mp_node_s *) block;
   
9.     new_node->end = block + PAGE_SIZE;
   
10.     new_node->next = NULL;
    
11. 
    
12.     unsigned char *ret_addr = mp_align_ptr(block + sizeof(struct mp_node_s), MP_ALIGNMENT);
    
13. 
    
14.     new_node->last = ret_addr + size;
    
15.     new_node->quote++;
    
16. 
    
17.     struct mp_node_s *current = pool->current;
    
18.     struct mp_node_s *cur = NULL;
    
19. 
    
20.     for (cur = current; cur->next; cur = cur->next) {
    
21.         if (cur->failed++ > 4) {
    
22.             current = cur->next;
    
23.         }
    
24.     }
    
25.     //now cur = last node
    
26.     cur->next = new_node;
    
27.     pool->current = current;
    
28.     return ret_addr;
    
29. }

复制代码

７.分配大块内存

1. //size>4k
   
2. void *mp_malloc_large(struct mp_pool_s *pool, size_t size) {
   
3.     unsigned char *big_addr;
   
4.     int ret = posix_memalign((void **) &big_addr, MP_ALIGNMENT, size); //size
   
5.     if (ret) {
   
6.         return NULL;
   
7.     }
   
8. 
   
9.     struct mp_large_s *large;
   
10.     //released struct large resume
    
11.     int n = 0;
    
12.     for (large = pool->large; large; large = large->next) {
    
13.         if (large->alloc == NULL) {
    
14.             large->size = size;
    
15.             large->alloc = big_addr;
    
16.             return big_addr;
    
17.         }
    
18.         if (n++ > 3) {
    
19.             break;// 为了避免过多的遍历，限制次数
    
20.         }
    
21.     }
    
22.     large = mp_malloc(pool, sizeof(struct mp_large_s));
    
23.     if (large == NULL) {
    
24.         free(big_addr);
    
25.         return NULL;
    
26.     }
    
27.     large->size = size;
    
28.     large->alloc = big_addr;
    
29.     large->next = pool->large;
    
30.     pool->large = large;
    
31.     return big_addr;
    
32. }

复制代码

８.释放内存

如果是大块内存，找到之后直接释放；如果是小块内存，将引用计数减1，如果引用计数为0则重置last。

1. //释放内存
   
2. void mp_free(struct mp_pool_s *pool, void *p) {
   
3.     struct mp_large_s *large;
   
4.     for (large = pool->large; large; large = large->next) {//大块
   
5.         if (p == large->alloc) {
   
6.             free(large->alloc);
   
7.             large->size = 0;
   
8.             large->alloc = NULL;
   
9.             return;
   
10.         }
    
11.     }
    
12.     //小块 引用-1
    
13.     struct mp_node_s *cur = NULL;
    
14.     for (cur = pool->head; cur; cur = cur->next) {
    
15. //        printf("cur:%p   p:%p   end:%p\n", (unsigned char *) cur, (unsigned char *) p, (unsigned char *) cur->end);
    
16.         if ((unsigned char *) cur <= (unsigned char *) p && (unsigned char *) p <= (unsigned char *) cur->end) {
    
17.             cur->quote--;
    
18.             if (cur->quote == 0) {
    
19.                 if (cur == pool->head) {
    
20.                     pool->head->last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
    
21.                 }
    
22.                 else {
    
23.                     cur->last = (unsigned char *) cur + sizeof(struct mp_node_s);
    
24.                 }
    
25.                 cur->failed = 0;
    
26.                 pool->current = pool->head;
    
27.             }
    
28.             return;
    
29.         }
    
30.     }
    
31. }

复制代码

六、内存池测试

1. //
   
2. // Created by 68725 on 2022/7/26.
   
3. //
   
4. #include <stdlib.h>
   
5. #include <stdio.h>
   
6. #include <string.h>
   
7. 
   
8. #define PAGE_SIZE 4096
   
9. #define MP_ALIGNMENT 16
   
10. #define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))
    
11. #define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))
    
12. 
    
13. //每4k一block结点
    
14. struct mp_node_s {
    
15.     unsigned char *end;//块的结尾
    
16.     unsigned char *last;//使用到哪了
    
17.     struct mp_node_s *next;//链表
    
18.     int quote;//引用计数
    
19.     int failed;//失效次数
    
20. };
    
21. 
    
22. struct mp_large_s {
    
23.     struct mp_large_s *next;//链表
    
24.     int size;//alloc的大小
    
25.     void *alloc;//大块内存的起始地址
    
26. };
    
27. 
    
28. struct mp_pool_s {
    
29.     struct mp_large_s *large;
    
30.     struct mp_node_s *head;
    
31.     struct mp_node_s *current;
    
32. };
    
33. 
    
34. struct mp_pool_s *mp_create_pool(size_t size);
    
35. 
    
36. void mp_destroy_pool(struct mp_pool_s *pool);
    
37. 
    
38. void *mp_malloc(struct mp_pool_s *pool, size_t size);
    
39. 
    
40. void *mp_calloc(struct mp_pool_s *pool, size_t size);
    
41. 
    
42. void mp_free(struct mp_pool_s *pool, void *p);
    
43. 
    
44. void mp_reset_pool(struct mp_pool_s *pool);
    
45. 
    
46. void monitor_mp_poll(struct mp_pool_s *pool, char *tk);
    
47. 
    
48. 
    
49. void mp_reset_pool(struct mp_pool_s *pool) {
    
50.     struct mp_node_s *cur;
    
51.     struct mp_large_s *large;
    
52. 
    
53.     for (large = pool->large; large; large = large->next) {
    
54.         if (large->alloc) {
    
55.             free(large->alloc);
    
56.         }
    
57.     }
    
58. 
    
59.     pool->large = NULL;
    
60.     pool->current = pool->head;
    
61.     for (cur = pool->head; cur; cur = cur->next) {
    
62.         cur->last = (unsigned char *) cur + sizeof(struct mp_node_s);
    
63.         cur->failed = 0;
    
64.         cur->quote = 0;
    
65.     }
    
66. }
    
67. 
    
68. //创建内存池
    
69. struct mp_pool_s *mp_create_pool(size_t size) {
    
70.     struct mp_pool_s *pool;
    
71.     if (size < PAGE_SIZE || size % PAGE_SIZE != 0) {
    
72.         size = PAGE_SIZE;
    
73.     }
    
74.     //分配4k以上不用malloc，用posix_memalign
    
75.     /*
    
76.         int posix_memalign (void **memptr, size_t alignment, size_t size);
    
77.      */
    
78. 
    
79.     int ret = posix_memalign((void **) &pool, MP_ALIGNMENT, size); //4K + mp_pool_s
    
80.     if (ret) {
    
81.         return NULL;
    
82.     }
    
83.     pool->large = NULL;
    
84.     pool->current = pool->head = (unsigned char *) pool + sizeof(struct mp_pool_s);
    
85.     pool->head->last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
    
86.     pool->head->end = (unsigned char *) pool + PAGE_SIZE;
    
87.     pool->head->failed = 0;
    
88. 
    
89.     return pool;
    
90. }
    
91. 
    
92. //销毁内存池
    
93. void mp_destroy_pool(struct mp_pool_s *pool) {
    
94.     struct mp_large_s *large;
    
95.     for (large = pool->large; large; large = large->next) {
    
96.         if (large->alloc) {
    
97.             free(large->alloc);
    
98.         }
    
99.     }
    
100. 
     
101.     struct mp_node_s *cur, *next;
     
102.     cur = pool->head->next;
     
103. 
     
104.     while (cur) {
     
105.         next = cur->next;
     
106.         free(cur);
     
107.         cur = next;
     
108.     }
     
109.     free(pool);
     
110. }
     
111. 
     
112. //size>4k
     
113. void *mp_malloc_large(struct mp_pool_s *pool, size_t size) {
     
114.     unsigned char *big_addr;
     
115.     int ret = posix_memalign((void **) &big_addr, MP_ALIGNMENT, size); //size
     
116.     if (ret) {
     
117.         return NULL;
     
118.     }
     
119. 
     
120.     struct mp_large_s *large;
     
121.     //released struct large resume
     
122.     int n = 0;
     
123.     for (large = pool->large; large; large = large->next) {
     
124.         if (large->alloc == NULL) {
     
125.             large->size = size;
     
126.             large->alloc = big_addr;
     
127.             return big_addr;
     
128.         }
     
129.         if (n++ > 3) {
     
130.             break;// 为了避免过多的遍历，限制次数
     
131.         }
     
132.     }
     
133.     large = mp_malloc(pool, sizeof(struct mp_large_s));
     
134.     if (large == NULL) {
     
135.         free(big_addr);
     
136.         return NULL;
     
137.     }
     
138.     large->size = size;
     
139.     large->alloc = big_addr;
     
140.     large->next = pool->large;
     
141.     pool->large = large;
     
142.     return big_addr;
     
143. }
     
144. 
     
145. //new block 4k
     
146. void *mp_malloc_block(struct mp_pool_s *pool, size_t size) {
     
147.     unsigned char *block;
     
148.     int ret = posix_memalign((void **) &block, MP_ALIGNMENT, PAGE_SIZE); //4K
     
149.     if (ret) {
     
150.         return NULL;
     
151.     }
     
152.     struct mp_node_s *new_node = (struct mp_node_s *) block;
     
153.     new_node->end = block + PAGE_SIZE;
     
154.     new_node->next = NULL;
     
155. 
     
156.     unsigned char *ret_addr = mp_align_ptr(block + sizeof(struct mp_node_s), MP_ALIGNMENT);
     
157. 
     
158.     new_node->last = ret_addr + size;
     
159.     new_node->quote++;
     
160. 
     
161.     struct mp_node_s *current = pool->current;
     
162.     struct mp_node_s *cur = NULL;
     
163. 
     
164.     for (cur = current; cur->next; cur = cur->next) {
     
165.         if (cur->failed++ > 4) {
     
166.             current = cur->next;
     
167.         }
     
168.     }
     
169.     //now cur = last node
     
170.     cur->next = new_node;
     
171.     pool->current = current;
     
172.     return ret_addr;
     
173. }
     
174. 
     
175. //分配内存
     
176. void *mp_malloc(struct mp_pool_s *pool, size_t size) {
     
177.     if (size <= 0) {
     
178.         return NULL;
     
179.     }
     
180.     if (size > PAGE_SIZE - sizeof(struct mp_node_s)) {
     
181.         //large
     
182.         return mp_malloc_large(pool, size);
     
183.     }
     
184.     else {
     
185.         //small
     
186.         unsigned char *mem_addr = NULL;
     
187.         struct mp_node_s *cur = NULL;
     
188.         cur = pool->current;
     
189.         while (cur) {
     
190.             mem_addr = mp_align_ptr(cur->last, MP_ALIGNMENT);
     
191.             if (cur->end - mem_addr >= size) {
     
192.                 cur->quote++;//引用+1
     
193.                 cur->last = mem_addr + size;
     
194.                 return mem_addr;
     
195.             }
     
196.             else {
     
197.                 cur = cur->next;
     
198.             }
     
199.         }
     
200.         return mp_malloc_block(pool, size);// open new space
     
201.     }
     
202. }
     
203. 
     
204. void *mp_calloc(struct mp_pool_s *pool, size_t size) {
     
205.     void *mem_addr = mp_malloc(pool, size);
     
206.     if (mem_addr) {
     
207.         memset(mem_addr, 0, size);
     
208.     }
     
209.     return mem_addr;
     
210. }
     
211. 
     
212. //释放内存
     
213. void mp_free(struct mp_pool_s *pool, void *p) {
     
214.     struct mp_large_s *large;
     
215.     for (large = pool->large; large; large = large->next) {//大块
     
216.         if (p == large->alloc) {
     
217.             free(large->alloc);
     
218.             large->size = 0;
     
219.             large->alloc = NULL;
     
220.             return;
     
221.         }
     
222.     }
     
223.     //小块 引用-1
     
224.     struct mp_node_s *cur = NULL;
     
225.     for (cur = pool->head; cur; cur = cur->next) {
     
226. //        printf("cur:%p   p:%p   end:%p\n", (unsigned char *) cur, (unsigned char *) p, (unsigned char *) cur->end);
     
227.         if ((unsigned char *) cur <= (unsigned char *) p && (unsigned char *) p <= (unsigned char *) cur->end) {
     
228.             cur->quote--;
     
229.             if (cur->quote == 0) {
     
230.                 if (cur == pool->head) {
     
231.                     pool->head->last = (unsigned char *) pool + sizeof(struct mp_pool_s) + sizeof(struct mp_node_s);
     
232.                 }
     
233.                 else {
     
234.                     cur->last = (unsigned char *) cur + sizeof(struct mp_node_s);
     
235.                 }
     
236.                 cur->failed = 0;
     
237.                 pool->current = pool->head;
     
238.             }
     
239.             return;
     
240.         }
     
241.     }
     
242. }
     
243. 
     
244. void monitor_mp_poll(struct mp_pool_s *pool, char *tk) {
     
245.     printf("\r\n\r\n------start monitor poll------%s\r\n\r\n", tk);
     
246.     struct mp_node_s *head = NULL;
     
247.     int i = 0;
     
248.     for (head = pool->head; head; head = head->next) {
     
249.         i++;
     
250.         if (pool->current == head) {
     
251.             printf("current==>第%d块\n", i);
     
252.         }
     
253.         if (i == 1) {
     
254.             printf("第%02d块small block  已使用:%4ld  剩余空间:%4ld  引用:%4d  failed:%4d\n", i,
     
255.                    (unsigned char *) head->last - (unsigned char *) pool,
     
256.                    head->end - head->last, head->quote, head->failed);
     
257.         }
     
258.         else {
     
259.             printf("第%02d块small block  已使用:%4ld  剩余空间:%4ld  引用:%4d  failed:%4d\n", i,
     
260.                    (unsigned char *) head->last - (unsigned char *) head,
     
261.                    head->end - head->last, head->quote, head->failed);
     
262.         }
     
263.     }
     
264.     struct mp_large_s *large;
     
265.     i = 0;
     
266.     for (large = pool->large; large; large = large->next) {
     
267.         i++;
     
268.         if (large->alloc != NULL) {
     
269.             printf("第%d块large block  size=%d\n", i, large->size);
     
270.         }
     
271.     }
     
272.     printf("\r\n\r\n------stop monitor poll------\r\n\r\n");
     
273. }
     
274. 
     
275. 
     
276. 
     
277. int main() {
     
278.     struct mp_pool_s *p = mp_create_pool(PAGE_SIZE);
     
279.     monitor_mp_poll(p, "create memory pool");
     
280. #if 0
     
281.     printf("mp_align(5, %d): %d, mp_align(17, %d): %d\n", MP_ALIGNMENT, mp_align(5, MP_ALIGNMENT), MP_ALIGNMENT,
     
282.            mp_align(17, MP_ALIGNMENT));
     
283.     printf("mp_align_ptr(p->current, %d): %p, p->current: %p\n", MP_ALIGNMENT, mp_align_ptr(p->current, MP_ALIGNMENT),
     
284.            p->current);
     
285. #endif
     
286.     void *mp[30];
     
287.     int i;
     
288.     for (i = 0; i < 30; i++) {
     
289.         mp[i] = mp_malloc(p, 512);
     
290.     }
     
291.     monitor_mp_poll(p, "申请512字节30个");
     
292. 
     
293.     for (i = 0; i < 30; i++) {
     
294.         mp_free(p, mp[i]);
     
295.     }
     
296.     monitor_mp_poll(p, "销毁512字节30个");
     
297. 
     
298.     int j;
     
299.     for (i = 0; i < 50; i++) {
     
300.         char *pp = mp_calloc(p, 32);
     
301.         for (j = 0; j < 32; j++) {
     
302.             if (pp[j]) {
     
303.                 printf("calloc wrong\n");
     
304.                 exit(-1);
     
305.             }
     
306.         }
     
307.     }
     
308.     monitor_mp_poll(p, "申请32字节50个");
     
309. 
     
310.     for (i = 0; i < 50; i++) {
     
311.         char *pp = mp_malloc(p, 3);
     
312.     }
     
313.     monitor_mp_poll(p, "申请3字节50个");
     
314. 
     
315. 
     
316.     void *pp[10];
     
317.     for (i = 0; i < 10; i++) {
     
318.         pp[i] = mp_malloc(p, 5120);
     
319.     }
     
320.     monitor_mp_poll(p, "申请大内存5120字节10个");
     
321. 
     
322.     for (i = 0; i < 10; i++) {
     
323.         mp_free(p, pp[i]);
     
324.     }
     
325.     monitor_mp_poll(p, "销毁大内存5120字节10个");
     
326. 
     
327.     mp_reset_pool(p);
     
328.     monitor_mp_poll(p, "reset pool");
     
329. 
     
330.     for (i = 0; i < 100; i++) {
     
331.         void *s = mp_malloc(p, 256);
     
332.     }
     
333.     monitor_mp_poll(p, "申请256字节100个");
     
334. 
     
335.     mp_destroy_pool(p);
     
336.     return 0;
     
337. }

复制代码

七、nginx内存池对比分析

１.相关结构体定义对比

２.创建内存池对比

３.内存申请对比

作者：cheems