typedef struct {

u_char *last; // 当前内存池分配到此处，即下一次分配从此处开始

u_char *end; // 内存池结束位置

ngx_pool_t *next; // 内存池里面有很多块内存，这些内存块就是通过该指针连成链表的

ngx_uint_t failed; // 内存池分配失败次数

} ngx_pool_data_t;

struct ngx_pool_s {

ngx_pool_data_t d; // 指向内存池的第一个数据块

size_t max; // 内存池数据块的最大值(数目)

ngx_pool_t *current; // 指向当前内存池

ngx_chain_t *chain; // 该指针挂接一个ngx_chain_t结构

ngx_pool_large_t *large; // 大块内存链表，即分配空间超过max的内存

ngx_pool_cleanup_t *cleanup; // 释放内存池的callback

ngx_log_t *log; // 主要用于记录日志信息

};

struct ngx_pool_large_s {

ngx_pool_large_t *next; // 指向下一个large内存

void *alloc; // 指向分配的large内存

};

struct ngx_pool_cleanup_s {

ngx_pool_cleanup_pt handler; // 指向用于cleanup本cleanup内存

void *data; // 指向分配的cleanup内存

ngx_pool_cleanup_t *next; // 指向下一个cleanup内存

};

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;

}

// 可以看到 last 指向 pool 之后的位置，即下一个pool块分配的位置

p->d.last = (u_char *) p + sizeof(ngx_pool_t);

// end 指向pool的size的最后，即当前pool可容纳的最大尺寸的结束位置

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;

}

/*

* 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)

ngx_int_t

ngx_os_init(ngx_log_t *log)

{

ngx_uint_t n;

#if (NGX_HAVE_OS_SPECIFIC_INIT)

if (ngx_os_specific_init(log) != NGX_OK) {

return NGX_ERROR;

}

#endif

ngx_init_setproctitle(log);

ngx_pagesize = getpagesize();

ngx_cacheline_size = NGX_CPU_CACHE_LINE;

for (n = ngx_pagesize; n >>= 1; ngx_pagesize_shift++) { /* void */ }

… …

}

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)

… …

#endif

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

ngx_free(p);

if (n == NULL) {

break;

}

}

}

void

ngx_reset_pool(ngx_pool_t *pool)

{

ngx_pool_t *p;

ngx_pool_large_t *l;

// 先遍历large链表，释放large内存

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

if (l->alloc) {

ngx_free(l->alloc);

}

}

pool->large = NULL;

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

p->d.last = (u_char *) p + sizeof(ngx_pool_t);

}

}

void *

ngx_palloc(ngx_pool_t *pool, size_t size)

{

u_char *m;

ngx_pool_t *p;

if (size <= pool->max) { // 如果需要分配的size大于max，则使用palloc_large来分配

p = pool->current; // 小于max，则从current开始遍历pool链表

do {

// 每次从last处开始分配aligned内存

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

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

// 如果分配的内存够用，则就从此处分配，并调整last

p->d.last = m + size;

return m;

}

p = p->d.next;

} while (p);

// 表示链表里没有能够分配size大小的内存节点

// 则生成一个新的节点，并在其中分配内存

return ngx_palloc_block(pool, size);

}

// 大于max的，就在large中进行分配

return ngx_palloc_large(pool, size);

}