Nginx 内存池（pool）分析

装载自：http://www.linuxidc.com/Linux/2011-08/41860.htm

Nginx 内存池管理的源码在src/core/ngx_palloc.h、src/core/ngx_palloc.c 两个文件中。

先将我整理的注释等内容贴上，方便下面分析：

ngx_create_pool：创建pool

ngx_destory_pool：销毁 pool

ngx_reset_pool：重置pool中的部分数据

ngx_palloc/ngx_pnalloc：从pool中分配一块内存

ngx_pool_cleanup_add：为pool添加cleanup数据

 

struct ngx_pool_cleanup_s {

    ngx_pool_cleanup_pt   handler;  // 当前 cleanup 数据的回调函数

    void                 *data;     // 内存的真正地址

    ngx_pool_cleanup_t   *next;     // 指向下一块 cleanup 内存的指针

};

 

struct ngx_pool_large_s {

    ngx_pool_large_t     *next;     // 指向下一块 large 内存的指针

    void                 *alloc;    // 内存的真正地址

};

 

typedef struct {

    u_char               *last;     // 当前 pool 中用完的数据的结尾指针，即可用数据的开始指针

    u_char               *end;      // 当前 pool 数据库的结尾指针

    ngx_pool_t           *next;     // 指向下一个 pool 的指针

    ngx_uint_t            failed;   // 当前 pool 内存不足以分配的次数

} ngx_pool_data_t;

 

struct ngx_pool_s {

    ngx_pool_data_t       d;        // 包含 pool 的数据区指针的结构体

    size_t                max;      // 当前 pool 最大可分配的内存大小（Bytes）

    ngx_pool_t           *current;  // pool 当前正在使用的pool的指针

    ngx_chain_t          *chain;    // pool 当前可用的 ngx_chain_t 数据，注意：由 ngx_free_chain 赋值

    ngx_pool_large_t     *large;    // pool 中指向大数据快的指针（大数据快是指 size > max 的数据块）

    ngx_pool_cleanup_t   *cleanup;  // pool 中指向 ngx_pool_cleanup_t 数据块的指针

    ngx_log_t            *log;      // pool 中指向 ngx_log_t 的指针，用于写日志的

};

 

使用 ngx_create_pool、ngx_destory_pool、ngx_reset_pool三个函数来创建、销毁、重置 pool。使用ngx_palloc、ngx_pnalloc、ngx_pool_cleanup_add来使用pool。使用结构体 ngx_pool_t 管理整个 pool。下面将详细分析其工作方式。

 

我们以 nginx 接受并处理 http 请求的方式，来分析pool的工作流程。

在 ngx_http_request.c 中，ngx_http_init_request 函数便是 http 请求处理的开始，在其中调用了 ngx_create_pool 来创建对应于 http 请求的 pool。同一个c文件中，ngx_http_free_request 函数便是 http 请求处理的结束，在其中调用了 ngx_destory_pool。

我们一步步来看具体工作流程。首先，调用ngx_create_pool来创建一个pool，源码如下：

ngx_pool_t *

ngx_create_pool(size_t size, ngx_log_t *log)

{

    ngx_pool_t  *p;

 

    // 分配一块 size 大小的内存

    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log); 

    if (p == NULL) {

        return NULL;

    }

 

    // 对pool中的数据项赋初始值

    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;  // pool 中最大可用大小

 

    // 继续赋初始值

    p->current = p;

    p->chain = NULL;

    p->large = NULL;

    p->cleanup = NULL;

    p->log = log;

 

    return p;

}

 

创建完pool后，pool示例如为：

 

最左边的便是创建的pool内存池，其中首sizeof(ngx_pool_t)便是pool的header信息，header信息中的各个字段用于管理整个pool。由于此时刚创建，pool中除了header之外，没有任何数据。

注意：current 永远指向此pool的开始地址。current的意思是当前的pool地址，而非pool中的地址。

从代码的角度来说，pool->d.last ~ pool->d.end 中的内存区便是可用数据区。

 

    接下来，我们使用ngx_palloc从内存池中获取一块内存，源码如下：

void *

ngx_palloc(ngx_pool_t *pool, size_t size)

{

    u_char      *m;

    ngx_pool_t  *p;

 

    // 判断 size 是否大于 pool 最大可使用内存大小

    if (size <= pool->max) {

 

        p = pool->current;

 

        do {

            // 将 m 对其到内存对齐地址

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

            // 判断 pool 中剩余内存是否够用

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

}

此处需要分3步进行讨论。当需要的内存大于pool最大可分配内存大小时；否则，当需要的内存大于pool目前可用内存大小时；否则，当需要的内存可以在此pool中分配时。

我们先从最简单的情况开始，即，当需要的内存可以在此pool中分配时。此时从代码流程可以看到，判断内存够用后，直接移动 p->d.last 指针，令其向下偏移到指定的值即可，使用此种方式可以避免新分配内存的系统调用，效率大大提高。此时的 pool 示例图为：

 

我们继续讨论第二种情况，当需要的内存大于pool目前可用内存大小时。从代码流程可以看到，此时首先寻找pool数据区中的下一个节点，看是否有够用的内存，如不够，则调用ngx_palloc_block 重新分配，我们将问题简单化，由于刚创建pool，pool->d.next指针为NULL，所以肯定会重新分配一块内存。源码如下：

static void *

ngx_palloc_block(ngx_pool_t *pool, size_t size)

{

    u_char      *m;

    size_t       psize;

    ngx_pool_t  *p, *new, *current;

 

    // 先前的整个 pool 的大小

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

    m = ngx_align_ptr(m, NGX_ALIGNMENT);

    new->d.last = m + size;

 

    current = pool->current;

 

// 判断在当前 pool 分配内存的失败次数，即：不能复用当前 pool 的次数，

// 如果大于 4 次，这放弃在此 pool 上再次尝试分配内存，以提高效率

    for (p = current; p->d.next; p = p->d.next) {

        if (p->d.failed++ > 4) {

            current = p->d.next;

        }

    }

 

    // 让旧指针数据区的 next 指向新分配的 pool

    p->d.next = new;

 

    // 更新 current 指针

    pool->current = current ? current : new;

 

    return m;

}

    通过上面可以看到，nginx 重新分配了一个新pool，新pool大小跟之��的大小一样，然后对 pool 赋初始值，最终将新pool串到老pool的后面。注意，此处新pool的current指针目前没有起用，为NULL。另外，在此处会判断一个pool尝试分配内存失败的次数，如果失败次数大于4（不等于4），则更新current指针，放弃对老pool的内存进行再使用。此时的pool示例图为：       

 

我们讨论最后一种情况，当需要的内存大于pool最大可分配内存大小时，此时首先判断size已经大于pool->max的大小了，所以直接调用ngx_palloc_large进行大内存分配，我们将注意力转向这个函数，源码为：

static void *

ngx_palloc_large(ngx_pool_t *pool, size_t size)

{

    void              *p;

    ngx_uint_t         n;

    ngx_pool_large_t  *large;

 

// 重新申请一块大小为 size 的新内存

// 注意：此处不使用 ngx_memalign 的原因是，新分配的内存较大，对其也没太大必要

//       而且后面提供了 ngx_pmemalign 函数，专门用户分配对齐了的内存

    p = ngx_alloc(size, pool->log);

    if (p == NULL) {

        return NULL;

    }

 

    n = 0;

 

    // 查找可复用的 large 指针

for (large = pool->large; large; large = large->next) {

    // 判断当前 large 指针是否指向真正的内存，否则直接拿来用

    // ngx_free 可使此指针为 NULL

        if (large->alloc == NULL) {

            large->alloc = p;

            return p;

        }

 

        // 如果当前 large 后串的 large 内存块数目大于 3 （不等于3），

// 则直接去下一步分配新内存，不再查找了

        if (n++ > 3) {

            break;

        }

    }

 

    // 为 ngx_pool_large_t 分配一块内存

    large = ngx_palloc(pool, sizeof(ngx_pool_large_t));

    if (large == NULL) {

        ngx_free(p);

        return NULL;

    }

 

    // 将新分配的 large 串到链表后面

    large->alloc = p;

    large->next = pool->large;

    pool->large = large;

 

    return p;

}

由如上代码可知，函数首先申请一块大小为size的内存，然后判断当前 large 链表中是否有存在复用的可能性，有的话，当然直接赋值返回；如果没有，则新分配一块大小为sizeof(ngx_pool_large_t)的内存，串到large链表的后面。我们继续上面的例子，由于之前没有分配过large内存，所以此时直接将新内存块串起来。此时pool示例图为：

 

         至此，在pool中分配普通内存的情况我们就讨论完了。如果有新内存需要分配，无非也就是在pool中直接移动last指针，next、large next指针后面串接新的内存块而已。

 

我们接下来看看函数ngx_pool_cleanup_add，在pool中分配带有handler的内存，先上源码：

ngx_pool_cleanup_t *

ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)

{

    ngx_pool_cleanup_t  *c;

   

    // 首先申请 sizeof(ngx_pool_cleanup_t) 大小的内存作为header信息

    c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));

    if (c == NULL) {

        return NULL;

    }

 

if (size) {

    // cleanup 中有内存大小的话，分配 size 大小的内存空间

        c->data = ngx_palloc(p, size);

        if (c->data == NULL) {

            return NULL;

        }

 

    } else {

        c->data = NULL;

    }

   

    // 对 cleanup 数据结构其他项进行赋值

    c->handler = NULL;

    c->next = p->cleanup;

 

    // 将 cleanup 数据串进去

    p->cleanup = c;

 

    ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, p->log, 0, "add cleanup: %p", c);

    return c;

}

我们看到源码首先分配 header 大小的头信息内存，然后判断是否要真正分配内存，如果要的话，分配内存，最后将新的数据块串起来。我们继续上面的示例图，将分配一个 cleanup 之后的示例图画出。此时 pool 示例图为：

 

    在此顺带提一点，pool 中的 chain 指向一个 ngx_chain_t 数据，其值是由宏 ngx_free_chain 进行赋予的，指向之前用完了的，可以释放的ngx_chain_t数据。由函数ngx_alloc_chain_link进行使用。

 

接下来我们通过上面的图讨论一下ngx_reset_pool函数，源码：

void

ngx_reset_pool(ngx_pool_t *pool)

{

    ngx_pool_t        *p;

    ngx_pool_large_t  *l;

 

    // 释放 large 数据块的内存

    for (l = pool->large; l; l = l->next) {

        if (l->alloc) {

            ngx_free(l->alloc);

        }

    }

 

    // 将 pool 直接下属 large 设为 NULL 即可，无需再上面的 for 循环中每次都进行设置

    pool->large = NULL;

 

    // 重置指针位置，让 pool 中的内存可用

    for (p = pool; p; p = p->d.next) {

        p->d.last = (u_char *) p + sizeof(ngx_pool_t);

    }

}

    可以看到，代码相当简单，将large、pool 中原有内存还原到初始状态而已。

 

最后我们讨论一下ngx_destory_pool函数，销毁创建的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 中的 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);

        }

    }

 

    // 释放 large 数据块的内存

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

        }

    }

 

    // 释放整个 pool

    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {

        ngx_free(p);

 

        if (n == NULL) {

            break;

        }

    }

}

代码也相当简单，首先调用 cleanup 中的handler函数来清理特定资源，然后释放large内存，最终释放整个pool。

最终整个pool就销毁的无影无踪了。细心的朋友可能会发现，销毁时似乎忘了释放 cleanup 内存块分配的内存了，真的是这样吗？呃，这个还是留给大家自己想吧。