Nginx学习(20)—内存池创建

内存池创建

对于内存池的结构，我们可以暂且将其分为头部以及数据域两部分，代码如下：

 struct ngx_pool_s {
     ngx_pool_data_t       d;        // 数据域部分，小块内存在此分配
     size_t                max;      // 整个数据块的大小，亦即能够分配的小块内存最大值
     ngx_pool_t           *current;  // 指向当前内存池
     ngx_chain_t          *chain;    // 可以挂载一个chain结构
     ngx_pool_large_t     *large;    // 当分配的内存超过max值时，即分配大块内存时，使用该成员，属于数据域部分
     ngx_pool_cleanup_t   *cleanup;  // 当内存池释放的时候，同时需要释放的一些资源使用该成员
     ngx_log_t            *log;      // 日志
 };

 typedef struct {
     u_char               *last;     // 当前内存分配结束位置，亦即下一段内存分配开始位置
     u_char               *end;      // 内存池结束位置
     ngx_pool_t           *next;     // 链接下一个内存池
     ngx_uint_t            failed;   // 该数据域部分不能满足分配内存的次数
 } ngx_pool_data_t;

内存池创建的代码如下：

 ngx_pool_t *
 ngx_create_pool(size_t size, ngx_log_t *log)
 {
     ngx_pool_t  *p;

     /* 创建数据域大小为size的内存池，地址以NGX_POOL_ALIGNMENT对齐，这里是16位 */
     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;

     p->current = p;
     p->chain = NULL;
     p->large = NULL;
     p->cleanup = NULL;
     p->log = log;

     return p;
 }

按照上面的描述，可以简单用图示意下：

内存池分配

nginx提供给用户使用的内存分配接口有：

 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_palloc和ngx_pnalloc都是从内存池里分配size大小内存，至于分得的是小块内存还是大块内存，将取决于size的大小；他们的不同之处在于，palloc取得的内存是对齐的，pnalloc则否。ngx_pcalloc是直接调用palloc分配好内存，然后进行一次初始化操作。ngx_pmemalign将在分配size大小的内存并按alignment对齐，然后挂到large字段下，当做大块内存处理。

以ngx_palloc为例详细说明下：

 void *
 ngx_palloc(ngx_pool_t *pool, size_t size)
 {
     u_char      *m;
     ngx_pool_t  *p;

     /* 申请分配小内存块 */
     if (size <= pool->max) {

         p = pool->current;

         do {
             /* 内存对齐宏，下面有注释 */
             m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);

             /* 如果小内存块的数据域大于申请内存的size大小，就直接分配；
              * 否则，通过next指针寻找下一个内存池，直到找到能够分配size大小内存的内存池为止
              */
             if ((size_t) (p->d.end - m) >= size) {
                 p->d.last = m + size;

                 return m;
             }

             p = p->d.next;

         } while (p);

         /* 如果不存在能够分配size大小的内存池，则申请一个新的内存池，并分配。
          * failed字段在该函数里增加，一个内存池当failed字段大于4之后就将current字段指向
          * 下一个内存池，亦即当failed字段大于4之后意味着该内存池已经分配完毕。至于为什么大小
          * 是4，可能就像网站说的，是基于统计或者测试的经验吧。。
          */
         return ngx_palloc_block(pool, size);
     }

     /* 申请分配大的内存块 */
     return ngx_palloc_large(pool, size);
 }

关于内存对齐使用的 宏注释：

 #define ngx_align(d, a)     (((d) + (a - 1)) & ~(a - 1))
 #define ngx_align_ptr(p, a)                                                   \
     (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))

以ngx_align(d, a)为例，这里a是2的幂的数，如2，4，8...
以a=8为例，用二进制表示就是a = 0x1000；(a-1) = 0x00...00111，再取反后为 0x11...11000；
当d=0~8时，0 =< d+(a-1) <= 15，该数与[~(a-1)]按位与，取高位，结果为0x1000，十进制为8；
当d=9~16时，0 =< d+(a-1) <= 23，该数与[~(a-1)]按位与，取高位，结果为0x10000，十进制为16；
当d=17~24时，0 =< d+(a-1) <= 31，该数与[~(a-1)]按位与，取高位，结果为0x11000，十进制为24；
......

亦即，最后取值均为8的倍数，完成对齐的功能。
推而广之，一个数加上(a-1)后与a(2的幂)进行(a减一后取反再按位与)的操作，所得值即为这个数向上取a的整倍数。

具体的内存池分配示意图：

内存池重置

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

     pool->large = NULL;

     /* 只是将last指针指向可共分配的内存的初始位置。
      * 这样，就省去了内存池的释放和重新分配操作，而达到重置内存池的目的
      */
     for (p = pool; p; p = p->d.next) {
         p->d.last = (u_char *) p + sizeof(ngx_pool_t);
     }
 }

内存池释放

 void
 ngx_destroy_pool(ngx_pool_t *pool)
 {
     ngx_pool_t          *p, *n;
     ngx_pool_large_t    *l;
     ngx_pool_cleanup_t  *c;

     /* 先释放cleanup上挂载的数据资源，调用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);
         }
     }

     /* 然后释放大内存块 */
     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);
         }
     }

     /* 最后完成内存池的释放 */
     for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
         ngx_free(p);

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

总结

Nginx内存的设计初探很精妙，然后学习进去发现逻辑很清晰。这种设计思想要有印象，以后遇到类似内存的设计问题可以提供备选思路。