本文分享自華爲雲社區《超越內存限制：深入探索內存池的工作原理與實現》，作者：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的值是不確定的。
錯誤值：
- EINVAL：對齊參數不是2的冪，或者不是sizeof（void*）的倍數。
- ENOMEM：內存不足，無法完成分配請求。
四、對齊計算
要分配一個以指定大小對齊的內存，可以使用如下公式：
假設要分配大小爲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生命週期結束再釋放內存。