Nginx 源代码分析(2) 内存池

  内存池的使用是使小内存分配时更加速度，即小内存本来需要的多次malloc可以集中起来一下子malloc一块大的，要用的时候只需要操作指针即可，其返回的即指针。
  首相说明一点的是这次先忽略掉日志结构。
  内存池结构ngx_pool_t在src/core/ngx_palloc.{c,h}中定义及实现

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;//内存池可以分配的最大数据结构大小
               //若要分配大于的内存区域将分配large
    ngx_pool_t           *current;//当前内存池 与d中的failed有关
    ngx_chain_t          *chain;//挂一个chain结构
    ngx_pool_large_t     *large;//指向大块内存的数据数据结构
    ngx_pool_cleanup_t   *cleanup;//挂载一些内存池释放的时候，同时释放的资源
    ngx_log_t            *log;//写log
};

  在 src/core/core.h中

typedef struct ngx_pool_s        ngx_pool_t;

  以下是在网上发现的一张非常好的结构图 在这儿感谢不知名的作者

  内存池的创建在src/core/ngx_palloc.{c.h}中

ngx_pool_t *
ngx_create_pool(size_t size, ngx_log_t *log)//size是要分配的内存池大小 log是日志结构
{
    ngx_pool_t  *p;

    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);//分配大小size的对齐的内存 具体实现下面分析
    if (p == NULL) {//检查是否分配失败
        return NULL;
    }
   
//内存开始的sizeof(ngx_pool_t)个字节需要存放ngx_pool_t结构
    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);//从内存池中可以分配的内存的最大的大小
   //最大的大小不可以大于NGX_MAX_ALLOC_FROM_POOL 具体下面说
    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;
}

  在src/core/ngx_core.h中

#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)//大小即内存页的大小减1

  在src/os/unix/ngx_alloc.{h,c}中
 

//这篇预编译代码挺有意思的 原来预编译还能这么写啊 长见识了…… c语言中的多态啊 哈哈哈
#if (NGX_HAVE_POSIX_MEMALIGN || NGX_HAVE_MEMALIGN)

void *ngx_memalign(size_t alignment, size_t size, ngx_log_t *log);//如果预定义了

#else

#define ngx_memalign(alignment, size, log)  ngx_alloc(size, log)//如果没有预定义 则代码重用ngx_alloc

#endif


#if (NGX_HAVE_POSIX_MEMALIGN)
//定义了NGX_HAVE_POSIX_MEMALIGN 则调用这个函数
void *
ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)
{
    void  *p;
    int    err;

    err = posix_memalign(&p, alignment, size);//分配内存的进一步调用

    if (err) {
        ngx_log_error(NGX_LOG_EMERG, log, err,
                      "posix_memalign(%uz, %uz) failed", alignment, size);//日志
        p = NULL;
    }

    ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,
                   "posix_memalign: %p:%uz @%uz", p, size, alignment);//日志

    return p;
}

#elif (NGX_HAVE_MEMALIGN)
//只定义了NGX_HAVE_MEMALIGN 则调用这个函数
void *
ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)
{
    void  *p;

    p = memalign(alignment, size);
    if (p == NULL) {
        ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
                      "memalign(%uz, %uz) failed", alignment, size);//日志
    }

    ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,
                   "memalign: %p:%uz @%uz", p, size, alignment);//日志

    return p;
}

#endif
//都没定义 则调用这个函数
void *
ngx_alloc(size_t size, ngx_log_t *log)
{
    void  *p;

    p = malloc(size);//终于到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;
}

  好了 到这里 pool已经创建好了
 
  调用ngx_destroy_pool函数释放内存池

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) {//遍历cleanup函数
        if (c->handler) {//如果定义了cleanup函数
            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)

    /*
     * we could allocate the pool->log from this pool
     * so we can not use this log while the free()ing the pool
     */
//日志信息
    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 (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {//遍历内存池
        ngx_free(p);//释放内存池

        if (n == NULL) {
            break;
        }
    }
}

  在src/os/unix/ngx_alloc.h中

#define ngx_free          free

 
  内存池重置函数在src/core/ngx_palloc.c中

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;

    for (p = pool; p; p = p->d.next) {//遍历所有的内存池
        p->d.last = (u_char *) p + sizeof(ngx_pool_t);//重置所有的小块内存 可以重新分配
    }
}

  从内存池中分配小内存 有两个函数ngx_palloc和ngx_pnalloc。
  ngx_palloc函数返回一个对齐的指针 而ngx_pnalloc函数则不一定。在src/core/ngx_palloc.c

void *
ngx_palloc(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    ngx_pool_t  *p;

    if (size <= pool->max) {//如果大于max 则使用ngx_palloc_large函数分配大内存

        p = pool->current;

        do {
            m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);//在ngx_pnalloc函数中没有这一行 其他都一样
                                                        //使返回的地址对齐
            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);//申请大内存块
}

大内存块管理数据结构ngx_pool_large_t在src/core/ngx_palloc.h中

typedef struct ngx_pool_large_s  ngx_pool_large_t;

struct ngx_pool_large_s {
    ngx_pool_large_t     *next;
    void                 *alloc;
};

//从内存池中分配
static void *
ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
    u_char      *m;
    size_t       psize;
    ngx_pool_t  *p, *new, *current;

    psize = (size_t) (pool->d.end - (u_char *) pool);//size大小

    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);//新建一个pool
    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;

    current = pool->current;

    for (p = current; p->d.next; p = p->d.next) {//如果有四次分配失败 则current指针往后移
        if (p->d.failed++ > 4) {
            current = p->d.next;
        }
    }

    p->d.next = new;//把new加入链

    pool->current = current ? current : 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;

    for (large = pool->large; large; large = large->next) {//这里看不懂了…… 可能是前
                                            //三个会有已经分配好的ngx_pool_large_t结构
        if (large->alloc == NULL) {
            large->alloc = p;
            return p;
        }

        if (n++ > 3) {
            break;
        }
    }

    large = ngx_palloc(pool, sizeof(ngx_pool_large_t));//分配管理大内存块的数据结构           ngx_pool_large_t
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }

    large->alloc = p;//加入链表
    large->next = pool->large;
    pool->large = large;

    return p;
}

部分结构，函数分析完毕…