nginx内存池

内存池的结构解析

nginx对内存进行了精细的管理，内部实现了内存池，具体结构如下：
ngx_palloc.h中定义

typedef struct ngx_pool_s            ngx_pool_t;
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;
};

1. nginx内存池第一个变量d ,ngx_pool_data_t

typedef unsigned char __u_char;
typedef __u_char u_char;
typedef uintptr_t       ngx_uint_t;
typedef struct {
    u_char               *last;
    u_char               *end;
    ngx_pool_t           *next;
    ngx_uint_t            failed;
} ngx_pool_data_t;

可以看出此变量，包含了三个指针，两个unsigned char指针存储数据，一个ngx_pool_t指针，指向下一个内存池。一个unsigned int整数。
2. 变量max应该是内存池的大小
3. current变量类型是ngx_pool_t指针，指向的当前内存池
4. 变量chain类型如下

typedef struct ngx_chain_s           ngx_chain_t;
struct ngx_chain_s {
    ngx_buf_t    *buf;
    ngx_chain_t  *next;
};
typedef struct ngx_buf_s  ngx_buf_t;
struct ngx_buf_s {
    u_char          *pos;
    u_char          *last;
    off_t            file_pos;
    off_t            file_last;

    u_char          *start;         /* start of buffer */
    u_char          *end;           /* end of buffer */
    ngx_buf_tag_t    tag;
    ngx_file_t      *file;
    ngx_buf_t       *shadow;


    /* the buf's content could be changed */
    unsigned         temporary:1;

    /*
     * the buf's content is in a memory cache or in a read only memory
     * and must not be changed
     */
    unsigned         memory:1;

    /* the buf's content is mmap()ed and must not be changed */
    unsigned         mmap:1;

    unsigned         recycled:1;
    unsigned         in_file:1;
    unsigned         flush:1;
    unsigned         sync:1;
    unsigned         last_buf:1;
    unsigned         last_in_chain:1;

    unsigned         last_shadow:1;
    unsigned         temp_file:1;

    /* STUB */ int   num;
};

ngx_chain_s可以看到是一个链表，链表中的元素是ngx_buf_s，ngx_buf_s本身又含有ngx_buf_s类型的指针。

5.large变量结构如下

typedef struct ngx_pool_large_s  ngx_pool_large_t;

struct ngx_pool_large_s {
    ngx_pool_large_t     *next;
    void                 *alloc;
};

large变量仅仅是一个链表，而链表中的元素是一个void*指针。

6.cleanup变量
结构如下

typedef void (*ngx_pool_cleanup_pt)(void *data);

typedef struct ngx_pool_cleanup_s  ngx_pool_cleanup_t;

struct ngx_pool_cleanup_s {
    ngx_pool_cleanup_pt   handler;
    void                 *data;
    ngx_pool_cleanup_t   *next;
};

可以看到ngx_pool_cleanup_t结构是包含了两个元素的链表，一个是函数指针，一个void*类型标量。
7. 变量log是一个ngx_log_t的类型的指针，结构如下

typedef struct ngx_log_s             ngx_log_t;
struct ngx_log_s {
    ngx_uint_t           log_level;
    ngx_open_file_t     *file;

    ngx_atomic_uint_t    connection;

    time_t               disk_full_time;

    ngx_log_handler_pt   handler;
    void                *data;

    ngx_log_writer_pt    writer;
    void                *wdata;

    /*
     * we declare "action" as "char *" because the actions are usually
     * the static strings and in the "u_char *" case we have to override
     * their types all the time
     */

    char                *action;

    ngx_log_t           *next;
};

是nginx管理日志模块的结构。

内存池的数据结构总结

内存池提供的接口

创建内存池

ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log);
业务逻辑

ngx_pool_t *
ngx_create_pool(size_t size, ngx_log_t *log)
{
    ngx_pool_t  *p;
	/*这里申请了size大小的内存，且获得的内存地址是NGX_POOL_ALIGNMENT的倍数，或者直接调用malloc申请内存，根据环境来选择*/
    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
    if (p == NULL) {
        return NULL;
    }
	/*这里预留出了sizeof(ngx_pool_t)的空间，end代表了内存的终止地址，d变量的last前面还有sizeof(ngx_pool_t)的大小是申请好的地址*/
    p->d.last = (u_char *) p + sizeof(ngx_pool_t);
    p->d.end = (u_char *) p + size;
    p->d.next = NULL; /*下一个初始化为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;
	/*current指向当前的ngx_pool_t*/
    p->current = p;
    p->chain = NULL;
    p->large = NULL;
    p->cleanup = NULL;
    p->log = log;

    return p;
}

销毁内存池

void 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);
        }
    }
	/*销毁pool的large链表，链表的元素alloc是堆上的地址*/
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            ngx_free(l->alloc);
        }
    }
	/*销毁pool本身，pool在d中存着，d中链表的每个元素的地址是一个堆上的pool*/
    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        ngx_free(p);

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

重置pool

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;
	/*释放large列表的空间*/
    for (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            ngx_free(l->alloc);
        }
    }
	/*重置d中链表上的每个pool的last地址和failed*/
    for (p = pool; p; p = p->d.next) {
        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
        p->d.failed = 0;
    }
	/*设置当前pool*/
    pool->current = pool;
    pool->chain = NULL;
    pool->large = NULL;
}

从内存池申请内存

void *
ngx_palloc(ngx_pool_t *pool, size_t size)
{
/*两种申请内存的方式，一种是small一种large*/
#if !(NGX_DEBUG_PALLOC)
    if (size <= pool->max) {
        return ngx_palloc_small(pool, size, 1);
    }
#endif

    return ngx_palloc_large(pool, size);
}
#define ngx_align_ptr(p, a)                                                   \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
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;

        if (align) {
        	/*m的地址对齐，使m的地址是大于m的sizeof(unsigned long)的倍数的最小值*/
            m = ngx_align_ptr(m, NGX_ALIGNMENT);
        }
		/*如果当前pool剩余内存还剩下的空间充足，则从当前空间获取，并返回m,如果不够使用则从next获取*/
        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);
}
static void *
ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    size_t       psize;
    ngx_pool_t  *p, *new;
	/*计算pool中已经申请的空间*/
    psize = (size_t) (pool->d.end - (u_char *) pool);
	/*从系统申请空间，大小为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;
    new->d.next = NULL;
    new->d.failed = 0;

    m += sizeof(ngx_pool_data_t);
    /*m进行内存对齐，获取内存地址是比m大的NGX_ALIGNMENT的倍数*/
    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) {
        	//更新pool的current是failed>4的d的下一个元素
            pool->current = p->d.next;
        }
    }
	// 把新生成的pool插入链表d的尾部。
    p->d.next = new;
    return m;
}
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) {
        if (large->alloc == NULL) {
            large->alloc = p;
            return p;
        }
		/*只查找4次就break退出,而不是查到末尾?*/
        if (n++ > 3) {
            break;
        }
    }
	// 从d中申请一块内存给打large,大小是sizeof(ngx_pool_large_t)
    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }
	// 把large插入到pool的large链表的头部
    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}

内存对齐方式申请内存

void *
ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)

void *
ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
{
    void              *p;
    ngx_pool_large_t  *large;
	/*内存对齐方式，申请内存*/
    p = ngx_memalign(alignment, size, pool->log);
    if (p == NULL) {
        return NULL;
    }

    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }
	/*把large放入到pool的large链表首部*/
    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}

释放内存

ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);

ngx_int_t
ngx_pfree(ngx_pool_t *pool, void *p)
{
    ngx_pool_large_t  *l;
	/*从large列表中，查找指针，释放内存*/
    for (l = pool->large; l; l = l->next) {
        if (p == l->alloc) {
            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
                           "free: %p", l->alloc);
            ngx_free(l->alloc);
            l->alloc = NULL;

            return NGX_OK;
        }
    }

    return NGX_DECLINED;
}

增加一个cleanup到cleanup链表中

ngx_pool_cleanup_t *
ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
    ngx_pool_cleanup_t  *c;
	// 申请ngx_pool_cleanup_t空间
    c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
    if (c == NULL) {
        return NULL;
    }

    if (size) {
    	// 给data申请空间，大小是size
        c->data = ngx_palloc(p, size);
        if (c->data == NULL) {
            return NULL;
        }

    } else {
        c->data = NULL;
    }

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

ngx_pool_run_cleanup_file接口

void
ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd)
{
    ngx_pool_cleanup_t       *c;
    ngx_pool_cleanup_file_t  *cf;
	/*遍历cleanup链表，调用ngx_pool_cleanup_file处理文件*/
    for (c = p->cleanup; c; c = c->next) {
        if (c->handler == ngx_pool_cleanup_file) {

            cf = c->data;

            if (cf->fd == fd) {
                c->handler(cf);
                c->handler = NULL;
                return;
            }
        }
    }
}

ngx_pool_cleanup_file接口

void
ngx_pool_cleanup_file(void *data)
{
    ngx_pool_cleanup_file_t  *c = data;

    ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, c->log, 0, "file cleanup: fd:%d",
                   c->fd);
	// 关闭文件句柄
    if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
        ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
                      ngx_close_file_n " \"%s\" failed", c->name);
    }
}

ngx_pool_delete_file 接口

void
ngx_pool_delete_file(void *data)
{
    ngx_pool_cleanup_file_t  *c = data;

    ngx_err_t  err;

    ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, c->log, 0, "file cleanup: fd:%d %s",
                   c->fd, c->name);
	/*删除文件*/
    if (ngx_delete_file(c->name) == NGX_FILE_ERROR) {
        err = ngx_errno;

        if (err != NGX_ENOENT) {
            ngx_log_error(NGX_LOG_CRIT, c->log, err,
                          ngx_delete_file_n " \"%s\" failed", c->name);
        }
    }
	/*关闭文件*/
    if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
        ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
                      ngx_close_file_n " \"%s\" failed", c->name);
    }
}