参考
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);
}
}
先断开与文件的连接，再关闭。
总结
最后的操作可能会出现这个亚子的图。
