Nginx内存管理

目录

1. ngx_pool_s结构体定义

本节所有结构体定义都包含在: /nginx/src/core/ngx_palloc.h

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; //指向日志配置结构
};

1.1 ngx_pool_data_t结构体

typedef struct{
    u_char  *last;   //保存内存池中内存分配指针的当前位置
    u_char  *end;    //保存内存池的结束位置，也就是链表的末端
    ngx_pool_t  *next;  //指向下一个节点
    ngx_uint_t  failed;  //内存池分配失败的次数
}ngx_pool_data_t;

1.2 ngx_pool_large_s结构体

struct ngx_pool_large_s{
    ngx_pool_large_t  *next;
    void *alloc;   //所需存储的数据类型可以自定义
};

当申请所需的空间大小大于ngx_pool_s中的最大值max时，就需要申请*large指针所指的大体积内存。

1.3 ngx_pool_cleanup_s结构体

struct ngx_pool_cleanup_s{
    ngx_pool_cleanup_pt  handler;
    void  *data;   //需要被清除的数据
    ngx_pool_cleanup_t  *next;  //指向下一个将要被清除的数据
};

handler是一个内存数据清理函数指针：
typedef void (*ngx_pool_cleanup_pt) (void *data);

2. 内存池的逻辑结构

Nginx内存池本质上是一个链表结构。链表的每一个节点成为一个数据块，由ngx_pool_data_t结构体描述。

3. 内存池的管理

3.1 创建内存池

内存池的创建，主要由ngx_create_pool()函数实现，直接看源码：

//ngx_create_pool
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;
    //size为实际能够用于存储数据的内存大小
    size = size - sizeof(ngx_pool_t);  
    /*#define NGX_MAX_ALLOC_FROM_POOL (ngx_pagesize-1)
    *ngx_pagesize存放的是当前系统平台一页内存页的大小
    *也就是说，申请的内存空间不能超过一页内存页的大小
    */
    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_memalign()函数进行内存对齐。linux平台有多个系统调用用于分配内存：
- 不考虑数据对齐：malloc()
- 考虑数据对齐： memalign()，posix_memalign()

如果定义了NGX_HAVE_POSIX_MEMALIGN，则调用posix_memalign():

if (NGX_HAVE_POSIX_MEMALIGN)
void *
ngx_memalgin(size_t alignment, size_t size, ngx_log_t *log){
    void *p;
    int err;
    err = posix_memalign(&p, alignment, size);
    if(err){
    ...
    }
    ...
    return p;
}

如果定义了NGX_HAVE_MEMALIGN，则调用memalgin():

if (NGX_HAVE_MEMALIGN)
void *
ngx_memalgin(size_t alignment, size_t size, ngx_log_t *log){
    void *p;
    P = memalign(alignment, size);
    if(P == NULL){
    ...
    }
    ...
    return p;
}

alignment 变量的值来源于NGX_POX_ALIGNMENT：
#define NGX_POX_ALIGNMENT 16
这种情况下，分配的内存就是以16字节为边界对齐的。

如果没有定义内存对齐，则调用malloc():

void *
ngx_alloc(size_t size, ngx_log_t *log){
    void *p;
    p = malloc(size);
    if(p == NULL){
    ...
    }
    return p;
}

3.2 内存池销毁

销毁工作主要由ngx_destory_pool()完成，代码如下：

void
ngx_destory_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);
        }
    }
    //清除大块数据内存 #define ngx_free free
    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);
    }
    //释放内存池本身占用的内存空间
    for(p = pool, n = pool->d.next;;p = n,n = n->d.next){
        ngx_free(p);
        if(n == NULL)
            break;
    }
}

总的来说，内存池释放操作主要工作包括：
- 清除内存池每个节点的数据
- 清理并释放挂接在内存池分配模块上的大数据内存
- 释放内存池本身空间

3.3 重置内存池

将内存池恢复到起始状态，源码：

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);
    }
    pool->large = NULL;
    //将小数据块的结尾指针last，重新指向内存分配模块的实际数据存储单元的起始地址.
    //也就是说，已经分配的内存实际上没有被释放掉，而是又重头开始参与分配，被新数据覆盖。
    for(p = pool; p; p = p->d.next)
        p->d.last = (u_char*)p + sizeof(ngx_pool_t);
}

3.4 使用内存

3.4.1 申请内存

Nginx申请内存共有三种方式：
- ngx_palloc()
- ngx_pnalloc()
- ngx_calloc()
下面将通过源码分析这三种申请方式，进一步了解内存池的分配过程。

(1) ngx_pcalloc()：

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

。。。。。。