nginx原始碼學習----記憶體池
1、基本結構
先來學習一下nginx記憶體池的幾個主要資料結構：[見：./src/core/ngx_palloc.h/.c]
ngx_pool_data_t（記憶體池資料塊結構）
1: typedef struct {
2: u_char *last;
3: u_char *end;
4: ngx_pool_t *next;
5: ngx_uint_t failed;
6: } ngx_pool_data_t;
ngx_pool_s（記憶體池頭部結構）
1: struct ngx_pool_s {
2: ngx_pool_data_t d;
3: size_t max;
4: ngx_pool_t *current;
5: ngx_chain_t *chain;
6: ngx_pool_large_t *large;
7: ngx_pool_cleanup_t *cleanup;
8: ngx_log_t *log;
9:};
可以說，ngx_pool_data_t和ngx_pool_s基本構成了nginx記憶體池的主體結構，下面詳細介紹一下nginx記憶體池的主體結構：
如上圖，nginx的記憶體池實際是一個由ngx_pool_data_t和ngx_pool_s構成的連結串列，其中：
ngx_pool_data_t中：
last：是一個unsigned char 型別的指標，儲存的是/當前記憶體池分配到末位地址，即下一次分配從此處開始。
end：記憶體池結束位置；
next：記憶體池裡面有很多塊記憶體，這些記憶體塊就是通過該指標連成連結串列的，next指向下一塊記憶體。
failed：記憶體池分配失敗次數。
ngx_pool_s
d：記憶體池的資料塊；
max：記憶體池資料塊的最大值；
current：指向當前記憶體池；
chain：該指標掛接一個ngx_chain_t結構；
large：大塊記憶體連結串列，即分配空間超過max的情況使用；
cleanup：釋放記憶體池的callback
log：日誌資訊
以上是記憶體池涉及的主要資料結構，為了儘量簡化，其他涉及的資料結構將在下面實際用到時候再做介紹。
2、記憶體池基本操作
記憶體池對外的主要方法有：
| 建立記憶體池 | ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log); |
| 銷燬記憶體池 | void ngx_destroy_pool(ngx_pool_t *pool); |
| 重置記憶體池 | void ngx_reset_pool(ngx_pool_t *pool); |
| 記憶體申請（對齊） | void * ngx_palloc(ngx_pool_t *pool, size_t size); |
| 記憶體申請（不對齊） | void * ngx_pnalloc(ngx_pool_t *pool, size_t size); |
| 記憶體清除 | ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p); |
注：
在分析記憶體池方法前，需要對幾個主要的記憶體相關函式作一下介紹（見：./src/Os/Unix（Win32）/ngx_alloc.h/.c）
這裡僅對Win32的作介紹：
ngx_alloc：（只是對malloc進行了簡單的封裝）
1: void *ngx_alloc(size_t size, ngx_log_t *log)2: {3: void *p;4:5: p = malloc(size);6: if (p == NULL) {7: ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,8: "malloc(%uz) failed", size);9: }10:11: ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size);12:13: return p;14: }ngx_calloc：（呼叫malloc並初始化為0）
1: void *ngx_calloc(size_t size, ngx_log_t *log)2: {3: void *p;4:5: p = ngx_alloc(size, log);6:7: if (p) {8: ngx_memzero(p, size);9: }10:11: return p;12: }ngx_memzero：
1: #define ngx_memzero(buf, n) (void) memset(buf, 0, n)ngx_free ：
1: #define ngx_free freengx_memalign：
1: #define ngx_memalign(alignment, size, log) ngx_alloc(size, log)這裡alignment主要是針對部分unix平臺需要動態的對齊，對POSIX 1003.1d提供的posix_memalign( )進行封裝，在大多數情況下，編譯器和C庫透明地幫你處理對齊問題。nginx中通過巨集NGX_HAVE_POSIX_MEMALIGN來控制；
2.1、記憶體池建立（ngx_create_pool）
ngx_create_pool用於建立一個記憶體池，我們建立時，傳入我們的初始大小：
1: ngx_pool_t *
2: ngx_create_pool(size_t size, ngx_log_t *log)
3: {
4: ngx_pool_t *p;
5:
6: p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
7: if (p == NULL) {
8: return NULL;
9: }
10:
11: p->d.last = (u_char *) p + sizeof(ngx_pool_t);//初始狀態：last指向ngx_pool_t結構體之後資料取起始位置
12: p->d.end = (u_char *) p + size;//end指向分配的整個size大小的記憶體的末尾
13: p->d.next = NULL;
14: p->d.failed = 0;
15: //#define NGX_MAX_ALLOC_FROM_POOL (ngx_pagesize - 1)
16: //記憶體池最大不超過4095，x86中頁的大小為4K
17: size = size - sizeof(ngx_pool_t);
18: p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
19:
20: p->current = p;
21: p->chain = NULL;
22: p->large = NULL;
23: p->cleanup = NULL;
24: p->log = log;
25:
26: return p;
27: }
nginx對記憶體的管理分為大記憶體與小記憶體，當某一個申請的記憶體大於某一個值時，就需要從大記憶體中分配空間，否則從小記憶體中分配空間。
nginx中的記憶體池是在建立的時候就設定好了大小，在以後分配小塊記憶體的時候，如果記憶體不夠，則是重新建立一塊記憶體串到記憶體池中，而不是將原有的記憶體池進行擴張。當要分配大塊記憶體是，則是在記憶體池外面再分配空間進行管理的，稱為大塊記憶體池。
2.2、記憶體申請
ngx_palloc
1: void *
2: ngx_palloc(ngx_pool_t *pool, size_t size)
3: {
4: u_char *m;
5: ngx_pool_t *p;
6:
7: if (size <= pool->max) {//如果申請的記憶體大小大於記憶體池的max值，則走另一條路，申請大記憶體
8:
9: p = pool->current;
10:
11: do {
12: m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);//對記憶體地址進行對齊處理
13:
14: if ((size_t) (p->d.end - m) >= size) {//如果在當前記憶體塊有效範圍內，進行記憶體指標的移動
15: p->d.last = m + size;
16:
17: return m;
18: }
19:
20: p = p->d.next;//如果當前記憶體塊有效容量不夠分配，則移動到下一個記憶體塊進行分配
21:
22: } while (p);
23:
24: return ngx_palloc_block(pool, size);
25: }
26:
27: return ngx_palloc_large(pool, size);
28: }
這裡需要說明的幾點：
1、ngx_align_ptr，這是一個用來記憶體地址取整的巨集，非常精巧，一句話就搞定了。作用不言而喻，取整可以降低CPU讀取記憶體的次數，提高效能。因為這裡並沒有真正意義呼叫malloc等函式申請記憶體，而是移動指標標記而已，所以記憶體對齊的活，C編譯器幫不了你了，得自己動手。
1: #define ngx_align_ptr(p, a) \
2: (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
2、ngx_palloc_block(ngx_pool_t *pool, size_t size)
這個函式是用來分配新的記憶體塊，為pool記憶體池開闢一個新的記憶體塊，並申請使用size大小的記憶體；
1: static void *
2: ngx_palloc_block(ngx_pool_t *pool, size_t size)
3: {
4: u_char *m;
5: size_t psize;
6: ngx_pool_t *p, *new, *current;
7:
8: psize = (size_t) (pool->d.end - (u_char *) pool);//計算記憶體池第一個記憶體塊的大小
9:
10: m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);//分配和第一個記憶體塊同樣大小的記憶體塊
11: if (m == NULL) {
12: return NULL;
13: }
14:
15: new = (ngx_pool_t *) m;
16:
17: new->d.end = m + psize;//設定新記憶體塊的end
18: new->d.next = NULL;
19: new->d.failed = 0;
20:
21: m += sizeof(ngx_pool_data_t);//將指標m移動到d後面的一個位置，作為起始位置
22: m = ngx_align_ptr(m, NGX_ALIGNMENT);//對m指標按4位元組對齊處理
23: new->d.last = m + size;//設定新記憶體塊的last，即申請使用size大小的記憶體
24:
25: current = pool->current;
26: //這裡的迴圈用來找最後一個連結串列節點，這裡failed用來控制迴圈的長度，如果分配失敗次數達到5次，
27: //就忽略，不需要每次都從頭找起
28: for (p = current; p->d.next; p = p->d.next) {
29: if (p->d.failed++ > 4) {
30: current = p->d.next;
31: }
32: }
33:
34: p->d.next = new;
35:
36: pool->current = current ? current : new;
37:
38: return m;
39: }
3、ngx_palloc_large(ngx_pool_t *pool, size_t size)
在ngx_palloc中首先會判斷申請的記憶體大小是否超過記憶體塊的最大限值，如果超過，則直接呼叫ngx_palloc_large，進入大記憶體塊的分配流程；
1: static void *
2: ngx_palloc_large(ngx_pool_t *pool, size_t size)
3: {
4: void *p;
5: ngx_uint_t n;
6: ngx_pool_large_t *large;
7: // 直接在系統堆中分配一塊空間
8: p = ngx_alloc(size, pool->log);
9: if (p == NULL) {
10: return NULL;
11: }
12:
13: n = 0;
14: // 查詢到一個空的large區，如果有，則將剛才分配的空間交由它管理
15: for (large = pool->large; large; large = large->next) {
16: if (large->alloc == NULL) {
17: large->alloc = p;
18: return p;
19: }
20:
21: if (n++ > 3) {
22: break;
23: }
24: }
25: //為了提高效率， 如果在三次內沒有找到空的large結構體，則建立一個
26: large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
27: if (large == NULL) {
28: ngx_free(p);
29: return NULL;
30: }
31:
32: large->alloc = p;
33: large->next = pool->large;
34: pool->large = large;
35:
36: return p;
37: }
2.3、記憶體池重置
ngx_reset_pool
1: void
2: ngx_reset_pool(ngx_pool_t *pool)
3: {
4: ngx_pool_t *p;
5: ngx_pool_large_t *l;
6: //釋放所有大塊記憶體
7: for (l = pool->large; l; l = l->next) {
8: if (l->alloc) {
9: ngx_free(l->alloc);
10: }
11: }
12:
13: pool->large = NULL;
14: // 重置所有小塊記憶體區
15: for (p = pool; p; p = p->d.next) {
16: p->d.last = (u_char *) p + sizeof(ngx_pool_t);
17: }
18: }
2.4、記憶體池清理
ngx_pfree
1: ngx_int_t
2: ngx_pfree(ngx_pool_t *pool, void *p)
3: {
4: ngx_pool_large_t *l;
5: //只檢查是否是大記憶體塊，如果是大記憶體塊則釋放
6: for (l = pool->large; l; l = l->next) {
7: if (p == l->alloc) {
8: ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
9: "free: %p", l->alloc);
10: ngx_free(l->alloc);
11: l->alloc = NULL;
12:
13: return NGX_OK;
14: }
15: }
16:
17: return NGX_DECLINED;
18: }
所以說Nginx記憶體池中大記憶體塊和小記憶體塊的分配與釋放是不一樣的。我們在使用記憶體池時，可以使用ngx_palloc進行分配，使用ngx_pfree釋放。而對於大記憶體，這樣做是沒有問題的，而對於小記憶體就不一樣了，分配的小記憶體，不會進行釋放。因為大記憶體塊的分配只對前3個記憶體塊進行檢查，否則就直接分配記憶體，所以大記憶體塊的釋放必須及時。
ngx_pool_cleanup_s
Nginx記憶體池支援通過回撥函式，對外部資源的清理。ngx_pool_cleanup_t是回撥函式結構體，它在記憶體池中以連結串列形式儲存，在記憶體池進行銷燬時，迴圈呼叫這些回撥函式對資料進行清理。
1: struct ngx_pool_cleanup_s {
2: ngx_pool_cleanup_pt handler;
3: void *data;
4: ngx_pool_cleanup_t *next;
5: };
其中
handler：是回撥函式指標；
data：回撥時，將此資料傳入回撥函式；
next：//指向下一個回撥函式結構體；
如果我們需要新增自己的回撥函式，則需要呼叫ngx_pool_cleanup_add來得到一個ngx_pool_cleanup_t，然後設定handler為我們的清理函式，並設定data為我們要清理的資料。這樣在ngx_destroy_pool中會迴圈呼叫handler清理資料；
比如：我們可以將一個開打的檔案描述符作為資源掛載到記憶體池上，同時提供一個關閉檔案描述的函式註冊到handler上，那麼記憶體池在釋放的時候，就會呼叫我們提供的關閉檔案函式來處理檔案描述符資源了。
2.5、記憶體池銷燬
ngx_destroy_pool
ngx_destroy_pool這個函式用於銷燬一個記憶體池：
1: void
2: ngx_destroy_pool(ngx_pool_t *pool)
3: {
4: ngx_pool_t *p, *n;
5: ngx_pool_large_t *l;
6: ngx_pool_cleanup_t *c;
7:
8: //首先呼叫所有的資料清理函式
9: for (c = pool->cleanup; c; c = c->next) {
10: if (c->handler) {
11: ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
12: "run cleanup: %p", c);
13: c->handler(c->data);
14: }
15: }
16:
17: //釋放所有的大塊記憶體
18: for (l = pool->large; l; l = l->next) {
19:
20: ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
21:
22: if (l->alloc) {
23: ngx_free(l->alloc);
24: }
25: }
26:
27: //最後釋放所有記憶體池中的記憶體塊
28: for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
29: ngx_free(p);
30:
31: if (n == NULL) {
32: break;
33: }
34: }
35: }