Nginx内存池理解

　　工作中经常遇到内存泄漏，而且又很难排查是哪里没有释放导致，如果采用内存池的方式，内存都从内存池里面分配，销毁内存池时才统一释放，就能减少很多的内存泄漏问题。使用内存池的意义，一个是能够有效解决内存碎片化的问题，再一个就是避免内存泄漏的问题；本文主要介绍Nginx的内存池。

　　（1）Nginx内存池结构

　　　　大块结构定义

//大块
struct ngx_pool_large_s {
    ngx_pool_large_t     *next;//下一个大块内存
    void                 *alloc;//分配的大块内存空间
};

　　ngx_pool_data_t 结构定义

//ngx_pool_data_t可以理解为是嵌入到ngx_pool_s里
typedef struct {
    u_char               *last;//内存块中last指向还没有用过的内存的头部地址，也可以认为分配的小块内存就是指针last的移动
    u_char               *end;//当前chunck的末尾
    ngx_pool_t           *next;//指向下一个chunck
    ngx_uint_t            failed;//统计该内存池不能满足分配请求的次数
} ngx_pool_data_t;
//申请小块内存都会在chunck里面分配

　　内存池结构定义

struct ngx_pool_s {
    ngx_pool_data_t       d;//chunck链表
    size_t                max;//chunck内存最大大小
    ngx_pool_t           *current;
    ngx_chain_t          *chain;//可以挂载一个chain结构
    ngx_pool_large_t     *large;//大块链表
    ngx_pool_cleanup_t   *cleanup;//挂载一些内存池释放的时候，同时释放的资源
    ngx_log_t            *log;
};

　　大块的链表结构：

 　　内存池结构：

 　　由上图可知，小块内存是在chunck里面分配，end指针指向的是整个chunck的尾部，last指针指向未使用的内存首部地址（分配内存开始位置），为了方便统一管理，large节点是放在chunck里面，它指向大块的链表。

　　（2）创建内存池

ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log)//size为chunck的大小
{
    ngx_pool_t  *p;

    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);//分配一块size大小，不同系统会不一样
    if (p == NULL) {
        return NULL;
    }

    p->d.last = (u_char *) p + sizeof(ngx_pool_t);//指向一个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;//最大不超过NGX_MAX_ALLOC_FROM_POOL

    p->current = p;//指向当前的内存池
    p->chain = NULL;
    p->large = NULL;
    p->cleanup = NULL;
    p->log = log;

    return p;
}

　　（3）销毁内存池

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

#if (NGX_DEBUG)

    /*
     * we could allocate the pool->log from this pool
     * so we cannot use this log while free()ing the pool
     */

    for (l = pool->large; l; l = l->next) {
        ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
    }

    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
                       "free: %p, unused: %uz", p, p->d.end - p->d.last);

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

#endif
	//大块清理
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            ngx_free(l->alloc);
        }
    }
	//chunck清理
    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        ngx_free(p);

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

　　（4）重置内存池

　　释放所有大块内存，将所有chunck的last指针、failed值进行重置。

void ngx_reset_pool(ngx_pool_t *pool)
{
    ngx_pool_t        *p;
    ngx_pool_large_t  *l;
	//释放所有的大块内存（大块的链表节点依然还在，因为它存储在chunck里面）
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            ngx_free(l->alloc);
        }
    }
	//将chunck中last指针初始化，chunck内存中的数据不需要清理，后面分配时覆盖
    for (p = pool; p; p = p->d.next) {
        p->d.last = (u_char *) p + sizeof(ngx_pool_t);//指向分配内存的起始地址
        p->d.failed = 0;//置0
    }

    pool->current = pool;
    pool->chain = NULL;
    pool->large = NULL;
}

　　（5）分配内存

　　ngx_palloc 分配的内存是对齐的，如果分配的内存小于chunck的大小，就到chunck中进行小块分配，否则就到大块去分配。

void * ngx_palloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
    if (size <= pool->max) {//小于chunck最大大小，就分配到chunck中(小块)
        return ngx_palloc_small(pool, size, 1);//1：内存对齐
    }
#endif
	//否则，分配到大块中
    return ngx_palloc_large(pool, size);
}

　　ngx_pnalloc 分配的内存是不对齐的，如果分配的内存小于chunck的大小，就到chunck中进行小块分配，否则就到大块去分配。

void * ngx_pnalloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
    if (size <= pool->max) {
        return ngx_palloc_small(pool, size, 0);//0：内存不对齐
    }
#endif

    return ngx_palloc_large(pool, size);
}

　　（6）ngx_palloc_small小块分配

　　从当前chunck开始遍历，如果当前chunck有足够空间可分配，那么就返回可分配的起始地址

　　当遍历完所有chunck都找不到可分配的空间，则新建一个chunck

static ngx_inline void * ngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
{
    u_char      *m;
    ngx_pool_t  *p;

    p = pool->current;//当前的内存池

    do {
        m = p->d.last;//指向当前chunck块中还未分配的首位地址

        if (align) {
            m = ngx_align_ptr(m, NGX_ALIGNMENT);//对齐内存指针，加快存取速度
        }
	//如果当前chunck有足够空间可分配，那么就返回内存可分配的起始地址
        if ((size_t) (p->d.end - m) >= size) {
            p->d.last = m + size;

            return m;//返回可分配的内存地址
        }

        p = p->d.next;//指向下一chunck

    } while (p);
	
    //遍历完所有chunck都找不到可分配的空间，则需要新建一个chunck，返回该chunck可分配的起始地址
    return ngx_palloc_block(pool, size);
}

　　（7）ngx_palloc_block 新建一个chunck

　　新建一个chunck过程与新建内存池相似，从内存中取一块地址分配一个chunck，进行内存对齐

　　最后返回chunck中可分配内存的起始地址

static void * ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    size_t       psize;
    ngx_pool_t  *p, *new;
	
    psize = (size_t) (pool->d.end - (u_char *) pool);//去除头部后，得到真正使用的内存空间大小，一个chunck可用空间大小
    //分配一块psize大小的内存，返回可用空间的起始地址
    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
    if (m == NULL) {
        return NULL;
    }

    new = (ngx_pool_t *) m;
    new->d.end = m + psize;//整个chunck的大小
    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;

    for (p = pool->current; p->d.next; p = p->d.next) {
		
        if (p->d.failed++ > 4) {//如果failed > 4, 漏过这个chunck(也就是说每个块，只允许失败4次，失败4次后，让current指向下一个chunck)
	    pool->current = p->d.next;
        }
    }
    //把chunck插入链表尾部
    p->d.next = new;

    return m;
}

　　（8）ngx_palloc_large 大块分配

　　从申请一块size大小的内存，大于3使用尾插法，大于3使用头插法

　　在chunck里面分配一个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的内存
    p = ngx_alloc(size, pool->log);
    if (p == NULL) {
        return NULL;
    }

    n = 0;

    for (large = pool->large; large; large = large->next) {
	//n小于3使用尾插法
        if (large->alloc == NULL) {//找到最后一个节点
            large->alloc = p;//指向分配的内存块
            return p;
        }

        if (n++ > 3) {//大于3使用头插法，好处就是查找最近插入点的效率快很多，3可能是经验值
            break;
        }
    }
    //在chunck里分配一个链表的节点（用于指向大块），这个节点是存放在小块里，原因是避免内存碎片化，便于统一管理
    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }
    //头插法
    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}