haproxy内存池概述
内存池按照类型分类，每个类型的内存池都有一个名字，用链表记录空闲的内存块，每个内存块大小相等，并按照16字节对齐。
haporxy用pool_head 结构记录内存池
struct pool_head {
void **free_list; /* 空闲链表 */
struct list list; /* 双向链表，链接每种类型的内存池 */
unsigned int used; /* 使用了多少内存块 */
unsigned int allocated; /* 分配了多少内存块 */
unsigned int limit; /* 内存块上限 */
unsigned int minavail; /* 最少保留几个，回收时不会全部回收 */
unsigned int size; /* 内存块大小 */
unsigned int flags; /* 能否共享，类型不同，但大小相同的，能否共享一个pool_head */
unsigned int users; /* 内存池有几个使用者 */
char name[12]; /* 内存池名称 */
};
在程序执行过程中，产生的内存池，很有可能按照大小，排列成如下方式：
内存池的创建
haproxy创建内存池时，会先检查内存池中，有没有与所需大小相同的内存池，有且内存池可共享，将pool_head.users++。若没有，则新创建一个内存池。
struct pool_head *create_pool(char *name, unsigned int size, unsigned int flags)
{
struct pool_head *pool;
struct pool_head *entry;
struct list *start;
unsigned int align;
//按照16字节对齐
align = 16;
size = (size + align - 1) & -align;
//pools是全局变量，内存池的头节点
start = &pools;
pool = NULL;
list_for_each_entry(entry, &pools, list) {
if (entry->size == size) {
if (flags & entry->flags & MEM_F_SHARED) {//大小相等且可共享
pool = entry;
break;
}
}
else if (entry->size > size) { //内存池按照大小排序，新pool_head，插在适当位置
start = &entry->list;
break;
}
}
//创建一个新的内存池
if (!pool) {
pool = CALLOC(1, sizeof(*pool));
if (!pool)
return NULL;
if (name)
strlcpy2(pool->name, name, sizeof(pool->name));
pool->size = size;
pool->flags = flags;
LIST_ADDQ(start, &pool->list);
}
pool->users++;
return pool;
}
内存申请
create_pool仅仅是申请了内存池的类型，还没有具体分配内存，分配内存的工作由pool_refill_alloc来完成
void *pool_refill_alloc(struct pool_head *pool)
{
void *ret;
//如果可申请的内存块有上限，且已达上限，不再申请
if (pool->limit && (pool->allocated >= pool->limit))
return NULL;
ret = MALLOC(pool->size);
//如果申请失败，pool_gc2()垃圾回收，然后再申请一次，再失败就放弃
if (!ret) {
pool_gc2();
ret = MALLOC(pool->size);
if (!ret)
return NULL;
}
pool->allocated++;
pool->used++;
return ret;
}
其中，pool_gc2()垃圾回收函数，会遍历所有内存池，并释放空闲内存块（留下minavail的数量）。
使用者申请内存，不是直接调用pool_refill_alloc，而是通过调用pool_alloc2，如果free_list中没有空闲内存了，则调用pool_refill_alloc申请下内存。如果还有空闲内存，则使用第一块内存，free_list指向下一块。
#define pool_alloc2(pool) \
({ \
void *__p; \
if ((__p = pool->free_list) == NULL) \
__p = pool_refill_alloc(pool); \
else { \
pool->free_list = *(void **)pool->free_list; \
pool->used++; \
} \
__p; \
})
内存释放
如果内存块的使用者，在申请内存块后，不主动释放内存块，那么销毁内存池后，内存块将无法回到内存。所以，必须注意，要主动释放内存块。
内存块的释放很简单，将内存块直接放到空闲链表的第一个节点就行。
#define pool_free2(pool, ptr) \
({ \
*(void **)ptr = (void *)pool->free_list; \
pool->free_list = (void *)ptr; \
pool->used--; \
pool_gc2_ifneed(pool); \
})
销毁内存池
内存池的销毁很简单，释放所有空闲内存块，然后释放内存池。如果还有使用中的内存（pool->used != 0），停止释放
void *pool_destroy2(struct pool_head *pool)
{
if (pool) {
pool_flush2(pool);
if (pool->used)
return pool;
pool->users--;
if (!pool->users) {
LIST_DEL(&pool->list);
FREE(pool);
}
}
return NULL;
}
其中, pool_flush2函数会直接释放掉所有空闲内存
void pool_flush2(struct pool_head *pool)
{
void *temp, *next;
if (!pool)
return;
next = pool->free_list;
while (next) {
temp = next;
next = *(void **)temp;
pool->allocated--;
FREE(temp);
}
pool->free_list = next;
}