nginx 内存池

目录

• 简述
• 几种数据结构
• 对外的方法
• 总结

参考

https://www.cnblogs.com/xiekeli/archive/2012/10/17/2727432.html?tdsourcetag=s_pctim_aiomsg

源码版本 nginx-1.12.2

简述

nginx 是一个http ， 反向代理等的服务器，以其高效，稳定，低内存闻名。最具特点的是它不是以线程方式处理请求，而是采用了一种事件驱动异步架构的方式。这也就要求

整个内存池可以看作是由一个个内存块组成的链表。

几种数据结构

对外的方法

ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log);//创建内存池
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);//内存申请，并初始化为0
ngx_int_t  ngx_pfree(ngx_pool_t *pool, void *p);//释放内存  
void ngx_reset_pool(ngx_pool_t *pool);//重置内存池
void ngx_destroy_pool(ngx_pool_t *pool);//销毁内存池

ngx_pool_cleanup_t *ngx_pool_cleanup_add(ngx_pool_t *p, size_t size);//添加外部资源管理
void ngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd);//清理外部资源中管理的文件
void ngx_pool_cleanup_file(void *data);//清理文件
void ngx_pool_delete_file(void *data);//删除文件

需要额外了解的结构，也可等看后文时遇到再回来翻阅

#define ngx_memalign(alignment, size, log)  ngx_alloc(size, log)
void *ngx_alloc(size_t size, ngx_log_t *log){
    void  *p;
    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_memalign 实际上可以看作对malloc的封装并处理了内存对齐的问题。

#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)
//页大小减一，4096-1

#define ngx_align_ptr(p, a)                                                   \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))
//用来对内存地址取整的宏相当于手动对指针进行内存对齐、

#define ngx_memzero(buf, n)       (void) memset(buf, 0, n)
#define ngx_free          free
#define ngx_close_file           close
#define ngx_delete_file(name)    unlink((const char *) name)

创建内存池

ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log) //size代表要分配的内存节的大小
{
    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;  
    //大小内存的判定标准如果<=max则算是分配小内存，最大不能超过 4095

    p->current = p;//分配小内存时开始搜索的节点
    p->chain = NULL;
    p->large = NULL;
    p->cleanup = NULL;
    p->log = log;
    
    return p;
}

上面这个代码相当于创建内存池，并且定义了内存池的大小。

分配内存

//分配内存，对齐
void * ngx_palloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
    if (size <= pool->max) {
        return ngx_palloc_small(pool, size, 1);
    }
#endif

    return ngx_palloc_large(pool, size);
}

//分配内存，不对齐
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);
    }
#endif

    return ngx_palloc_large(pool, size);
}

//分配内存，不对齐，并初始化为0
void * ngx_pcalloc(ngx_pool_t *pool, size_t size)
{
    void *p;

    p = ngx_palloc(pool, size);
    if (p) {
        ngx_memzero(p, size);
    }

    return p;
}

按照是否进行内存对齐，是否初始化为0的方式分配内存。

分配小内存

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; //从current节点开始搜索

    do {
        m = p->d.last;

        if (align) {    //如果设置对齐，则进行将指针进行对齐
            m = ngx_align_ptr(m, 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);
}

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); 
    //内存节总的大小，也即第一次创建内存传入的大小

    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;     
    
    //更新一下分配小内存的查找的起点，
    //既然能新分配内存节，说明之前的内存节大小可能都占满了，如果哪个节点失败次数多的话就会在下一次查找时被跳过
    for (p = pool->current; p->d.next; p = p->d.next) { 
        if (p->d.failed++ > 4) {
            pool->current = p->d.next;
        }
    }

    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;

    p = ngx_alloc(size, pool->log); 
    if (p == NULL) {
        return NULL;
    }

    n = 0;
    //哪个大内存结构管理的内存为空，只多检查5个。
    for (large = pool->large; large; large = large->next) {
        if (large->alloc == NULL) {
            large->alloc = p;
            return p;
        }

        if (n++ > 3) {
            break;
        }
    }
    //分配新的大内存管理结构
    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;
}

分配后可能会出现这种情形

释放内存

ngx_int_t
ngx_pfree(ngx_pool_t *pool, void *p)
{
    ngx_pool_large_t  *l;

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

检测是否大内存，是的话就释放，否则不做操作。

重置内存池

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;
    }
    //这块有点问题，因为按照它这个方法处理后，除了第一个内存块可用空间是正常的，
    //其它的内存块第一次分配 和 重置后 可用空间不同，
    //应该除了内存块头节点，其它都为 p->d.last = (u_char *) p + sizeof(ngx_pool_data_t);

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

也就是说，假如内存池为空和重置后可用空间不同。

外部资源管理

主要用来保存外部资源信息。可以将文件托管到这个结构，也可以将外部资源和相应的资源处理函数托管到这个结构。nginx 提供的几种函数是专门处理文件的，而外部资源则需要用户处理。

添加一个外部资源管理结构

ngx_pool_cleanup_t *
ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
    ngx_pool_cleanup_t  *c;

    c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
    if (c == NULL) {
        return NULL;
    }
    //如果没有传入大小，则只添加一个头部
    if (size) {
        c->data = ngx_palloc(p, size);
        if (c->data == NULL) {
            return NULL;
        }

    } else {
        c->data = NULL;
    }

    c->handler = NULL;
    
    c->next = p->cleanup;//头插
    p->cleanup = c;

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

    return c;
}

清理文件

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

关闭文件。

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;

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

关闭外部资源管理器中管理的文件。

删除文件

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

先断开与文件的连接，再关闭。

总结

最后的操作可能会出现这个亚子的图。

来源：https://www.cnblogs.com/starrys/p/12200067.html