nginx源码学习 内存池

1、内存池：

（1）宏定义：

//说明：每次最多可以从内存池申请的空间大小，ngx_pagesize代表操作系统内存页大小，x86中是4096字节为一页，所以这里是4095

#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)

//默认内存池大小

#define NGX_DEFAULT_POOL_SIZE    (16 * 1024)

//默认内存池字节对齐

#define NGX_POOL_ALIGNMENT       16

//最小内存池大小，1个ngx_pool_t+2个ngx_pool_large_t+内存对齐

#define NGX_MIN_POOL_SIZE                                                     \

    ngx_align((sizeof(ngx_pool_t) + 2 * sizeof(ngx_pool_large_t)),            \

              NGX_POOL_ALIGNMENT)

（2）结构体定义：

typedef struct ngx_pool_cleanup_s  ngx_pool_cleanup_t;

struct ngx_pool_cleanup_s {//文件缓冲

    ngx_pool_cleanup_pt   handler;//释放内存的回调，
//原型为typedef void (*ngx_pool_cleanup_pt)(void *data);

    void                 *data;//实际是ngx_pool_cleanup_file_t

    ngx_pool_cleanup_t   *next;//链表的下一个结点

};

typedef struct ngx_pool_large_s  ngx_pool_large_t;

struct ngx_pool_large_s {//大块内存链表

    ngx_pool_large_t     *next;//下一个结点

    void                 *alloc;//已分配内存块地址

};

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

    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;//日志

};

typedef struct {

    ngx_fd_t              fd;//文件描述符

    u_char               *name;//文件名

    ngx_log_t            *log;//日志

} ngx_pool_cleanup_file_t;

（3）函数：

1）ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log);

根据size创建内存池，初始化内存池结构，设置d.last为(u_char *) p + sizeof(ngx_pool_t)位置，即申请的内存块偏移该ngx_pool_t结构体后都是本块内存的数据区

2）void ngx_destroy_pool(ngx_pool_t *pool);

释放内存池，迭代释放cleanup中的所有结点，large中所有结点

3）void ngx_reset_pool(ngx_pool_t *pool);

重置内存池，释放large系列结点，，重置d.last为初始位置，d.failed为0，重置current为本结点，chain、large为null。

4）void *ngx_palloc(ngx_pool_t *pool, size_t size);

申请内存块，如果size小于内存块最大值（一页内存），则调用ngx_palloc_small，并设定内存对齐，否则调用ngx_palloc_large。做内存对齐。

5）void *ngx_pnalloc(ngx_pool_t *pool, size_t size);

同上，但是不做内存对齐

6）void *ngx_palloc_small(ngx_pool_t *pool, size_t size);

先取当前内存块使用位置d.last，并把该位置内存对齐后给临时变量m（对齐后可能m>d.last），如果d.end-m >=size，说明本块内存剩余空间足够分配，则d.last=m+size，返回m指针为分配空间的起始地址。

如果遍历完内存块都未分配到内存，则调用ngx_palloc_block创建size大小的新内存块

7）static void *ngx_palloc_block(ngx_pool_t *pool, size_t size)；

psize = (size_t) (pool->d.end - (u_char *) pool);//计算每块内存的实际大小，这个值应该<=max

申请psize大小的内存块，初始化内存块的d结构，这里有一个问题：在ngx_create_pool的时候，d.last += sizeof(ngx_pool_t)，但是在这里d.last+=sizeof(ngx_pool_data_t)。这是因为ngx_create_pool返回的是内存池头结点，内部包含缓冲池其他链表指针，而ngx_palloc_block创建的是一个内存块，被添加到d链表的末尾，这块内存内部只需要包含内存块指针即可。然后从当前结点开始遍历内存池的内存块链表（d链表），找到d链表最后一个结点，把新内存块加到该结点后。

从这里可以看到failed的作用：执行到这里，说明current结点及其后面的结点已经连续4次分配内存失败，说明他们的空间不足，所以后移current结点，知道d.failed<=4的结点为止。

8）static void *ngx_palloc_large(ngx_pool_t *pool, size_t size)；

large结点本身空间是通过ngx_palloc_small开辟的，它的alloc指向了实际的数据空间（大小为size）。内存池在释放large数据空间时，并不删除large结点，而是free(alloc),alloc=null。如果在前四个large结点中找不alloc=null的结点，则新建一个large结点。

9）void *ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment);

带内存对齐的large内存块申请，申请后直接添加到large链表

10）ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p);

释放large结点中的数据块，但不删除large结点。由此可见，按页分配的内存是循环使用的，大于页的内存是一次性的。

11）void *ngx_pcalloc(ngx_pool_t *pool, size_t size)；

内部调用ngx_palloc，但是多了初始化内存为0的过程

12）文件相关的内存操作

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

从上面的函数可以看出，内存块是没有直接释放接口的（即把last往回推），这个过程是在外部进行的，比如nginx的array，底层就是一个内存池，当数组中一个元素不使用时（需要释放），由array负责直接把last推回，源码：

void ngx_array_destroy(ngx_array_t *a)

{

    ......

    if ((u_char *) a->elts + a->size * a->nalloc == p->d.last) {

        p->d.last -= a->size * a->nalloc;

    }

   ......

}