haproxy-代码阅读-内存管理

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-代码阅读-内存管理

内存池的创建

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;
}
上一篇:mysql 基础篇5(mysql语法---数据)


下一篇:c++unsigned char的输出问题