菜鸟nginx源码剖析数据结构篇（九） 内存池ngx_pool_t

这里alignment主要是针对部分unix平台需要动态的对齐，对POSIX 1003.1d提供的posix_memalign( )进行封装，在大多数情况下，编译器和C库透明地帮你处理对齐问题。nginx中通过宏NGX_HAVE_POSIX_MEMALIGN来控制；调用posix_memalign( )成功时会返回size字节的动态内存，并且这块内存的地址是alignment的倍数。参数alignment必须是2的幂，还是void指针的大小的倍数。返回的内存块的地址放在了memptr里面，函数返回值是0.

4.内存池基本操作

• 内存池对外的主要方法有：

4.1 创建内存池ngx_create_pool

ngx_create_pool用于创建一个内存池，我们创建时，传入我们的需要的初始大小：

1: ngx_pool_t *

   3: {

   4:     ngx_pool_t  *p;

   5:     

//以16（NGX_POOL_ALIGNMENT）字节对齐分配size内存

   7:     p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);

if (p == NULL) {

return NULL;

  10:     }

  11:  

//初始状态：last指向ngx_pool_t结构体之后数据取起始位置

sizeof(ngx_pool_t);

//end指向分配的整个size大小的内存的末尾

  15:     p->d.end = (u_char *) p + size;

  16:     

  17:     p->d.next = NULL;

  18:     p->d.failed = 0;

  19:  

sizeof(ngx_pool_t);

//#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)，内存池最大不超过4095，x86中页的大小为4K

  22:     p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;

  23:  

  24:     p->current = p;

  25:     p->chain = NULL;

  26:     p->large = NULL;

  27:     p->cleanup = NULL;

  28:     p->log = log;

  29:  

return p;

  31: }

nginx对内存的管理分为大内存与小内存，当某一个申请的内存大于某一个值时，就需要从大内存中分配空间，否则从小内存中分配空间。

nginx中的内存池是在创建的时候就设定好了大小，在以后分配小块内存的时候，如果内存不够，则是重新创建一块内存串到内存池中，而不是将原有的内存池进行扩张。当要分配大块内存是，则是在内存池外面再分配空间进行管理的，称为大块内存池。

4.2 内存申请 ngx_palloc

1: void *

   3: {

   4:     u_char      *m;

   5:     ngx_pool_t  *p;

   6:  

//如果申请的内存大小小于内存池的max值

if (size <= pool->max) {

   9:  

  10:         p = pool->current;

  11:  

do {

//对内存地址进行对齐处理

  14:             m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);

  15:  

//如果当前内存块够分配内存，则直接分配

if ((size_t) (p->d.end - m) >= size) 

  18:             {

  19:                 p->d.last = m + size;

  20:  

return m;

  22:             }

  23:             

//如果当前内存块有效容量不够分配，则移动到下一个内存块进行分配

  25:             p = p->d.next;

  26:  

while (p);

  28:  

//当前所有内存块都没有空闲了，开辟一块新的内存，如下2详细解释

return ngx_palloc_block(pool, size);

  31:     }

  32:  

//分配大块内存

return ngx_palloc_large(pool, size);

   1: #define ngx_align_ptr(p, a)                                                   \

   2:      (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))

2、开辟一个新的内存块 ngx_palloc_block(ngx_pool_t *pool, size_t size)

这个函数是用来分配新的内存块，为pool内存池开辟一个新的内存块，并申请使用size大小的内存；

1: static void *

   3: {

   4:     u_char      *m;

   5:     size_t       psize;

new;

   7:  

//计算内存池第一个内存块的大小

   9:     psize = (size_t) (pool->d.end - (u_char *) pool);

  10:  

//分配和第一个内存块同样大小的内存块

  12:     m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);

if (m == NULL) {

return NULL;

  15:     }

  16:  

new = (ngx_pool_t *) m;

  18:  

//设置新内存块的end

new->d.end = m + psize;

new->d.next = NULL;

new->d.failed = 0;

  23:  

//将指针m移动到d后面的一个位置，作为起始位置

sizeof(ngx_pool_data_t);

//对m指针按4字节对齐处理

  27:     m = ngx_align_ptr(m, NGX_ALIGNMENT);

//设置新内存块的last，即申请使用size大小的内存

new->d.last = m + size;

  30:  

//这里的循环用来找最后一个链表节点，这里failed用来控制循环的长度，如果分配失败次数达到5次，就忽略，不需要每次都从头找起

for (p = pool->current; p->d.next; p = p->d.next) {

if (p->d.failed++ > 4) {

  34:             pool->current = p->d.next;

  35:         }

  36:     }

  37:  

new;

  39:  

return m;

void *

   3: {

void              *p;

   5:     ngx_uint_t         n;

   6:     ngx_pool_large_t  *large;

   7:  

// 直接在系统堆中分配一块大小为size的空间

   9:     p = ngx_alloc(size, pool->log);

if (p == NULL) {

return NULL;

  12:     }

  13:  

  14:     n = 0;

  15:  

// 查找到一个空的large区，如果有，则将刚才分配的空间交由它管理  

for (large = pool->large; large; large = large->next) {

if (large->alloc == NULL) {

  19:             large->alloc = p;

return p;

  21:         }

//为了提高效率， 如果在三次内没有找到空的large结构体，则创建一个

if (n++ > 3) {

break;

  25:         }

  26:     }

  27:  

  28:  

sizeof(ngx_pool_large_t));

if (large == NULL) {

  31:         ngx_free(p);

return NULL;

  33:     }

  34:     

//将large链接到内存池

  36:     large->alloc = p;

  37:     large->next = pool->large;

  38:     pool->large = large;

  39:  

return p;

• 4.3 内存池重置 ngx_reset_pool

1: void

   3: {

   4:     ngx_pool_t        *p;

   5:     ngx_pool_large_t  *l;

   6:     

//释放大块内存

for (l = pool->large; l; l = l->next) {

if (l->alloc) {

  10:             ngx_free(l->alloc);

  11:         }

  12:     }

  13:     

// 重置所有小块内存区

for (p = pool; p; p = p->d.next) {

sizeof(ngx_pool_t);

  17:         p->d.failed = 0;

  18:     }

  19:  

  20:     pool->current = pool;

  21:     pool->chain = NULL;

  22:     pool->large = NULL;

  23: }

4.4 内存池释放 ngx_pfree

   3: {

   4:     ngx_pool_large_t  *l;

   5:  

//只检查是否是大内存块，如果是大内存块则释放

for (l = pool->large; l; l = l->next) {

if (p == l->alloc) {

   9:             ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,

"free: %p", l->alloc);

  11:             ngx_free(l->alloc);

  12:             l->alloc = NULL;

  13:  

return NGX_OK;

  15:         }

  16:     }

  17:  

return NGX_DECLINED;

struct ngx_pool_cleanup_s  ngx_pool_cleanup_t;

   2:  

   4:     ngx_pool_cleanup_pt   handler;

void                 *data;

   6:     ngx_pool_cleanup_t   *next;

   7: };

其中

• handler：是回调函数指针；
• data：回调时，将此数据传入回调函数；

next：//指向下一个回调函数结构体；

如果我们需要添加自己的回调函数，则需要调用ngx_pool_cleanup_add来得到一个ngx_pool_cleanup_t，然后设置handler为我们的清理函数，并设置data为我们要清理的数据。这样在ngx_destroy_pool中会循环调用handler清理数据；

   3: {

   4:     ngx_pool_cleanup_t  *c;

   5:     

//分配ngx_pool_cleanup_t

sizeof(ngx_pool_cleanup_t));

if (c == NULL) {

return NULL;

  10:     }

  11:  

//给data分配内存

if (size) {

  14:         c->data = ngx_palloc(p, size);

if (c->data == NULL) {

return NULL;

  17:         }

  18:  

else {

  20:         c->data = NULL;

  21:     }

  22:  

//将回掉函数链入内存池

  24:     c->handler = NULL;

  25:     c->next = p->cleanup;

  26:  

  27:     p->cleanup = c;

  28:  

"add cleanup: %p", c);

  30:  

return c;

4.6 内存池销毁 ngx_destroy_pool

   3: {

   4:     ngx_pool_t          *p, *n;

   5:     ngx_pool_large_t    *l;

   6:     ngx_pool_cleanup_t  *c;

   7:  

//依次调用外部析构回调函数

for (c = pool->cleanup; c; c = c->next) {

if (c->handler) {

  11:             ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,

"run cleanup: %p", c);

  13:             c->handler(c->data);

  14:         }

  15:     }

  16:     

//释放大块内存

for (l = pool->large; l; l = l->next) {

  19:  

"free: %p", l->alloc);

  21:  

if (l->alloc) {

  23:             ngx_free(l->alloc);

  24:         }

  25:     }

//释放小块内存

for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {

  28:         ngx_free(p);

  29:  

if (n == NULL) {

break;

  32:         }

  33:     }