内存池结构 -- ngx_pool_t

2015-03-17 09:09:34   最后更新: 2015-03-18 00:08:25   访问数量:1392




nginx 是通过资源集中管理的方式管理资源的,即打开所有即将要用的资源,以备随时取用,无论是文件还是内存

这样做的好处是避免了每次创建、打开资源造成的性能消耗

因此,便有了内存池模块,用来集中申请内存资源并进行内存资源的管理和分配

 

nginx 内存池的声明和定义分别在 src/core/ngx_palloc.h 和 src/core/ngx_palloc.c 中

 

 

 

如图所示,nginx 内存池是一个巨大的单链表结构,由他的 ngx_pool_data_t 结构域指定了当前内存池节点的终止地址、下一内存池链表节点等信息

nginx 内存池设计的基本原则是:只分配不释放,也就是说,并没有一个用来释放内存池中数据的操作函数,这样做的好处是维护内存池结构的简便性而无需关心内存碎片的产生,同时,他让每次分配工作都在第一个节点的 current 域指向的内存池节点进行,一旦连续4次分配失败,这也就意味着 current 指向的内存池节点剩余空间已经不足,然后便会让 current 指向内存池链表上的下一届点,这样保证了其分配工作的正常进行,而无需每次都遍历整个内存池链表

 

// struct 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; // 内存分配相关的log }; // }}}

 

// struct ngx_pool_data_t // 内存池数据结构 {{{ typedef struct { u_char *last; // 当前内存分配的结束位置 u_char *end; // 内存池的结束位置 ngx_pool_t *next; // 下一内存池 ngx_uint_t failed; // 内存分配失败计数 } ngx_pool_data_t; // }}}

 

typedef struct ngx_pool_large_s ngx_pool_large_t; // struct ngx_pool_large_s // 大块内存结构 {{{ struct ngx_pool_large_s { ngx_pool_large_t *next; void *alloc; }; // }}}

 

// 内存析构函数 typedef void (*ngx_pool_cleanup_pt)(void *data); typedef struct ngx_pool_cleanup_s ngx_pool_cleanup_t; // struct ngx_pool_cleanup_s // 内存清理结构 {{{ struct ngx_pool_cleanup_s { ngx_pool_cleanup_pt handler; // 析构函数 void *data; // 析构函数参数 ngx_pool_cleanup_t *next; // 下一析构函数 }; // }}}

 

// struct ngx_chain_s // 缓存链结构 {{{ struct ngx_chain_s { ngx_buf_t *buf; ngx_chain_t *next; }; // }}}

 

 

图中没有画出 ngx_chain_s 结构,ngx_chain_s 结构用于存储缓存链,我们将在讲解缓存时进行讲解

 

内存池操作函数
说明函数
创建内存池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_alloc(size_t size, ngx_log_t *log);
分配内存并初始化为 0void * ngx_calloc(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_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);

 

// 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; // 对内存分配函数进行封装,不同系统运行不同的函数 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; // ngx_pool_t 40byte 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; } // }}}

 

// void * ngx_memalign(size_t alignment, size_t size, ngx_log_t *log) // 指定内存对齐方式并分配堆内存 {{{ void * ngx_memalign(size_t alignment, size_t size, ngx_log_t *log) { void *p; int err; // 以指定对齐方式分配 size 大小的内存 // size 单位是 byte 而不是 bit 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 函数而不是 malloc 在堆上开辟内存呢?

虽然 malloc 默认也是用对齐的方式开辟内存的,但是我们却无法指定其对齐的大小,posix_memalign 提供了更大的灵活性,我们可以在开辟内存的同时指定以多少位对齐

初始化后,内存池的各个域均获得了其正确的初始值

需要注意的是,max 最大不能超过 NGX_MAX_ALLOC_FROM_POOL(4096)

 

// 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; // 循环调用所有析构函数 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); } } #if (NGX_DEBUG) /* * we could allocate the pool->log from this pool * so we cannot use this log while free()ing the pool */ 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 (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) { ngx_free(p); if (n == NULL) { break; } } } // }}}

 

 

内存池的销毁工作进行了以下三步:

  1. 循环调用所有析构函数
  2. 释放所有大内存结构(ngx_pool_large_s)
  3. 释放内存池链上其他内存池

 

// 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; // 释放所有大内存结构 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; } // }}}

 

重置内存池函数将内存池重新置为未使用状态

 

内存池使用最重要的工作当然就是内存池上内存的分配了

nginx 提供了以下 3 个内存池分配函数:

内存池操作函数
说明函数
内存申请(对齐)void * ngx_palloc(ngx_pool_t *pool, size_t size);
内存申请(不对齐)void * ngx_pnalloc(ngx_pool_t *pool, size_t size);
以指定对齐方式分配内存void * ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment);
// void * ngx_palloc(ngx_pool_t *pool, size_t size) // 在内存池中分配内存 {{{ 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); 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); } return ngx_palloc_large(pool, size); } // }}}

 

// void * ngx_pnalloc(ngx_pool_t *pool, size_t size) // 在内存池中分配内存,不对齐 {{{ void * ngx_pnalloc(ngx_pool_t *pool, size_t size) { u_char *m; ngx_pool_t *p; if (size <= pool->max) { p = pool->current; do { m = p->d.last; 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); } return ngx_palloc_large(pool, size); } // }}}

 

// 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(pool, sizeof(ngx_pool_large_t)); if (large == NULL) { ngx_free(p); return NULL; } large->alloc = p; large->next = pool->large; pool->large = large; return p; } // }}}

 

 

当内存不足时,nginx 会根据待分配内存的大小,执行下面两个函数之一,来扩充内存池

// static void * ngx_palloc_block(ngx_pool_t *pool, size_t 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) // 为大块内存申请分配内存池 {{{ 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; for (large = pool->large; large; large = large->next) { if (large->alloc == NULL) { large->alloc = p; return p; } if (n++ > 3) { break; } } large = ngx_palloc(pool, sizeof(ngx_pool_large_t)); if (large == NULL) { ngx_free(p); return NULL; } large->alloc = p; large->next = pool->large; pool->large = large; return p; } // }}}

 

 

对于小块内存,如果当前内存池已经不足以分配,则会在当前内存池链上创建一个新的内存池,用来分配新的空间申请

对于大于 max 的内存申请,则在整个内存空间中 malloc 一段内存,供其存储,用 ngx_large_t 结构指向他,并将相应的 ngx_large_t 变量存储到内存池中形成大内存结构链表,由内存池结构的 large 域指向链表起始地址

 

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

 

 

这个函数将指定的大块内存释放掉

 

对于内存操作,仅仅使用内存池是无法满足所有需求的,所以同时也需要 malloc 的存在

nginx 提供了两个对 malloc 封装的函数,他们的区别在于是否在内存分配后初始化为 0

// void * ngx_alloc(size_t size, ngx_log_t *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; } // }}}

 

// void * ngx_calloc(size_t size, ngx_log_t *log) // 分配内存池并初始化为 0 {{{ void * ngx_calloc(size_t size, ngx_log_t *log) { void *p; p = ngx_alloc(size, log); if (p) { ngx_memzero(p, size); } return p; } // }}}

 

 






技术帖      操作系统      数据结构      struct      龙潭书斋      内存      memory      structure      malloc      nginx      内存分配      posix_memalign      ngx_pool_data_t      ngx_pool_s     


京ICP备15018585号