內存池的使用給Nginx帶來了很多好處,比如內存使用的便利,邏輯代碼的簡化以及程序性能的提升。
幾個關鍵知識點羅列如下:
(1)函數ngx_palloc()嘗試從內存中分配size大小的內存時,分兩種情況,一種是size大小小於pool->max,稱爲小塊內存分配,若當前內存池節點小於size,則申請一個新的等同大小的內存池節點,然後從這個新內存池節點分配出size大小的內存空間。若size 大於pool->max時,即分配大塊內存,此時調用的函數直接向操作系統申請大塊內存。
(2)小塊內存的申請是插入在鏈表的尾節點,而新的大塊內存則是插入在鏈表前面。
(3)Nginx僅提供對大塊內存的釋放,沒有提供對小塊內存的釋放,意味着從內存池分配出去的內存不會再回收到內存池裏來,而只有在銷燬整個內存池時,這些內存纔會回收到系統內存裏。
(4)ngx_pool_t中的current字段:這個字段記錄了後序從該內存池分配內存的起始節點,Nginx規定當一個內存節點分配總失敗次數大於等於6次時,current則指向下一個內存節點。
(5)爲什麼要將pool->max字段的最大值限制在一頁內存,這也是小塊內存與大塊內存的臨界,原因在於只有當分配的空間小於一頁時纔有緩存的必要,,否則的話還不如直接利用系統接口malloc()向操作系統申請。
各個結構體的定義:
//大塊內存管理結構
struct ngx_pool_large_s {
ngx_pool_large_t *next; //連接下一個大內存管理
void *alloc; //申請的大內存地址
};
//內存池中數據管理
typedef struct {
u_char *last; //可用內存的起始地址
u_char *end; //可用內存的末尾地址
ngx_pool_t *next; //指向下一個內存池節點
ngx_uint_t failed; //申請時,失敗的次數
} ngx_pool_data_t;
//內存池
struct ngx_pool_s {
ngx_pool_data_t d; //存放數據
size_t max; //存放數據的可用內存大小,最大爲1頁
ngx_pool_t *current; //指向分配內存的內存池
ngx_chain_t *chain;
ngx_pool_large_t *large; //連接大內存管理結構
ngx_pool_cleanup_t *cleanup; //清理對象頭
ngx_log_t *log;
};
內存池的初始化:
//創建一個size的內存池
ngx_pool_t *
ngx_create_pool(size_t size, ngx_log_t *log)
{
ngx_pool_t *p;
p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log); //以對齊的方式來申請size字節內存
if (p == NULL) {
return NULL;
}
p->d.last = (u_char *) p + sizeof(ngx_pool_t); //指向可用的內存起始地址
p->d.end = (u_char *) p + size; //指向可用內存的末尾地址
p->d.next = NULL; //初始時,下一個可用內存爲NULL
p->d.failed = 0; //該內存申請失敗零次
size = size - sizeof(ngx_pool_t); //實際可用的大小,減去控制結構的大小
p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL; //最大隻能是一頁大小
p->current = p; //指向正在分配內存的內存池
p->chain = NULL;
p->large = NULL;
p->cleanup = NULL;
p->log = log;
return p;
}
內存池的銷燬與重置:
//銷燬內存池
void
ngx_destroy_pool(ngx_pool_t *pool)
{
ngx_pool_t *p, *n;
ngx_pool_large_t *l;
ngx_pool_cleanup_t *c;
//運行清理對象的handler
for (c = pool->cleanup; c; c = c->next) {
if (c->handler) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"run cleanup: %p", c);
c->handler(c->data);
}
}
//釋放大內存
for (l = pool->large; l; l = l->next) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
if (l->alloc) {
ngx_free(l->alloc); //使用free釋放malloc申請的內存
}
}
#if (NGX_DEBUG)
/*
* we could allocate the pool->log from this pool
* so we cannot use this log while free()ing the pool
*/
for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"free: %p, unused: %uz", p, p->d.end - p->d.last);
if (n == NULL) {
break;
}
}
#endif
//釋放每一個申請的內存池對象ngx_pool_t
for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
ngx_free(p);
if (n == NULL) {
break;
}
}
}
//重設內存池
void
ngx_reset_pool(ngx_pool_t *pool)
{
ngx_pool_t *p;
ngx_pool_large_t *l;
//釋放大內存
for (l = pool->large; l; l = l->next) {
if (l->alloc) {
ngx_free(l->alloc);
}
}
//內存池對象,僅僅改變last的指針位置
for (p = pool; p; p = p->d.next) {
p->d.last = (u_char *) p + sizeof(ngx_pool_t); //導致所有的內存池對象的可用內存的起始地址偏移都一樣
p->d.failed = 0;
}
pool->current = pool;
pool->chain = NULL;
pool->large = NULL;
}
分配內存:
//分配內存(地址對齊)
void *
ngx_palloc(ngx_pool_t *pool, size_t size)
{
u_char *m;
ngx_pool_t *p;
if (size <= pool->max) { //小內存申請時,以size爲標準
p = pool->current;
do {
m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT); //首先將d.last地址對齊
if ((size_t) (p->d.end - m) >= size) { //可用的內存大於要申請的內存
p->d.last = m + size; //直接更新d.last
return m; //直接返回
}
p = p->d.next; //否則找下一個可用的內存池對象
} while (p);
//沒有找到,則要申請新的內存池對象
return ngx_palloc_block(pool, size);
}
return ngx_palloc_large(pool, size); //大內存申請處理
}
//分配內存(地址可以不對齊)
void *
ngx_pnalloc(ngx_pool_t *pool, size_t size)
{
u_char *m;
ngx_pool_t *p;
if (size <= pool->max) { //小內存
p = pool->current;
do {
m = p->d.last;
if ((size_t) (p->d.end - m) >= size) {
p->d.last = m + size;
return m;
}
p = p->d.next;
} while (p);
return ngx_palloc_block(pool, size); //申請新內存池對象
}
return ngx_palloc_large(pool, size); //大內存
}
小塊內存分配:
//申請新的內存池對象
static void *
ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
u_char *m;
size_t psize;
ngx_pool_t *p, *new;
psize = (size_t) (pool->d.end - (u_char *) pool); //申請內存的總大小
m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log); //對齊方式申請內存
if (m == NULL) {
return NULL;
}
new = (ngx_pool_t *) m; //新的內存
new->d.end = m + psize; //可用的內存的最後地址
new->d.next = NULL;
new->d.failed = 0;
m += sizeof(ngx_pool_data_t); //只有一個ngx_pool_data_t,節省了ngx_pool_t的其餘開銷
m = ngx_align_ptr(m, NGX_ALIGNMENT);
new->d.last = m + size; //可用的內存的起始地址
//如果當前申請內存的失敗的次數已經有5次了,第6次,current將會指向新的內存池對象
for (p = pool->current; p->d.next; p = p->d.next) {
if (p->d.failed++ > 4) {
pool->current = p->d.next;
}
}
p->d.next = new; //連接剛剛申請的內存池對象
return m;
}
大塊內存分配
//大內存申請處理
static void *
ngx_palloc_large(ngx_pool_t *pool, size_t size)
{
void *p;
ngx_uint_t n;
ngx_pool_large_t *large;
p = ngx_alloc(size, pool->log); //直接malloc申請內存
if (p == NULL) {
return NULL;
}
n = 0;
for (large = pool->large; large; large = large->next) {
if (large->alloc == NULL) { //如果有內存被釋放了,可重用
large->alloc = p;
return p;
}
if (n++ > 3) { //但是隻找4次,第5次直接break,創建大內存的管理結構
break;
}
}
large = ngx_palloc(pool, sizeof(ngx_pool_large_t)); //從內存池對象申請內存
if (large == NULL) {
ngx_free(p);
return NULL;
}
large->alloc = p; //指向申請的大內存
//插入large的頭
large->next = pool->large;
pool->large = large;
return p;
}
直接分配內存:
//不管內存大小多大,向操作系統申請內存
void *
ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
{
void *p;
ngx_pool_large_t *large;
p = ngx_memalign(alignment, size, pool->log); //申請的內存
if (p == NULL) {
return NULL;
}
large = ngx_palloc(pool, sizeof(ngx_pool_large_t)); //申請一個大內存管理結構
if (large == NULL) {
ngx_free(p);
return NULL;
}
//放入到內存池ngx_pool_t中管理
large->alloc = p; //指向申請的內存
//插入到頭部
large->next = pool->large;
pool->large = large;
return p;
}
釋放內存:
//釋放內存
ngx_int_t
ngx_pfree(ngx_pool_t *pool, void *p)
{
ngx_pool_large_t *l;
//只釋放大內存
for (l = pool->large; l; l = l->next) {
if (p == l->alloc) {
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
"free: %p", l->alloc);
ngx_free(l->alloc);
l->alloc = NULL; //置爲空
return NGX_OK;
}
}
return NGX_DECLINED;
}