6.nginx源码分析之数据结构：ngx_pool_t

末蓝、 2022-07-15 00:44 148阅读 0赞

## nginx内存管理 ##

--------------------

### nginx内存管理的结构体 ###

关于nginx内存管理的方法在ngx\_palloc.h文件中，定义了相关结构体和接口：

如下几个宏定义了内存池的默认大小和对齐大小。

/* * NGX_MAX_ALLOC_FROM_POOL should be (ngx_pagesize - 1), i.e. 4095 on x86. * On Windows NT it decreases a number of locked pages in a kernel. */
    #define NGX_MAX_ALLOC_FROM_POOL (ngx_pagesize - 1)
    
    //默认大小是1024个16B
    #define NGX_DEFAULT_POOL_SIZE (16 * 1024)
    
    #define NGX_POOL_ALIGNMENT 16
    #define NGX_MIN_POOL_SIZE \
        ngx_align((sizeof(ngx_pool_t) + 2 * sizeof(ngx_pool_large_t)),            \
                  NGX_POOL_ALIGNMENT)

定义了nginx的FREE函数指针，ngx\_pool\_cleanup\_pt为一个函数指针，他可以指向用户希望采用的释放函数。

--------------------

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

**handler** 记录着资源的释放策略；  
**data**是实际所指向的资源的地址；  
**next**就是链表的下一个节点位置；

因为nginx的内存释放是在最后进行的，所以需要记录下每个资源的释放规则（由handler记录着函数地址）。

typedef struct ngx_pool_large_s  ngx_pool_large_t;
    
    struct ngx_pool_large_s {
        ngx_pool_large_t     *next;    //指向下一个pool
        void                 *alloc;    //指向分配的内存
    };

typedef struct {
        u_char               *last;      //内存池下一次分配的起始位置
        u_char               *end;       //内存池结束位置
        ngx_pool_t           *next;      //内存池里面有很多块内存，这些内存块就是通过该指针连成链表的
        ngx_uint_t            failed;    //内存分配失败次数
    } ngx_pool_data_t;   //内存池数据块信息

内存池的控制信息如下，上述内存池数据块ngx\_pool\_data\_t信息是当前这个内存池的描述信息，所以其实是ngx\_pool\_s的一部分，作为控制信息我们把它放在了ngx\_pool\_s的开始位置。

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

**d** 是当前内存块的控制信息；  
**max** 是小块内存申请的最大值，如果比这个大就算是大块内存；  
**current** 当前内存池本身的地址  
**chain** 指向了一个chain结构  
**large** 指向一个大块内存的地址（大小大鱼max的内存，nginx使用标准库malloc进行申请）  
**cleanup** 指向nginx释放结构体的指针  
**log** 指向日志结构体

各个结构体的关系如下图所示（该图由JULY绘制，借鉴过来）：  
![这里写图片描述][20161028103253995]

--------------------

### nginx内存管理的接口 ###

上述是内存管理的结构体定义，在C编程中，一旦结构体定义OK，剩下的接口实现基本都是围绕着结构体展开的。nginx向我们介绍了如下几个接口定义：

//nginx的内存申请
    void *ngx_alloc(size_t size, ngx_log_t *log);
    void *ngx_calloc(size_t size, ngx_log_t *log);
    
    //nginx创建内存池，销毁内存池，重置内存池
    ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log);
    void ngx_destroy_pool(ngx_pool_t *pool);
    void ngx_reset_pool(ngx_pool_t *pool);
    
    //在内存池进行资源的申请和释放
    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);
    void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment);
    ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);
    
    
    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);

下面我们对这些接口进行逐个分析，接口的实现在ngx\_palloc.c文件中：

--------------------

**ngx\_alloc**

void * ngx_alloc(size_t size, ngx_log_t *log)
    {
        void  *p;
    
        p = malloc(size);   //ngx_alloc申请内存只是对malloc的封装
        //不管是申请成功还是失败都会写入日志
        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\_calloc**

void * ngx_calloc(size_t size, ngx_log_t *log)
    {   
        void  *p;
    
        p = ngx_alloc(size, log);
    
        if (p) {
            ngx_memzero(p, size);    //将ngx_alloc申请的内存全部清空
        }
    
        return p;
    }

--------------------

**ngx\_create\_pool 创建ngx内存池操作**

ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log)
    {       
        ngx_pool_t  *p;    //创建nginx内存池的控制结构
    
        p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
    
        if (p == NULL) {
            return NULL;
        }              
    
        //对nginx控制结构的值进行初始化
        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);    //可申请的内存大小要去除控制信息（ngx_pool_t）
        p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;   //判定大内存的大小
    
        p->current = p;    //当前内存块的地址指向p本身
        p->chain = NULL;     //链表指针地址
        p->large = NULL;      //刚开始还没有大内存申请，所以指针为NULL
        p->cleanup = NULL;     //清空模块的指针为空
        p->log = log;         //日志结构体指针进行初始化
    
        return p; 
    }

内存池的初始化没有采用malloc直接申请，而是使用了ngx\_memalign函数，ngx\_memalign的实现如下：

void * ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)
    {
        void  *p;
        int    err;
    
        err = posix_memalign(&p, alignment, size);
    
        if (err) {
            ngx_log_error(NGX_LOG_EMERG, log, err,
                          "posix_memalign(%uz, %uz) failed", alignment, size);
            p = NULL;
        }
    
        ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,
                       "posix_memalign: %p:%uz @%uz", p, size, alignment);
    
        return p;
    }

这个函数中真正起申请作用的是posix\_memalign，posix\_memalign的接口定义如下：

int posix_memalign (void **memptr,    //内存申请指针的地址
                        size_t alignment,    //申请的内存是alignment的倍数，alignment的2的幂，这样设计是为了方便操作
                        size_t size);    //size是我们申请的内存的大小

ngx\_create\_pool 调用最终会得到一个内存池的控制信息以及对其成员的初始化：

--------------------

**ngx\_destroy\_pool内存池的销毁操作**

代码实现如下：

void
    ngx_destroy_pool(ngx_pool_t *pool)
    {
        ngx_pool_t          *p, *n;
        ngx_pool_large_t    *l;
        ngx_pool_cleanup_t  *c;
    
        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);
            }
        }
    
        for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
            ngx_free(p);
    
            if (n == NULL) {
                break;
            }
        }
    }

在C语言中，因为没有类的概念，也就不存在类的销毁，所以资源的释放顺序一定要严格的把控。以ngx\_pool\_t为例，它其中包含了ngx\_pool\_large\_t和ngx\_pool\_cleanup\_t这些结构体指针，释放顺序如下：  
（1）首先在清楚链表中使用用户指定的方式( handler  
所指向的函数)释放节点的data数据。

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

（2）接着释放大块内存链表,其中的ngx\_free就是标准库中的free函数封装：

for (l = pool->large; l; l = l->next) {
            if (l->alloc) {
                ngx_free(l->alloc);
            }
        }

（3）最后我们释放nginx的内存池链表，这里采用的是双指针联动方式，让p指向当前内存池地址，而n指向下一个内存池，先释放当前的内存池，再判断下一个内存池是否存在，如果不存在则循环结束：

for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
            ngx_free(p);
    
            if (n == NULL) {
                break;
            }
        }

--------------------

**ngx\_reset\_pool 重置内存池**

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;
        }
    
        pool->current = pool;
        pool->chain = NULL;
        pool->large = NULL;
    }

这个流程和销毁内存池操作有着相同的部分，先清空大内存池的链表，之前的那个cleanup链表的销毁操作可以不进行，反正在内存池执行销毁的时候也会执行，然后把last指针指向控制信息的下一个字节地址。

--------------------

**ngx\_palloc内存池申请内存**

这里对申请的内存大小做判断，选择大内存申请或者小内存申请方式，注意这里申请的内存大小是经过对齐的，而ngx\_pnalloc申请的内存大小是没有对齐的。

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

这里主要关注两个函数ngx\_palloc\_small和ngx\_palloc\_large。

**ngx\_palloc\_small**

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

在整个内存池链表中找到能够申请size大小的内存，把申请的起始地址返回，该内存池的可用内存大小减少size。如果遍历完当前的内存池链表都无法满足当前size大小的内存申请。则调用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;
    }

该函数的作用就是申请了一个新的内存池（pool），首先计算了内存池的大小，然后进行申请，如果成功的话把地址返回给new指针，用new对内存池的结构体成员进行初始化，m是我们最后申请的内存块的首地址，但是现在需要把new这个新的内存池插入到其他的内存池的链表末尾。

**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;
    
        //大块内存的申请采用malloc直接申请
        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;
            }
    
            if (n++ > 3) {
                break;
            }
        }
    
        large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
        if (large == NULL) {
            ngx_free(p);
            return NULL;
        }
    
        //把这个p所指向的大块内存的管理节点尾部添加到大块内存链表指针里
        large->alloc = p;
        large->next = pool->large;
        pool->large = large;
    
        return p;
    }

--------------------

**ngx\_pnalloc不进行对其的内存池申请**

该方法的实现和ngx\_palloc类似

--------------------

**ngx\_pcalloc对内存池申请的内存初始化为0**

void * ngx_pcalloc(ngx_pool_t *pool, size_t size)
    {
        void *p;
    
        p = ngx_palloc(pool, size);
        if (p) {
        //初始化申请的内存为0
            ngx_memzero(p, size);
        }
    
        return p;
    }

**ngx\_pfree 内存池释放大块内存的方法**

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

--------------------

**ngx\_pool\_run\_cleanup\_file清空文件描述符fd**

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

## 小结 ##

关于nginx的内存池管理如上所示，需要边看代码边进行画图才能加深理解，管理思路比较直接，不像c++的stl那样分配了多个自由链表。希望大家可以好好思考。

[20161028103253995]: /images/20220715/3998413266044f85876f7bac7a683f98.png