nginx源碼學(xué)習----內存池最近在進(jìn)行監控平臺的設計，之前一直覺(jué)得C/C++中最棘手的部分是內存的管理上，遠不止new/delete、malloc/free這么簡(jiǎn)單。隨著(zhù)代碼量的遞增，程序結構復雜度的提高。各種內存方面的問(wèn)題悄然滋生。而且作為平臺，后期的插件擴展在所難免。長(cháng)時(shí)間運行的采集平臺的特性更是提出了對穩定性的高要求。不是c#、java，沒(méi)有虛擬機為你管理內存，一切都要靠自己。于是想看看nginx、python、lua這些C的經(jīng)典之作在內存管理這塊“要地”又是如何處理的。
先來(lái)看看nginx吧，因為網(wǎng)上都說(shuō)nginx的內存池設計的非常精巧：
1、基本結構
先來(lái)學(xué)習一下nginx內存池的幾個(gè)主要數據結構：[見(jiàn)：./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: };
可以說(shuō)，ngx_pool_data_t和ngx_pool_s基本構成了nginx內存池的主體結構，下面詳細介紹一下nginx內存池的主體結構：
如上圖，nginx的內存池實(shí)際是一個(gè)由ngx_pool_data_t和ngx_pool_s構成的鏈表，其中：
ngx_pool_data_t中：
last：是一個(gè)unsigned char 類(lèi)型的指針，保存的是/當前內存池分配到末位地址，即下一次分配從此處開(kāi)始。
end：內存池結束位置；
next：內存池里面有很多塊內存，這些內存塊就是通過(guò)該指針連成鏈表的，next指向下一塊內存。
failed：內存池分配失敗次數。
ngx_pool_s
d：內存池的數據塊；
max：內存池數據塊的最大值；
current：指向當前內存池；
chain：該指針掛接一個(gè)ngx_chain_t結構；
large：大塊內存鏈表，即分配空間超過(guò)max的情況使用；
cleanup：釋放內存池的callback
log：日志信息
以上是內存池涉及的主要數據結構，為了盡量簡(jiǎn)化，其他涉及的數據結構將在下面實(shí)際用到時(shí)候再做介紹。
2、內存池基本操作
內存池對外的主要方法有：
創(chuàng )建內存池ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log);
銷(xiāo)毀內存池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);
注：
在分析內存池方法前，需要對幾個(gè)主要的內存相關(guān)函數作一下介紹（見(jiàn)：./src/Os/Unix（Win32）/ngx_alloc.h/.c）
這里僅對Win32的作介紹：
ngx_alloc：（只是對malloc進(jìn)行了簡(jiǎn)單的封裝）
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 free
ngx_memalign：
1: #define ngx_memalign(alignment, size, log) ngx_alloc(size, log)
這里alignment主要是針對部分unix平臺需要動(dòng)態(tài)的對齊，對POSIX 1003.1d提供的posix_memalign( )進(jìn)行封裝，在大多數情況下，編譯器和C庫透明地幫你處理對齊問(wèn)題。nginx中通過(guò)宏NGX_HAVE_POSIX_MEMALIGN來(lái)控制；
2.1、內存池創(chuàng )建（ngx_create_pool）
ngx_create_pool用于創(chuàng )建一個(gè)內存池，我們創(chuàng )建時(shí)，傳入我們的初始大?。?div style="height:15px;">
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);//初始狀態(tài)：last指向ngx_pool_t結構體之后數據取起始位置 12: p->d.end = (u_char *) p + size;//end指向分配的整個(gè)size大小的內存的末尾 13: p->d.next = NULL; 14: p->d.failed = 0; 15: //#define NGX_MAX_ALLOC_FROM_POOL (ngx_pagesize - 1) 16: //內存池最大不超過(guò)4095，x86中頁(yè)的大小為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對內存的管理分為大內存與小內存，當某一個(gè)申請的內存大于某一個(gè)值時(shí)，就需要從大內存中分配空間，否則從小內存中分配空間。
nginx中的內存池是在創(chuàng )建的時(shí)候就設定好了大小，在以后分配小塊內存的時(shí)候，如果內存不夠，則是重新創(chuàng )建一塊內存串到內存池中，而不是將原有的內存池進(jìn)行擴張。當要分配大塊內存是，則是在內存池外面再分配空間進(jìn)行管理的，稱(chēng)為大塊內存池。
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);//對內存地址進(jìn)行對齊處理 13: 14: if ((size_t) (p->d.end - m) >= size) {//如果在當前內存塊有效范圍內，進(jìn)行內存指針的移動(dòng) 15: p->d.last = m + size; 16: 17: return m; 18: } 19: 20: p = p->d.next;//如果當前內存塊有效容量不夠分配，則移動(dòng)到下一個(gè)內存塊進(jìn)行分配 21: 22: } while (p); 23: 24: return ngx_palloc_block(pool, size); 25: } 26: 27: return ngx_palloc_large(pool, size); 28: }
這里需要說(shuō)明的幾點(diǎn)：
1、ngx_align_ptr，這是一個(gè)用來(lái)內存地址取整的宏，非常精巧，一句話(huà)就搞定了。作用不言而喻，取整可以降低CPU讀取內存的次數，提高性能。因為這里并沒(méi)有真正意義調用malloc等函數申請內存，而是移動(dòng)指針標記而已，所以?xún)却鎸R的活，C編譯器幫不了你了，得自己動(dòng)手。
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)
這個(gè)函數是用來(lái)分配新的內存塊，為pool內存池開(kāi)辟一個(gè)新的內存塊，并申請使用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);//計算內存池第一個(gè)內存塊的大小 9: 10: m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);//分配和第一個(gè)內存塊同樣大小的內存塊 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òng)到d后面的一個(gè)位置，作為起始位置 22: m = ngx_align_ptr(m, NGX_ALIGNMENT);//對m指針按4字節對齊處理 23: new->d.last = m + size;//設置新內存塊的last，即申請使用size大小的內存 24: 25: current = pool->current; 26: //這里的循環(huán)用來(lái)找最后一個(gè)鏈表節點(diǎn)，這里failed用來(lái)控制循環(huán)的長(cháng)度，如果分配失敗次數達到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中首先會(huì )判斷申請的內存大小是否超過(guò)內存塊的最大限值，如果超過(guò)，則直接調用ngx_palloc_large，進(jìn)入大內存塊的分配流程；
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: // 查找到一個(gè)空的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: //為了提高效率， 如果在三次內沒(méi)有找到空的large結構體，則創(chuàng )建一個(gè) 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: }
所以說(shuō)Nginx內存池中大內存塊和小內存塊的分配與釋放是不一樣的。我們在使用內存池時(shí)，可以使用ngx_palloc進(jìn)行分配，使用ngx_pfree釋放。而對于大內存，這樣做是沒(méi)有問(wèn)題的，而對于小內存就不一樣了，分配的小內存，不會(huì )進(jìn)行釋放。因為大內存塊的分配只對前3個(gè)內存塊進(jìn)行檢查，否則就直接分配內存，所以大內存塊的釋放必須及時(shí)。
ngx_pool_cleanup_s
Nginx內存池支持通過(guò)回調函數，對外部資源的清理。ngx_pool_cleanup_t是回調函數結構體，它在內存池中以鏈表形式保存，在內存池進(jìn)行銷(xiāo)毀時(shí)，循環(huán)調用這些回調函數對數據進(jìn)行清理。
1: struct ngx_pool_cleanup_s { 2: ngx_pool_cleanup_pt handler; 3: void *data; 4: ngx_pool_cleanup_t *next; 5: };
其中
handler：是回調函數指針；
data：回調時(shí)，將此數據傳入回調函數；
next：//指向下一個(gè)回調函數結構體；
如果我們需要添加自己的回調函數，則需要調用ngx_pool_cleanup_add來(lái)得到一個(gè)ngx_pool_cleanup_t，然后設置handler為我們的清理函數，并設置data為我們要清理的數據。這樣在ngx_destroy_pool中會(huì )循環(huán)調用handler清理數據；
比如：我們可以將一個(gè)開(kāi)打的文件描述符作為資源掛載到內存池上，同時(shí)提供一個(gè)關(guān)閉文件描述的函數注冊到handler上，那么內存池在釋放的時(shí)候，就會(huì )調用我們提供的關(guān)閉文件函數來(lái)處理文件描述符資源了。
2.5、內存池銷(xiāo)毀
ngx_destroy_pool
ngx_destroy_pool這個(gè)函數用于銷(xiāo)毀一個(gè)內存池：
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: }
