浅析nginx中的内存池

Natural 发表于 2020-04-18 15:46:35
编辑于 2020-04-20 11:50:50

## 写在开始之前
第二篇blog,最近打算分析nginx的源码,以后还会更新
## 数据结构
```c
//自清理内存回调函数指针
typedef void (*ngx_pool_cleanup_pt)(void *data);

//自清理内存结构体
typedef struct ngx_pool_cleanup_s  ngx_pool_cleanup_t;
struct ngx_pool_cleanup_s {
    ngx_pool_cleanup_pt   handler;  //清理函数
    void                 *data;     //数据
    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_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;          //logger
};

//自清理文件描述符结构体
typedef struct {
    ngx_fd_t              fd;           //文件描述符
    u_char               *name;         //名字(作用暂不明确)
    ngx_log_t            *log;          //logger
} ngx_pool_cleanup_file_t;
```
## 内存池的创建
```c
//创建内存池
//size: size_t      内存池大小
//log:  ngx_log_t*  指向logger的指针
ngx_pool_t *
ngx_create_pool(size_t size, ngx_log_t *log)
{
    //ngx_pool_t *p = NULL;
    ngx_pool_t  *p;

//分配一块大小为size的内存
    //相当于
    //ngx_alloc(size,log);
    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
    if (p == NULL) {
        return NULL;
    }

//初始化内存池
    //头sizeof(ngx_pool_t)个字节用来维护ngx_pool_t自身的数据
    //先偏移sizeof(ngx_pool_t)字节
    //剩下的内存用来使用
    p->d.last = (u_char *) p + sizeof(ngx_pool_t);
    //d.end指向内存池的边界
    p->d.end = (u_char *) p + size;
    //d.next设置为NULL
    //小内存或内存池的链表
    p->d.next = NULL;
    //失败的次数
    p->d.failed = 0;

//获取真正可用的内存大小
    //即减去sizeof(ngx_pool_t)
    size = size - sizeof(ngx_pool_t);
    
    //小内存的最大大小
    p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;

//迭代启动设置成p
    p->current = p;
    //暂不明确
    p->chain = NULL;
    //不预先分配大内存块
    p->large = NULL;
    p->cleanup = NULL;
    //设置logger
    p->log = log;

return p;
}
```
## 分配内存
```c
//从内存池中分配内存
//pool: ngx_pool_t* 要在哪个内存池中分配
//size: size_t      需要分配的大小
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);
}
```
### 分配小内存
```c
//分配小内存
//pool:     ngx_pool_t* 要在哪个内存池分配
//size:     size_t      需要分配的大小
//align:    ngx_uint_t  是否对齐(0,1)
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;

//寻找一块合适的内存
    do {
        m = p->d.last;

if (align) {
            //按sizeof(unsigned long)对齐
            //无需对齐则跳过这步
            m = ngx_align_ptr(m, NGX_ALIGNMENT);
        }

//如果对齐之后的大小(m到d.end的距离)符合需分配大小
        //将d.last偏移m+size字节
        //返回m
        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);
}
```
### 分配大内存
```c
//分配大内存
//pool: ngx_pool_t* 在哪个内存池上分配
//size: size_t      需分配的大小
static void *
ngx_palloc_large(ngx_pool_t *pool, size_t size)
{
    void              *p;
    ngx_uint_t         n;
    ngx_pool_large_t  *large;

//分配大内存直接malloc
    p = ngx_alloc(size, pool->log);
    if (p == NULL) {
        return NULL;
    }

n = 0;

//添加到pool的大内存链表中
    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;
    }

//将p加入到大内存链表中
    //并将p作为大内存链表首项
    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

return p;
}
```
### 对齐分配
```c
//分配一块对齐alignment的内存
//pool:         ngx_pool_t*     在哪个内存池中分配
//size:         size_t          内存的大小
//alignment:    size_t          对齐的字节数
void *
ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
{
    void              *p;
    ngx_pool_large_t  *large;

//使用malloc分配
    p = ngx_memalign(alignment, size, pool->log);
    if (p == NULL) {
        return NULL;
    }

//按照大内存的策略来处理
    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;
}
```
## 内存池扩容
```c
//内存池扩容
//pool: ngx_pool_t  *指向内存池的指针
//size: size_t      欲分配的内存大小
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;
}
```
## 内存池中的自清理内存
```c
//添加自带清理器的内存
//pool: ngx_pool_t* 要在哪个内存池中添加
//size: size_t      数据大小
ngx_pool_cleanup_t *
ngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
{
    ngx_pool_cleanup_t  *c;

//从内存池中分配内存构建ngx_pool_cleanup_t
    c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
    if (c == NULL) {
        return NULL;
    }

//判断数据大小是否为0
    if (size) {
        //不为0则分配额外数据
        //供用户使用
        c->data = ngx_palloc(p, size);
        if (c->data == NULL) {
            return NULL;
        }

} else {
        c->data = NULL;
    }

//设置handler为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;
}
```
### 文件描述符(FD)的清理回调函数
```c
//清理指定文件描述符
//pool: ngx_pool_t* 文件对象所属内存池
//fd:   ngx_fd_t    文件描述符
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;

//找到指定的ngx_pool_cleanup_file_t
    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;
            }
        }
    }
}

//关闭文件描述符
//data: void*   指向ngx_pool_cleanup_file_t的指针
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);
    }
}

//删除文件
//data: void*   指向ngx_pool_cleanup_file_t的指针
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);
    }
}
```
## 大内存的释放与内存池的销毁和重设
### 大内存的释放
```c
//大内存释放
//pool: ngx_pool_t* 内存所属内存池
//p:    void*       指向欲释放内存块
ngx_int_t
ngx_pfree(ngx_pool_t *pool, void *p)
{
    ngx_pool_large_t  *l;
    //在大内存链表中找到内存块并调用free
    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;
}
```
### 内存池的销毁
```c
//销毁内存池
//pool: ngx_pool_t* 指向内存池的指针
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) {
        //如果handler不为NULL
        if (c->handler) {
            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
                           "run cleanup: %p", c);
            //使用handler清理数据
            c->handler(c->data);
        }
    }

#if (NGX_DEBUG)

/*
     * we could allocate the pool->log from this pool
     * so we cannot use this log while free()ing the pool
     */

for (l = pool->large; l; l = l->next) {
        ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
    }

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 (l = pool->large; l; l = l->next) {
        if (l->alloc) {
            ngx_free(l->alloc);
        }
    }

//清理内存池的小块内存
    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
        ngx_free(p);

if (n == NULL) {
            break;
        }
    }
}
```
### 重设内存池
```c
//重设内存池
//pool: ngx_pool_t  指向内存池的指针
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) {
        //将d.last设置成p+sizeof(ngx_pool_t)
        //重设last成员
        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
        //失败次数设置成0
        p->d.failed = 0;
    }

//迭代起点设置成pool
    pool->current = pool;
    pool->chain = NULL;
    pool->large = NULL;
}
```
## End
带注释的源码下载: [百度网盘](https://pan.baidu.com/s/1N9vtvDW9Mr0VqcyZwuvbRw  "百度网盘") 提取码：rwv5
### **Lxns牛逼**

Natural

@Natural

分布式菜狗