本文分享自华为云社区《超越内存限制：深入探索内存池的工作原理与实现》，作者：Lion Long。
一、引言
为什么需要内存池？
在系统应用层面，程序开发使用的都是虚拟内存。物理内存是底层的，只有底层程序（比如驱动、固件等）可以接触到。
程序通常能管理的内存主要是堆和共享内存（mmap）。应用层所谓的内存管理，主要是对堆上的内存池进行管理。
程序使用内存时，需要申请内存，通过调用 malloc() / callol()；使用完之后需要释放内存，调用 free()。程序运行时会不断的申请内存、释放内存，会发现内存到后面可能出现不可控制的状态，比如还有总可用内存，但是无法分配下来了，这就是内存碎片，内存有很多的小窗口存在。
因此，需要内存管理，从而有内存池存在。通过内存管理避免内存碎片以及避免频繁的申请、释放内存。
new 和 malloc/callol 关系：new 是关键字，内部调用的是 malloc/callol，delete 和 free 一样，是对内存释放。
二、内存管理方式
分配内存的时候，分配的大小以及何时分配何时释放都是不确定的。因此，针对不同的常见有不同的内存管理方式。
（1）不管需要的内存大小，每次分配固定大小的内存。这可以有效的避免内存碎片，但是内存利用率低。
（2）以 2n 累积内存池。可以提升内存的利用率，但是回收是一个很大的工程，没办法做到两块相邻的内存合在一起。
（3）大、小块。内存池中分大小块，申请内存大小大于某个值定为大块、否则是小块，内部使用链表串联。
三、posix_memalign()与 malloc()
malloc / alloc 函数原型：
#include <stdlib.h>
void *malloc(size_t size);void free(void *ptr);void *calloc(size_t nmemb, size_t size);void *realloc(void *ptr, size_t size);
复制代码
描述：
malloc 函数的作用是分配大小字节并返回分配内存的指针。分配的内存未初始化。size=0，则 malloc 返回 NULL 或唯一的指针值，稍后可以成功传递给 free()。
free 函数释放 ptr 指向的内存空间，该空间必须是先前调用 malloc()、calloc()或 realloc()返回的。否则，或者如果之前已经调用了 free(ptr)，则会发生未定义的行为。如果 ptr 为空，则不执行任何操作。
calloc 函数为每个 size 字节的 nmemb 元素数组分配内存，并返回分配内存的指针。内存被初始化为零。如果 nmemb 或 size 为 0，则 calloc()返回 NULL 或唯一的指针值，稍后可以成功传递给 free()。
realloc 函数将 ptr 指向的内存块大小更改为 size 字节。从区域开始到新旧尺寸的最小值，内容将保持不变。如果新大小大于旧大小，则不会初始化添加的内存。如果 ptr 为空，则对于 size 的所有值，调用等同于 malloc(size)；如果 size 等于零，且 ptr 不为空，则调用等同于 free(ptr)。除非 ptr 为空，否则它必须是通过先前调用 malloc()、calloc()或 realloc()返回的。如果指向的区域被移动，则执行 free(ptr)。
返回值：
malloc()和 calloc()函数返回一个指向已分配内存的指针，该指针适合任何内置类型。出现错误时，这些函数返回 NULL。如果成功调用大小为零的 malloc()，或者成功调用 nmemb 或大小等于零的 calloc()，也可能返回 NULL。
free()函数不返回任何值。
realloc()返回一个指向新分配内存的指针，该指针适合任何内置类型，可能与 ptr 不同，如果请求失败，则为 NULL。如果 size=0，则返回 NULL 或适合传递给 free()的指针。如果 realloc()失败，则原始块保持不变；它不会被释放或移动。
错误：
calloc（）、malloc（）和 realloc（）可能会失败，并出现以下错误：
ENOMEM，内存不足。应用程序可能会达到 getrlimit()中描述的 RLIMIT_AS 或 RLIMIT-DATA 限制。
malloc / alloc 分配内存是有限制的，可能不能分配超过 4k 的内存的，为了内分配大内存，需要使用 posix_memalign 函数。
posix_memalign 函数原型：
#include <stdlib.h>
int posix_memalign(void **memptr, size_t alignment, size_t size);void *aligned_alloc(size_t alignment, size_t size);void *valloc(size_t size);
#include <malloc.h>
void *memalign(size_t alignment, size_t size);void *pvalloc(size_t size);
复制代码
描述：
函数 posix_memalign 分配 size 字节，并将分配内存的地址放在 memptr 中。分配内存的地址将是 alignment 的倍数，必须是 2 的幂和 sizeof（void）的倍数。如果大小为 0，则放置在*memptr 中的值要么为空，要么是唯一的指针值，稍后可以成功传递给 free()。
返回：
posix_memalign（）在成功时返回零，或在失败时错误值。在调用 posix_memalign（）之后，errno 的值是不确定的。
错误值：
四、对齐计算
要分配一个以指定大小对齐的内存，可以使用如下公式：
假设要分配大小为 n，对齐方式为 x，那么 size=(n+(x-1)) & (~(x-1))。
举个例子：
n=17，x=4。即申请大小为 17，对齐为 4。则计算出对齐后的大小应该为(17+4-1)&(~(4-1))=20；
用二进制来计算，（0001 0001 + 0011）&（1111 1100）=0001 0100
// 对齐#define mp_align(n, alignment) (((n)+(alignment-1)) & ~(alignment-1))#define mp_align_ptr(p, alignment) (void *)((((size_t)p)+(alignment-1)) & ~(alignment-1))
复制代码
五、内存池的具体实现
5.1、内存池的定义
typedef struct mp_large_s { struct mp_large_s *next; void *alloc;
}mp_large_t;
typedef struct mp_node_s { unsigned char *last; // last之前为已使用的内存 unsigned char *end; // last到end之间为可分配内存 struct mp_node_s *next; size_t failed;}mp_node_t;
typedef struct mp_pool_s { size_t max;
mp_node_t* current; mp_large_t* large;
mp_node_t head[0];
}mp_pool_t;
复制代码
5.2、内存池的创建
mp_pool_t *mp_create_pool(size_t size){ mp_pool_t *p; // malloc无法分配超过4k的内存,size + sizeof(mp_pool_t) + sizeof(mp_node_s)保证有size大小可用 int ret = posix_memalign((void*)&p, MP_ALIGNMENT, size + sizeof(mp_pool_t) + sizeof(mp_node_t)); if (ret) return NULL;
p->max = size; p->current = p->head; p->large = NULL;
//(unsigned char*)(p + 1) // (unsigned char*)p + sizeof(mp_pool_t) p->head->last = (unsigned char*)p + sizeof(mp_pool_t)+sizeof(mp_node_t); p->head->end = p->head->last + size; p->head->failed = 0;
return p;}
复制代码
5.3、内存池的销毁
void mp_destory_pool(mp_pool_t *pool) { mp_node_t *h, *n; mp_large_t *l;
for (l = pool->large; l; l = l->next) { if (l->alloc) { free(l->alloc); } }
h = pool->head->next;
while (h) { n = h->next; free(h); h = n; }
free(pool);}
复制代码
5.4、内存池的重置
void mp_reset_pool(mp_pool_t *pool) {
mp_node_t *h; mp_large_t *l;
for (l = pool->large; l; l = l->next) { if (l->alloc) { free(l->alloc); } }
pool->large = NULL;
for (h = pool->head; h; h = h->next) { h->last = (unsigned char *)h + sizeof(mp_node_t); }
}
复制代码
5.5、内存池分配小块
void *mp_alloc_small(mp_pool_t *pool, size_t size){ unsigned char *m;
struct mp_node_s *h = pool->head; size_t psize = (size_t)(h->end - (unsigned char *)h); int ret = posix_memalign((void*)&m, MP_ALIGNMENT, psize); if (ret) return NULL;
mp_node_t *p, *new_node, *current;
new_node = (mp_node_t *)m; new_node->next = NULL; new_node->end = m + psize; new_node->failed = 0; m += sizeof(mp_node_t); m = mp_align_ptr(m, MP_ALIGNMENT); new_node->last += size;
current = pool->current; for (p = current; p->next; p = p->next) { // 如存在多次分配失败，current不再指向此node if (p->failed++ > 4) { current = p->next; } } p->next = new_node; pool->current = current ? current : new_node;
return m;}
复制代码
5.6、内存池分配大块
static void *mp_alloc_large(mp_pool_t *pool, size_t size) { void *p = NULL; int ret = posix_memalign((void*)&p, MP_ALIGNMENT, size); if (ret) return NULL; mp_large_t *large; // 查找是否有已经释放的large，在large list里面找到一个 null的节点 size_t n = 0; for (large = pool->large; large; large = large->next) { if (large->alloc == NULL) { large->alloc = p; return p; } // 避免遍历链条太长 if (n++ > 3) break; }
// 大内存块的头作为小块保存在small中 large = mp_alloc_small(pool, sizeof(mp_large_t));
// 头插法 large->alloc = p; large->next = pool->large; pool->large = large;}
复制代码
5.7、申请内存
void *mp_malloc(mp_pool_t *pool, size_t size){ if (size > pool->max) return mp_alloc_large(pool, size); mp_node_t *p = pool->current; while (p) { if (p->end - p->last < size) { p = p->next; continue; }
unsigned char *m = mp_align_ptr(p->last, MP_ALIGNMENT); p->last = m + size; return m; } return mp_alloc_small(pool, size);}
void *mp_calloc(mp_pool_t *pool, size_t size) {
void *p = mp_malloc(pool, size); if (p) { memset(p, 0, size); }
return p;
}
复制代码
5.8、释放内存
void mp_free(mp_pool_t *pool, void *p){ mp_large_t *l; for (l = pool->large; l; l = l->next) { if (p == l->alloc) { free(l->alloc); l->alloc = NULL; return; } }}
复制代码
5.9、完整示例代码
为避免文章篇幅过长，完整代码已上传 gitee：内存池完整示例代码。
总结
设计一个内存池，可以有效的避免内存碎片和避免频繁的内存创建‘释放。程序通常能管理的内存主要是堆和共享内存（mmap）。应用层所谓的内存管理，主要是对堆上的内存池进行管理。
内存管理方式，使用比较多的是以 2n 堆叠内存池以及大小块方式管理。nginx 就是使用的大小块方式管理内存；为每个 IO 建立自己的内存池，IO 生命周期结束再释放内存。
点击关注，第一时间了解华为云新鲜技术~
评论