最近對Nginx進行了一些簡單的剖析，要是剖析的不好希望大家見諒，本人水平有限哦

我們先看這麼一副圖

在呼叫這個圖片之前我想先首先宣告一下這幅圖的作者啊，我可不想打著盜版的聲音去用這幅圖哦= =！！！感謝這幅圖的作者rainx！

好，下面我們來通過這個圖來對整個記憶體池進行分析吧。
我們通過程式碼的對比來分析這幅圖

//記憶體池頭部結構 
struct ngx_pool_s {
    ngx_pool_data_t       d;//對執行緒塊的一個管理
    size_t                max;//最大值
    ngx_pool_t           *current;//當前指標指的是哪個記憶體塊
 

    ngx_chain_t          *chain;
    ngx_pool_large_t     *large;//大塊記憶體
    ngx_pool_cleanup_t   *cleanup;//清除某些特殊資料
    ngx_log_t            *log;
};

其實我覺得我們先應該通過這個結構體和這幅圖來了解一下nginx記憶體池，其實所謂的一個記憶體池是通過一個連結串列來進行管理的，而ngx_pool_t就是對一個節點進行管理的結構體。

ngx_pool_data_t d //這是對這一塊ngx_pool_t的資料塊的一個管理
size_t max //資料塊的大小，也就是你所分配的這一塊節點資料區域的大小
ngx_pool_t *current //當前可分配的ngx_pool_t
ngx_pool_large_t *large //大於max的用大塊記憶體區域儲存
ngx_pool_cleanup_t *cleanup //用於清除某些檔案描述符或者其它的特殊結構

typedef struct {
    u_char               *last;//當前記憶體池分配到此處，即下一次分配從此處開始
    u_char               *end;//記憶體池結束位置
    ngx_pool_t           *next;//記憶體池裡面有很多塊記憶體，這些記憶體   
                               //塊就是通過該指標連成連結串列的 
    ngx_uint_t            failed;//記憶體池分配失敗次數
} ngx_pool_data_t;

u_char *last //指向可以分配記憶體空間的地方，last實際上是作為已經分配的記憶體空間的末尾，而下一次資料分配就要從last開始到end，當然要是在分配的空間小於max的情況下，假如下一次所要求分配的空間大於max，那麼則開闢大塊記憶體
u_char *end //資料域最末尾的指標
ngx_pool_t *next //指向下一塊ngx_pool_t，這是在記憶體分配不夠，開闢了下一個ngx_pool_t的前提下
ngx_uint_t failed //假如我們的分配的記憶體空間過於的小，超過4次在此塊ngx_pool_t分配不成功，那麼我們的current就會指向下一個ngx_pool_t，這個就是記錄失敗次數的一個記錄器

//管理大塊記憶體
struct ngx_pool_large_s {
    ngx_pool_large_t     *next;//下一塊
    void                 *alloc;
};

我們在這裡強調一下，大塊記憶體實際上是指在ngx_pool_t中大於max的需要分配的節點，當然每次分配都是在current節點中，ngx_pool_t中的large指標負責將這些節點串聯起來
void *alloc //當然指的就是大塊記憶體的分配區域

struct ngx_pool_cleanup_s {
    ngx_pool_cleanup_pt   handler;//處理特殊資料的回撥函式
    void                 *data;//指向要清除的資料
    ngx_pool_cleanup_t   *next;//下一個cleanup callback  
};

當然我想說這個結構體沒啥好介紹的，當我們在記憶體池中加入打開了些檔案描述符在釋放前需要關閉這些檔案描述符或者一些特殊結構需要釋放的時候，我們會呼叫ngx_pool_cleanup_s中的handler函式，當然這也是一個節點，我們需要在處理這些特殊的結構或者檔案描述符的時候用特定的回撥函式handler，我們需要把這些handler串聯起來，其實跟ngx_pool_large_s差不多，也是在當前的current下，而串聯起來這些節點的是cleanup指標

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
分割線
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
好啦，我能說nginx中記憶體池大致的結構我已經剖析完了，現在我們來分析一些對它的操作的函式:

void *ngx_alloc(size_t size, ngx_log_t *log);
void *ngx_calloc(size_t size, ngx_log_t *log);

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);
void *ngx_pcalloc(ngx_pool_t *pool, size_t size);
void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment);

咱們來一個個分析好吧:

void *
ngx_alloc(size_t size, ngx_log_t *log)
{
    void  *p;
//可以看出來底層呼叫了malloc
    p = malloc(size);
    if (p == NULL) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
                      "malloc(%uz) failed", size);
    }

    ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size);

    return p;
}

ngx_alloc我們可以把它看成一個底層呼叫函式，直接呼叫的malloc，當然這裡是看起來跟記憶體池沒有任何關係了，但是它應該算是記憶體池的底層呼叫函式

/******************************************************/

void *
ngx_calloc(size_t size, ngx_log_t *log)
{
    void  *p;
//帶清零作用的
    p = ngx_alloc(size, log);

    if (p) {
        ngx_memzero(p, size);
    }

    return p;
}

這裡當然也是相當於一個底層呼叫函式，它只不過相當於從堆上分配了一塊記憶體附帶清零的作用，僅此而已
/******************************************************/

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);
    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;
    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;
}

誒嘿，這裡就很奇怪啊，貌似沒有用到上面的ngx_alloc()函式啊，不過沒關係，我只能說它其實並沒有呼叫ngx_alloc()這個介面，而它呼叫了另一個介面:
p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
我們可以看到這個介面和上面的介面都不一樣，那麼可以進這個接口裡面去看一下:

void *
ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)
{
    void  *p;
    int    err;
//呼叫posix_memalign( )成功時會返回size位元組的動態記憶體
//並且這塊記憶體的地址是alignment的倍數
//引數alignment必須是2的冪，還是void指標的大小的倍數
    err = posix_memalign(&p, alignment, size);
    //...
return p;
}

它裡面涵蓋了一個叫做posix_memalign(&p, alignment, size)的函式，那麼這個函式的作用是幹嘛的呢？我們知道POSIX標明瞭通過malloc(), calloc(), 和 realloc()返回的地址對於任何的C型別來說都是對齊的。在Linux中，這些函式返回的地址在32位系統是以8位元組為邊界對齊，在64位系統是以16位元組為邊界對齊的,而posix_memalign(&p, alignment, size)的作用就是動態對齊。而在這裡它則是按alignment大小來進行對齊的，其實也可以看一下這個玩意的大小吧:
#define NGX_POOL_ALIGNMENT 16

嘿嘿，看到沒有，它的大小是16哦！！！也就是說它是按16來進行對齊的，至於具體的posix_memalign(&p, alignment, size)咋用，希望大家自己回去查一下吧。

當然我們也看過了ngx_memalign(…)函式，我們繼續來看一下ngx_create_pool(…)函式，我們可以看到它對max進行了一個初始化:
p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;

其實我一直很好奇這個地方啊，這個地方的max是經過傳進來的值決定的，而假如，傳進來的小於NGX_MAX_ALLOC_FROM_POOL，那麼按size的大小來計算哦，這裡我們再來順帶看一下NGX_MAX_ALLOC_FROM_POOL是什麼:
#define NGX_MAX_ALLOC_FROM_POOL (ngx_pagesize - 1)

對哦，這裡是一個巨集定義，定義的大小是4K-1個大小，那麼我們姑且算在小於4K的情況下它按size大小來定義吧，其實我認為這裡的唯一的好處就是它按分頁機制去處理了一個最大記憶體，假如我不到4K我能節約性的從記憶體中拿合適的記憶體，當大於4K的時候我們就可以不考慮頁面大小的問題了，直接就大塊記憶體走起，當然，考不考慮4K不是我們說了算，而是剛開始申請的size大小說了算哦。

我一直覺得這個地方有個BUG，那就是假如傳進來的size < sizeof(ngx_pool_t)怎麼辦？不就成負數了？那麼這個程序會不會因此掛掉？這個我就是不是很清楚了！！
/******************************************************/
接下來看看ngx_destroy_pool(ngx_pool_t *pool)

void ngx_destroy_pool(ngx_pool_t *pool)
{
    ngx_pool_t          *p, *n;
    ngx_pool_large_t    *l;
    ngx_pool_cleanup_t  *c;

//先考慮cleanup函式，但是貌似我並沒有找見有關的回撥
    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);
        }
    }
    //....
        for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        ngx_free(p);

        if (n == NULL) {
            break;
        }
    }
}

我們可以從這裡看到它先呼叫了ngx_pool_t中的clean中的handler函式來清理一些它可能開啟的檔案描述符或者特殊結構，此時再free掉那些大塊結構。當然，最後是把自己本身的節點給free掉了
/******************************************************/
void ngx_reset_pool(ngx_pool_t *pool)

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);
        }
    }

    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)了吧

void * ngx_palloc(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    ngx_pool_t  *p;

    if (size <= pool->max) {

        p = pool->current;

        do {
            m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);

            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);
}

我們可以看到這裡是從記憶體池中分配記憶體的一個函式，當我們前面建立好記憶體池之後，我們可以通過這裡在一個ngx_pool_t中的資料段中分配節點，我們可以看到，它就只用了last和end兩個標記位去標記剩餘空間的大小，當我們空間大於max的時候直接用ngx_palloc_large(pool, size)呼叫大塊記憶體，而假如小於max卻在後面的ngx_pool_t中不夠用的話則會呼叫ngx_palloc_block(pool, size)函式，其實內部就是重新申請了一塊ngx_pool_t記憶體，呼叫的還是ngx_memalign(…)函式，有興趣的朋友自己看看了。

當然後面還有一個
void *ngx_pnalloc(ngx_pool_t *pool, size_t size);
當然，這個函式和void *ngx_palloc(ngx_pool_t *pool, size_t size)最大的區別當然就是:
void *ngx_palloc(ngx_pool_t *pool, size_t size)是對齊的
void *ngx_palloc(ngx_pool_t *pool, size_t size)是不對齊的

/******************************************************/
好了總結了那麼多，覺得心好累啊！！！