nginx slab內存管理

本來這一篇作為nginx系列的開頭是不合適的，不過由於nginx進程框架自己的梳理還沒
完成，這部分又剛好整理完了，就從這開始吧。
這兒談的是nginx的slab的內存管理方式，這種方式的內存管理在nginx中，主要是與nginx
的共享內存協同使用的。nginx的slab管理與linux的slab管理相同的地方在於均是利用了內存
的緩存與對齊機制，slab內存管理中一些設計相當巧妙的地方，也有一些地方個人感覺設計
不是很完美，或許是作為nginx設計綜合考慮的結果。
nginx slab實現中的一大特色就是大量的位操作，這部分操作很多是與slot分級數組相關的。

為方便描述下面做一些說明：
1.將整個slab的管理結構稱slab pool.
2.將slab pool前部的ngx_slab_pool_t結構稱slab header.
3.將管理內存分級的ngx_slab_page_t結構稱slot分級數組.
4.將管理page頁使用的ngx_slab_page_t結構稱slab page管理結構.
5.將具體page頁的存放位置稱pages數組.
6.將把page分成的各個小塊稱為chunk.
7.將標記chunk使用的位圖結構稱為bitmap.

整個slab pool中有兩個非常重要的結構，一是ngx_slab_pool_t，即slab header,如下示：

typedef struct {
    ngx_atomic_t      lock;

    size_t            min_size;
    size_t            min_shift;

    ngx_slab_page_t  *pages;
    ngx_slab_page_t   free;

    u_char           *start;
    u_char           *end;

    ngx_shmtx_t       mutex;

    u_char           *log_ctx;
    u_char            zero;

    void             *data;
    void             *addr;
} ngx_slab_pool_t;

其中最為重要的幾個成員為：
min_size:指最小分割成的chunk的大小。
min_shift:指min_size對應的移位數。
*pages:指向slab page管理結構的開始位置。
free:空閑的slab page管理結構鏈表。
*start:pages數組的的起始位置。
*end:整個slab pool 的結束位置。
*addr:整個slab pool的開始位置。

另一個重要的結構是ngx_slab_page_t,slot分級數組與slab page管理結構都使用了這個結構，
如下示：

struct ngx_slab_page_s {
    uintptr_t         slab;
    ngx_slab_page_t  *next;
    uintptr_t         prev;
};

其中的成員說明如下示：
slab:slab為使用較為復雜的一個字段，有以下四種使用情況
　　a.存儲為些結構相連的pages的數目(slab page管理結構)
　　b.存儲標記chunk使用情況的bitmap(size = exact_size)
　　c.存儲chunk的大小(size < exact_size)
　　d.存儲標記chunk的使用情況及chunk大小(size > exact_size)
next:使用情況也會分情況處理，后面看。
prev:通常是組合使用在存儲前一個位置及標記page的類型。

先來看下整個slab pool的結構，如下圖示：

上面需要注意的幾個地方：
1.由於內存對齊可能會導致slab pool中有部分未使用的內存區域。
2.由於內存對齊可能會導致pages數組的大小小於slab page管理結構的大小。
3.對於未使用的page管理鏈表其結點非常特殊，可以是由ngx_slab_page_t的數組構成
也可以是單個的ngx_slab_page_t.
4.pages數組中的page是與slab page管理結構一一對應的，雖然slab page有多的。

然后就是一些初始化數據，這兒僅考慮32位的情況。
ngx_pagesize = 4096;
ngx_pagesize_shift = 12;
ngx_slab_max_size = 2048;
ngx_slab_exact_size = 128;
ngx_slab_exact_shift = 7;
ngx_slab_min_size = 128;
ngx_slab_min_shift = 3;

先看slab 內存管理的初始化過程，具體的代碼分析如下：

//slab空間的初始化函數
void
ngx_slab_init(ngx_slab_pool_t *pool)
{
    u_char           *p;
    size_t            size;
    ngx_int_t         m;
    ngx_uint_t        i, n, pages;
    ngx_slab_page_t  *slots;

    /* STUB 最大slab size的初始化*/
    if (ngx_slab_max_size == 0) {
        ngx_slab_max_size = ngx_pagesize / 2;
        ngx_slab_exact_size = ngx_pagesize / (8 * sizeof(uintptr_t));
        for (n = ngx_slab_exact_size; n >>= 1; ngx_slab_exact_shift++) {
            /* void */
        }
    }
    /**/
    //計算最小的slab大小
    pool->min_size = 1 << pool->min_shift;
    //跳過ngx_slab_page_t的空間，也即跳過slab header
    p = (u_char *) pool + sizeof(ngx_slab_pool_t);
    size = pool->end - p;   //計算剩余可用空間的大小

    ngx_slab_junk(p, size);
    //進行slot分級數組的初始化
    slots = (ngx_slab_page_t *) p;
    n = ngx_pagesize_shift - pool->min_shift;   //計算可分的級數，page_size為4kb時對應的shift為12，若
                                                //最小可為8B，則shift為3，則對應可分為12-3,即8,16,32,64,
                                                //128,256,512,1024,2048 9個分級。
    for (i = 0; i < n; i++) {
         slots[i].slab = 0;
        slots[i].next = &slots[i];              //對應將每個next均初始化為自己
        slots[i].prev = 0;
    }
    //跳過slot分級數組區域
    p += n * sizeof(ngx_slab_page_t);
    //由於每一個page均對應一個ngx_slab_page_t的管理結構，因此下面是計算剩余空間還可分配出多少頁，不過這兒有疑問，后面討論
    pages = (ngx_uint_t) (size / (ngx_pagesize + sizeof(ngx_slab_page_t)));

    ngx_memzero(p, pages * sizeof(ngx_slab_page_t));
    //初始化pages指針的位置
    pool->pages = (ngx_slab_page_t *) p;

    pool->free.prev = 0;
    pool->free.next = (ngx_slab_page_t *) p;

    pool->pages->slab = pages;
    pool->pages->next = &pool->free;
    pool->pages->prev = (uintptr_t) &pool->free;
    //下面是進行內存的對齊操作
    pool->start = (u_char *)
                   ngx_align_ptr((uintptr_t) p + pages * sizeof(ngx_slab_page_t),
                                 ngx_pagesize);
    //這個地方是進行對齊后的page調整，這個地方是我前面疑問的部分解決位置。
    m = pages - (pool->end - pool->start) / ngx_pagesize;
    if (m > 0) {
         pages -= m;
        pool->pages->slab = pages;
    }

    pool->log_ctx = &pool->zero;
    pool->zero = '\0';
}

然后是內存申請過程：
step 1：根據申請size的大小，判斷申請內存的方式：
　　case 1：若大於ngx_slab_max_size則直接彩分配page的方式。
　　　　　　調用ngx_slab_alloc_pages后跳轉至step 5.
　　case 2：若小於等於ngx_slab_max_size則根據size計算分級的級數。
　　　　　　轉step 2.
step 2：檢查計算出的分級數對應的slot分級數組中是否存在可使用的頁，
　　　　若存在則轉step 3,否則轉step 4.
step 3：根據size的大小，進行不同的內存分配過程：
　　case 1：size小於ngx_slab_exact_size時
　　　　(1)遍歷bitmap數組查找可用的chunk位置
　　　　(2)完成chunk的標記
　　　　(3)標記完成后檢查chunk是否是對應的bitmap的最后一個被使用的，
　　　　　若是，則進步檢查page中是否還存在未使用的chunk，若不存在則
　　　　　將page脫離出此slot分級數組的管理,標記page的類型為NGX_SLAB_SMALL.
　　　　(4)計算申請到的chunk的內存起始地址，轉至step 5.
　　case 2：size等於ngx_slab_exact_size時
　　　　(1)檢查slab字段查找可用的chunk位置
　　　　(2)同上
　　　　(3)同上，不過page類型標記為NGX_SLAB_EXACT
　　　　(4)同上
　　case 3：size大於ngx_slab_exact_size時
　　　　(1)從slab字段中提取出標記chunk使用的bitmap
　　　　(2)同case 1 (1)
　　　　(3)同case 2 (2)
　　　　(4)同case 1 (3),不過page類型標記為NGX_SLAB_BIG
　　　　(5)同case 1 (4)
step 4：調用ngx_slab_alloc_pages申請1頁page,然后根據size情況完成page划分
　　　　及bitmap的初始化標記。
　　case 1：小於ngx_slab_exact_size時
　　　　(1)計算需要使用的bitmap的個數
　　　　(2)完成bitmap使用chunk的標記，同時標記即將分配出去的chunk
　　　　(3)完成剩余的bitmap的初始化
　　　　(4)設置page的類型為NGX_SLAB_SMALL
　　　　(5)計算分配chunk的位置
　　case 2：等於ngx_slab_exact_size時
　　　　(1)完成即將分配的chunk的標記
　　　　(2)設置page的類型為NGX_SLAB_EXACT
　　　　(3)計算分配的chunk的位置
　　case 3:
　　　　(1)完成chunk的標記，及將chunk的大小同時存儲於slab字段中
　　　　(2)設置page的類型為NGX_SLAB_BIG
　　　　(3)計算分配的chunk的位置
完成以上情況處理后，跳至step 5
step 5：返回得到空間。

下面看具體的代碼：

void *
ngx_slab_alloc_locked(ngx_slab_pool_t *pool, size_t size)
{
    size_t            s;
    uintptr_t         p, n, m, mask, *bitmap;
    ngx_uint_t        i, slot, shift, map;
    ngx_slab_page_t  *page, *prev, *slots;
    //case 1:請求的size大於最大的slot的大小，直接以頁的形式分配空間。
    if (size >= ngx_slab_max_size) {

         ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
                       "slab alloc: %uz", size);
        //獲取page
        page = ngx_slab_alloc_pages(pool, (size + ngx_pagesize - 1)
                                          >> ngx_pagesize_shift);
        if (page) {
             //計算具體的page的位置
            p = (page - pool->pages) << ngx_pagesize_shift;
            p += (uintptr_t) pool->start;

        } else {
            p = 0;
        }

        goto done;
    }
    //case 2:請求的size小於等於2048，可用slot滿足請求
    if (size > pool->min_size) {
         shift = 1;
        for (s = size - 1; s >>= 1; shift++) { /* void */ }
        slot = shift - pool->min_shift;

    } else {
         size = pool->min_size;
        shift = pool->min_shift;
        slot = 0;
    }

    ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0,
                   "slab alloc: %uz slot: %ui", size, slot);
    //取得分級數組的起始位置
    slots = (ngx_slab_page_t *) ((u_char *) pool + sizeof(ngx_slab_pool_t));
    //獲取對應的slot的用於取chunk的頁
    page = slots[slot].next;
    //存在用於切割chunk的頁
    if (page->next != page) {
        //case 2.1:請求的大小小於可exact切割的chunk大小，即128,需要占用page中前面的chunk來作為chunk使用狀況的位圖
        if (shift < ngx_slab_exact_shift) {

            do {
                //計算具體的page頁的存放位置
                p = (page - pool->pages) << ngx_pagesize_shift;
                //得到bitmap起始存放的位置
                bitmap = (uintptr_t *) (pool->start + p);
                //計算對應shift大小的bitmap的個數
                map = (1 << (ngx_pagesize_shift - shift))
                          / (sizeof(uintptr_t) * 8);

                for (n = 0; n < map; n++) {
                    //查找未使用的chunk.
                    if (bitmap[n] != NGX_SLAB_BUSY) {
                        //依次檢查bitmap的各位，以得到未使用的chunk.
                        for (m = 1, i = 0; m; m <<= 1, i++) {
                            if ((bitmap[n] & m)) {
                                continue;
                            }
                            //置使用標記
                            bitmap[n] |= m;
                            //計算找到的chunk的偏移位置。
                            i = ((n * sizeof(uintptr_t) * 8) << shift)
                                + (i << shift);
                            //當每個bitmap標示的chunk剛好使用完時，都會去檢查是否還有chunk未使用
                            //若chunk全部使用完，則將當前的page脫離下來。
                            if (bitmap[n] == NGX_SLAB_BUSY) {
                                for (n = n + 1; n < map; n++) {
                                     if (bitmap[n] != NGX_SLAB_BUSY) {
                                         //確認了還有未使用的chunk直接返回。
                                         p = (uintptr_t) bitmap + i;

                                         goto done;
                                     }
                                }
                                //page頁中的chunk都使用完了，將page脫離
                                //與NGX_SLAB_PAGE_MASK的反&運算是為了去除之前設置的page類型標記以得到prev的地址。
                                prev = (ngx_slab_page_t *)
                                            (page->prev & ~NGX_SLAB_PAGE_MASK);
                                prev->next = page->next;
                                page->next->prev = page->prev;

                                page->next = NULL;
                                //置chunk的類型
                                page->prev = NGX_SLAB_SMALL;
                            }

                            p = (uintptr_t) bitmap + i;

                            goto done;
                        }
                    }
                }

                page = page->next;

            } while (page);

        } else if (shift == ngx_slab_exact_shift) {
            //請求的大小剛好為exact的大小，即128,這時slab僅做bitmap使用
            do {
                //直接比較slab看有空的chunk不。
                if (page->slab != NGX_SLAB_BUSY) {
                    //逐位比較，查找chunk.
                    for (m = 1, i = 0; m; m <<= 1, i++) {
                        if ((page->slab & m)) {
                            continue;
                        }
                        //置使用標記
                        page->slab |= m;
                        //檢查page中的chunk是否使用完,使用完則做脫離處理
                        if (page->slab == NGX_SLAB_BUSY) {
                             prev = (ngx_slab_page_t *)
                                            (page->prev & ~NGX_SLAB_PAGE_MASK);
                            prev->next = page->next;
                            page->next->prev = page->prev;
                    
                            page->next = NULL;
                            page->prev = NGX_SLAB_EXACT;
                        }

                        p = (page - pool->pages) << ngx_pagesize_shift;
                        p += i << shift;
                        p += (uintptr_t) pool->start;

                        goto done;
                    }
                }

                page = page->next;

            } while (page);

        } else { /* shift > ngx_slab_exact_shift */
            //case 2.3:申請的size大小128，但小於等於2048時。
            //此時的slab同時存儲bitmap及表示chunk大小的shift,高位為bitmap.
            //獲取bitmap的高位mask.
            n = ngx_pagesize_shift - (page->slab & NGX_SLAB_SHIFT_MASK);
            n = 1 << n;
            n = ((uintptr_t) 1 << n) - 1;
            mask = n << NGX_SLAB_MAP_SHIFT;

            do {
                 if ((page->slab & NGX_SLAB_MAP_MASK) != mask) {
                    //逐位查找空的chunk.
                     for (m = (uintptr_t) 1 << NGX_SLAB_MAP_SHIFT, i = 0;
                          m & mask;
                         m <<= 1, i++)
                    {
                         if ((page->slab & m)) {
                            continue;
                        }

                        page->slab |= m;
                        //檢查page中的chunk是否使用完
                        if ((page->slab & NGX_SLAB_MAP_MASK) == mask) {
                             prev = (ngx_slab_page_t *)
                                            (page->prev & ~NGX_SLAB_PAGE_MASK);
                            prev->next = page->next;
                            page->next->prev = page->prev;

                            page->next = NULL;
                            page->prev = NGX_SLAB_BIG;
                        }

                        p = (page - pool->pages) << ngx_pagesize_shift;
                        p += i << shift;
                        p += (uintptr_t) pool->start;

                        goto done;
                    }
                }

                page = page->next;

            } while (page);
        }
    }

    page = ngx_slab_alloc_pages(pool, 1);

    if (page) {
        if (shift < ngx_slab_exact_shift) {
            //page用於小於128的chunk時，
            //獲取page的存放位置
            p = (page - pool->pages) << ngx_pagesize_shift;
            //獲取bitmap的開始位置
            bitmap = (uintptr_t *) (pool->start + p);

            s = 1 << shift;
            //計算chunk的個數
            n = (1 << (ngx_pagesize_shift - shift)) / 8 / s;

            if (n == 0) {
                n = 1;
            }
            //給bitmap占用的chunk置標記，同時對將要使用的chunk進行標記。
            bitmap[0] = (2 << n) - 1;
            //計算要使用的bitmap的個數
            map = (1 << (ngx_pagesize_shift - shift)) / (sizeof(uintptr_t) * 8);
            //從第二個開始初始化bitmap.
            for (i = 1; i < map; i++) {
                bitmap[i] = 0;
            }

            page->slab = shift;
            page->next = &slots[slot];
            //設置page的類型，低位存儲
            page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_SMALL;

            slots[slot].next = page;
            //計算申請的chunk的位置。
            p = ((page - pool->pages) << ngx_pagesize_shift) + s * n;
            p += (uintptr_t) pool->start;

            goto done;

        } else if (shift == ngx_slab_exact_shift) {
            //chunk的大小正好為128時，此時處理很簡單
            page->slab = 1;
            page->next = &slots[slot];
            //置chunk類型
            page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_EXACT;

            slots[slot].next = page;

            p = (page - pool->pages) << ngx_pagesize_shift;
            p += (uintptr_t) pool->start;

            goto done;

        } else { /* shift > ngx_slab_exact_shift */
            //大於128時，slab要存儲bitmap及表示chunk大小的shift.
             page->slab = ((uintptr_t) 1 << NGX_SLAB_MAP_SHIFT) | shift;
            page->next = &slots[slot];
            page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_BIG;

            slots[slot].next = page;

            p = (page - pool->pages) << ngx_pagesize_shift;
            p += (uintptr_t) pool->start;

            goto done;
        }
    }

    p = 0;

done:

     ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0, "slab alloc: %p", p);

    return (void *) p;
}

然后補充下，ngx_slab_alloc_pages函數的代碼分析:

//這個函數是用來申請page的，此函數的實現也為nginx slab在申請大內存的處理時留下了隱患。
static ngx_slab_page_t *
ngx_slab_alloc_pages(ngx_slab_pool_t *pool, ngx_uint_t pages)
{
    ngx_slab_page_t  *page, *p;
    //在slab page的管理頁中查找，找到slab管理塊中能夠一次滿足要求的slab,這和slab page的管理時不合並有關
    for (page = pool->free.next; page != &pool->free; page = page->next) {
        //找到了合適的slab
        if (page->slab >= pages) {
            //對於大於請求page數的情況，會將前pages個切分出去,page[pages]剛好為將
            //pages個切分出去后，逗留下的第一個，正好作為構建新結點的第一個。下面
            //其實是一個雙向鏈表插入及刪除節點時的操作
            if (page->slab > pages) {
                page[pages].slab = page->slab - pages;
                page[pages].next = page->next;
                page[pages].prev = page->prev;

                p = (ngx_slab_page_t *) page->prev;
                p->next = &page[pages];
                page->next->prev = (uintptr_t) &page[pages];

            } else {
                //恰好等於時，不用進行切分直接刪除節點
                p = (ngx_slab_page_t *) page->prev;
                p->next = page->next;
                page->next->prev = page->prev;
            }
            //修改page對應的狀態 
            page->slab = pages | NGX_SLAB_PAGE_START;
            page->next = NULL;
            page->prev = NGX_SLAB_PAGE;

            if (--pages == 0) {
                return page;
            }
            //對於pages大於1的情況，還處理非第一個page的狀態，修改為BUSY
            for (p = page + 1; pages; pages--) {
                p->slab = NGX_SLAB_PAGE_BUSY;
                p->next = NULL;
                p->prev = NGX_SLAB_PAGE;
                p++;
            }

            return page;
        }
    }

    ngx_slab_error(pool, NGX_LOG_CRIT, "ngx_slab_alloc() failed: no memory");

    return NULL;
}

下面是slab內存管理機制的釋放過程分析：
step 1：判斷異常情況，得到釋放空間位於的page的slab 管理結構的位置及page的位置。
step 2：獲取釋放空間位於的page的類型，根據類型進行處理：
　　case 1：NGX_SLAB_SMALL
　　　　(1)從slab字段中取出chunk的大小
　　　　(2)計算要釋放的空間位於page中的chunk的偏移
　　　　(3)計算對應chunk位於bitmap數組中的第幾個bitmap
　　　　(4)計算對應bitmap的地址
　　　　(5)檢查對應的chunk的bitmap中的標記，若為未釋放標記則進行后面的處理，否則
　　　　　　直接返回已經釋放。
　　　　(6)將釋放空間的page重新置於對應分級數組的管理下
　　　　(7)置釋放標記，同時檢查頁中管理的chunk是否均為未使用，若全為，則調用
　　　　　　ngx_slab_free_pages進行page的回收，即將其加入slab page的管理之下。
　　　　　　否則返回。
　　case 2：NGX_SLAB_EXACT
　　　　(1)同case 1 (2)
　　　　(2)同case 1 (5)
　　　　(3)同case 1 (7)
　　case 3：NGX_SLAB_BIG
　　　　(1)從slab字段中提取出bitmap及chunk的大小
　　　　(2)同case 1 (2)
　　　　(3)同case 1 (5)
　　　　(4)同case 1 (7)
　　　case 4：NGX_SLAB_PAGE
　　　　好像是處理一些頁相關的釋放情況，不詳細討論
step 3：返回

下面看具體代碼：

void
ngx_slab_free_locked(ngx_slab_pool_t *pool, void *p)
{
    size_t            size;
    uintptr_t         slab, m, *bitmap;
    ngx_uint_t        n, type, slot, shift, map;
    ngx_slab_page_t  *slots, *page;

    ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, ngx_cycle->log, 0, "slab free: %p", p);
    //判斷異常情況
    if ((u_char *) p < pool->start || (u_char *) p > pool->end) {
        ngx_slab_error(pool, NGX_LOG_ALERT, "ngx_slab_free(): outside of pool");
        goto fail;
    }
    //計算釋放的page的偏移
    n = ((u_char *) p - pool->start) >> ngx_pagesize_shift;
    //獲取對應slab_page管理結構的位置
    page = &pool->pages[n];
    slab = page->slab;
    //獲取page的類型
    type = page->prev & NGX_SLAB_PAGE_MASK;

    switch (type) {
    //page類型為小於128時。
    case NGX_SLAB_SMALL:
        //此時chunk的大小存放於slab中。
        shift = slab & NGX_SLAB_SHIFT_MASK;
        //計算chunk的大小
        size = 1 << shift;
        
        if ((uintptr_t) p & (size - 1)) {
            goto wrong_chunk;
        }
        //這段特別巧妙，由於前面對頁進行了內存對齊的處理，因此下面的式子可直接
        //求出p位於的chunk偏移，即是page中的第幾個chunk.
        n = ((uintptr_t) p & (ngx_pagesize - 1)) >> shift;
        //計算chunk位於bitmap管理的chunk的偏移，注意對2的n次方的取余操作的實現。
        m = (uintptr_t) 1 << (n & (sizeof(uintptr_t) * 8 - 1));
        //計算p指向的chunk位於第幾個bitmap中。
        n /= (sizeof(uintptr_t) * 8);
        //計算bitmap的起始位置
        bitmap = (uintptr_t *) ((uintptr_t) p & ~(ngx_pagesize - 1));
        //判斷是否處於free狀態。
        if (bitmap[n] & m) {
            //將page插入到對應slot分級數組管理的slab鏈表中，位於頭部
            if (page->next == NULL) {
                slots = (ngx_slab_page_t *)
                                   ((u_char *) pool + sizeof(ngx_slab_pool_t));
                slot = shift - pool->min_shift;

                page->next = slots[slot].next;
                slots[slot].next = page;

                page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_SMALL;
                page->next->prev = (uintptr_t) page | NGX_SLAB_SMALL;
            }
            //置釋放標記
            bitmap[n] &= ~m;
            //計算chunk的個數
            n = (1 << (ngx_pagesize_shift - shift)) / 8 / (1 << shift);

            if (n == 0) {
                n = 1;
            }
            //檢查首個bitmap對bitmap占用chunk的標記情況。
            if (bitmap[0] & ~(((uintptr_t) 1 << n) - 1)) {
                goto done;
            }
            //計算bitmap的個數
            map = (1 << (ngx_pagesize_shift - shift)) / (sizeof(uintptr_t) * 8);
            
            for (n = 1; n < map; n++) {
                if (bitmap[n]) {
                    goto done;
                }
            }
            //如果釋放后page中沒有在使用的chunk，則進行進一步的回收，改用slab_page進行管理
            ngx_slab_free_pages(pool, page, 1);

            goto done;
        }

        goto chunk_already_free;

    case NGX_SLAB_EXACT:

        m = (uintptr_t) 1 <<
                (((uintptr_t) p & (ngx_pagesize - 1)) >> ngx_slab_exact_shift);
        size = ngx_slab_exact_size;

        if ((uintptr_t) p & (size - 1)) {
            goto wrong_chunk;
        }

        if (slab & m) {
            if (slab == NGX_SLAB_BUSY) {
                slots = (ngx_slab_page_t *)
                                   ((u_char *) pool + sizeof(ngx_slab_pool_t));
                slot = ngx_slab_exact_shift - pool->min_shift;

                page->next = slots[slot].next;
                slots[slot].next = page;

                page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_EXACT;
                page->next->prev = (uintptr_t) page | NGX_SLAB_EXACT;
            }

            page->slab &= ~m;

            if (page->slab) {
                goto done;
            }

            ngx_slab_free_pages(pool, page, 1);

            goto done;
        }

        goto chunk_already_free;

    case NGX_SLAB_BIG:

        shift = slab & NGX_SLAB_SHIFT_MASK;
        size = 1 << shift;

        if ((uintptr_t) p & (size - 1)) {
            goto wrong_chunk;
        }

        m = (uintptr_t) 1 << ((((uintptr_t) p & (ngx_pagesize - 1)) >> shift)
                              + NGX_SLAB_MAP_SHIFT);

        if (slab & m) {

            if (page->next == NULL) {
                slots = (ngx_slab_page_t *)
                                   ((u_char *) pool + sizeof(ngx_slab_pool_t));
                slot = shift - pool->min_shift;

                page->next = slots[slot].next;
                slots[slot].next = page;

                page->prev = (uintptr_t) &slots[slot] | NGX_SLAB_BIG;
                page->next->prev = (uintptr_t) page | NGX_SLAB_BIG;
            }

            page->slab &= ~m;

            if (page->slab & NGX_SLAB_MAP_MASK) {
                goto done;
            }

            ngx_slab_free_pages(pool, page, 1);

            goto done;
        }

        goto chunk_already_free;

    case NGX_SLAB_PAGE:

        if ((uintptr_t) p & (ngx_pagesize - 1)) {
            goto wrong_chunk;
        }

        if (slab == NGX_SLAB_PAGE_FREE) {
            ngx_slab_error(pool, NGX_LOG_ALERT,
                           "ngx_slab_free(): page is already free");
            goto fail;
        }

        if (slab == NGX_SLAB_PAGE_BUSY) {
            ngx_slab_error(pool, NGX_LOG_ALERT,
                           "ngx_slab_free(): pointer to wrong page");
            goto fail;
        }

        n = ((u_char *) p - pool->start) >> ngx_pagesize_shift;
        size = slab & ~NGX_SLAB_PAGE_START;

        ngx_slab_free_pages(pool, &pool->pages[n], size);

        ngx_slab_junk(p, size << ngx_pagesize_shift);

        return;
    }

    /* not reached */

    return;

done:

    ngx_slab_junk(p, size);

    return;

wrong_chunk:

    ngx_slab_error(pool, NGX_LOG_ALERT,
                   "ngx_slab_free(): pointer to wrong chunk");

    goto fail;

chunk_already_free:

    ngx_slab_error(pool, NGX_LOG_ALERT,
                   "ngx_slab_free(): chunk is already free");

fail:

    return;
}

補充ngx_slab_free_pages的代碼分析：

static void
ngx_slab_free_pages(ngx_slab_pool_t *pool, ngx_slab_page_t *page,
    ngx_uint_t pages)
{
    ngx_slab_page_t  *prev;
    //計算結點后部跟的page的數目
    page->slab = pages--;
    //對跟的page的page管理結構slab_page進行清空。
    if (pages) {
        ngx_memzero(&page[1], pages * sizeof(ngx_slab_page_t));
    }
    //如果page后面還跟有節點，則將其連接至page的前一個結點。
    if (page->next) {
        prev = (ngx_slab_page_t *) (page->prev & ~NGX_SLAB_PAGE_MASK);
        prev->next = page->next;
        page->next->prev = page->prev;
    }
    //將page重新歸於，slab_page的管理結構之下。放於管理結構的頭部。
    page->prev = (uintptr_t) &pool->free;
    page->next = pool->free.next;

    page->next->prev = (uintptr_t) page;

    pool->free.next = page;
}

然后再看下slot分級數組對於page的管理：
初始化：初始化時，各個slot將未分配具體的page.
申請時：初始申請時沒有page空間可用，然后會像slab page管理結構申請page空間，完成
page的划分chunk及bitmap的初始后，會分配一塊chunk以供使用。對於再次申請時
會直接從page中取可用的chunk，當page時無可用的chunk時，此page頁會暫時脫離
slot分級數組的管理，即將其從對應鏈表中刪除。
釋放時:釋放時完成空間的回收標記后，會將page插入到對應的slot管理鏈表的頭部，然后
會進一步檢查些page是否全部chunk均未使用，若是，則進步回收此page將其置於
slab page管理結構的管理之下。
具體如下圖示:
BEGIN:

AFTER:

..
最后就是對於slab管理機制對於使用一段時間后，對於大內存申請的處理會大概率返回失敗
的情況分析。

主要原因在於ngx_slab_free_pages函數里面，從函數中看出，每次回收頁到slab page的管理
結構中時只會對page進行加入鏈表的操作，而沒有如同伙伴算法的結點合並操作，這樣經由
ngx_slab_alloc_pages申請大內存時，在查找一個結點擁有符合要求的page數目時，將不能
得到一個滿足要求的節點，因為使用一段時間后，可能slab page管理結構中的各個結點均會
成為小的數目page的組合。導致申請大的內存失敗。

 轉載請注明出處：http://www.cnblogs.com/doop-ymc/p/3412572.html