nginx内存池源码剖析

简介: 小块内存使用尾插法,大块内存使用头插法,大块内存申请挂载时如果前面三个节点都有对象,则不再向后遍历,直接创建一个节点插在头部如果一个小块内存超过四次都没有成功分配出内存,则认为他已经没有足够的内存了,则会抛弃(之后不在考虑在这个节点上分配内存)小块内存节点的内存不回收,但是大内存块的节点可以回收,提供回收方法内存对齐,多处内存对齐减少内存跨 cache 的数量。

在很多博客中都将nginx内存池的关系图的next指针指向的结构体画成ngx_pool_data_t类型(可能是为了方便读者理解而故意那样画的),但是通过源码可以看出,next实际指向实际上应该是ngx_pool_s类型,所以我特意找了一张符合源码结构的图

nginx关于内存池的源码路径是src/core/目录下ngx_palloc.h和ngx_palloc.cpp文件

在这里插入图片描述
在这里插入图片描述

相关结构体定义

// 大块内存
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;

// 内存池管理结构
typedef struct ngx_pool_s            ngx_pool_t;
struct ngx_pool_s {
   
   
    ngx_pool_data_t       d;            // 小块内存池
    size_t                max;          // 小块内存最大的分配内存,评估大内存还是小块内存
    ngx_pool_t           *current;      // 当前开始分配的小块内存池
    ngx_chain_t          *chain;        // chain
    ngx_pool_large_t     *large;        // 大块内存
    ngx_pool_cleanup_t   *cleanup;      // 待清理资源
    ngx_log_t            *log;          // 日志对象
};

ngx_pool_t 是整个内存池的管理结构,这种结构对于个内存池对象来说可能存在多个,但是对于用户而言,第一下访问的始终是创建时返回的那个。多个 ngx_pool_t 通过 d.next 来进行连接,current 指向 当前开始分配的小块内存池,注意 ngx_pool_data_t 在内存池结构的起始处,可以进行类型转换访问到不同的成员。

nginx的每一个节点都是nginx-pool-t类型,,但是除了头结点外剩下的节点只使用了nginx-pool-data-t部分

内存对齐

#define ngx_align(d, a)     (((d) + (a - 1)) & ~(a - 1))
#define ngx_align_ptr(p, a)                                                   \
    (u_char *) (((uintptr_t) (p) + ((uintptr_t) a - 1)) & ~((uintptr_t) a - 1))

创建内存池

在nginx中都以16字节为单位对齐

max 的最大值为 4095,当从内存池中申请的内存大小大于 max 时,不会从小块内存中进行分配。

#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)

#define NGX_DEFAULT_POOL_SIZE    (16 * 1024)

#define NGX_POOL_ALIGNMENT       16
#define NGX_MIN_POOL_SIZE                                                     \
    ngx_align((sizeof(ngx_pool_t) + 2 * sizeof(ngx_pool_large_t)),            \
              NGX_POOL_ALIGNMENT)

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); //// 分配一块 size 大小的内存  内存空间16字节对齐
    if (p == NULL) {
   
   
        return NULL;
    }

    // 对pool中的数据项赋初始值
    p->d.last = (u_char *) p + sizeof(ngx_pool_t); //可用空间要减去这个头部 首sizeof(ngx_pool_t)便是pool的header信息,header信息中的各个字段用于管理整个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; //不能超过NGX_MAX_ALLOC_FROM_POOL// pool 中最大可用大小

    p->current = p;
    p->chain = NULL;
    p->large = NULL;
    p->cleanup = NULL;
    p->log = log;

    return p; //指向空间最顶部头部
}

内存申请

在nginx源码中有三个可以申请内存的函数,他们有细微区别

  1. ngx_palloc 普通版本
  2. ngx_pnalloc 内存对齐版本
  3. ngx_pcalloc 会调用ngx_palloc然后初始化内存(清0)
void *
ngx_palloc(ngx_pool_t *pool, size_t size)
{
   
   
    u_char      *m;
    ngx_pool_t  *p;

    // 判断 size 是否大于 pool 最大可使用内存大小
    if (size <= pool->max) {
   
   

        p = pool->current; //从current所在的pool数据节点开始往后遍历寻找那个节点可以分配size内存

        do {
   
   
            m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);// 将 m 对其到内存对齐地址
            if ((size_t) (p->d.end - m) >= size) {
   
   // 判断 pool 中剩余内存是否够用
                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);
}




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

    if (size <= pool->max) {
   
   

        p = pool->current;

        do {
   
   
            m = p->d.last;

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




void *
ngx_pcalloc(ngx_pool_t *pool, size_t size)
{
   
   
    void *p;

    p = ngx_palloc(pool, size);
    if (p) {
   
   
        ngx_memzero(p, size);
    }

    return p;
}

小块内存申请

当没有小块内存池满足申请时,会再申请一个小块内存池来满足分配,在设置完 last 和 end 两个内存指示器后,对从 current 开始的内存池成员 failed 进行自增操作,并且当这个内存池的 failed 分配次数大于 4 时,表面这个内存分配失败的次数太多,根据经验应该下一次分配可能还是失败,所以直接跳过这个内存池,移动 current。

//如果前面开辟的pool空间已经用完,则从新开辟空间ngx_pool_t
static void *
ngx_palloc_block(ngx_pool_t *pool, size_t size)
{
   
   
    u_char      *m;
    size_t       psize;
    ngx_pool_t  *p, *new;

    // 先前的整个 pool 的大小
    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;

    // 判断在当前 pool 分配内存的失败次数,即:不能复用当前 pool 的次数,
    // 如果大于 4 次,这放弃在此 pool 上再次尝试分配内存,以提高效率
    //如果失败次数大于4(不等于4),则更新current指针,放弃对老pool的内存进行再使用
    for (p = pool->current; p->d.next; p = p->d.next) {
   
   
        if (p->d.failed++ > 4) {
   
   
            pool->current = p->d.next;// 更新 current 指针, 每次从pool中分配内存的时候都是从curren开始遍历pool节点获取内存的
        }
    }

    // 让旧指针数据区的 next 指向新分配的 pool
    p->d.next = new;

    return m;
}

大块内存申请

大块内存是通过 large 连接的,并且都属于 ngx_create_pool 返回的 ngx_pool_t 结构。malloc 分配的内存由一个 ngx_pool_large_t 节点来挂载,而这个 ngx_pool_large_t 节点又是从小块内存池中分配的。

  • 为避免large链表长度过大导致在遍历寻找空闲挂载节点耗时过长,限制了遍历的节点为3,如果没有满足要求则直接分配
  • 头插法 插入至large链表中,新的节点后面也是最先被访问
static void *
ngx_palloc_large(ngx_pool_t *pool, size_t size)
{
   
   
    void              *p;
    ngx_uint_t         n;
    ngx_pool_large_t  *large;

    /*
    // 重新申请一块大小为 size 的新内存
    // 注意:此处不使用 ngx_memalign 的原因是,新分配的内存较大,对其也没太大必要
    //  而且后面提供了 ngx_pmemalign 函数,专门用户分配对齐了的内存
    */
    p = ngx_alloc(size, pool->log);
    if (p == NULL) {
   
   
        return NULL;
    }

    n = 0;

    // 查找largt链表上空余的large 指针
    for (large = pool->large; large; large = large->next) {
   
   
        if (large->alloc == NULL) {
   
    //就用这个没用的large
            large->alloc = p;
            return p;
        }

        /*
         // 如果当前 large 后串的 large 内存块数目大于 3 (不等于3),
        // 则直接去下一步分配新内存,不再查找了
        */
        if (n++ > 3) {
   
   //也就是说如果pool->large头后面连续4个large的alloc指针都被用了,则重新申请一个新的pool_larg并放到pool->large头部
            break; //????? 感觉没啥用,因为后面每次alloc的large对应的alloc都是赋值了的
        }
    }

    large = ngx_palloc(pool, sizeof(ngx_pool_large_t));
    if (large == NULL) {
   
   
        ngx_free(p);
        return NULL;
    }

    // 将新分配的 large 串到链表后面
    large->alloc = p;
    large->next = pool->large;
    pool->large = large;

    return p;
}

大块内存释放

ngx_int_t
ngx_pfree(ngx_pool_t *pool, void *p)
{
   
   
    ngx_pool_large_t  *l;

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

销毁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在ngx_pool_cleanup_add赋值
        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)

    /*
     * we could allocate the pool->log from this pool
     * so we cannot use this log while 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;
        }
    }
}

重置pool

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) {
   
   
        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
        p->d.failed = 0;
    }

    pool->current = pool;
    pool->chain = NULL;
    pool->large = NULL;
}

总结

  1. 小块内存使用尾插法,大块内存使用头插法,
  2. 大块内存申请挂载时如果前面三个节点都有对象,则不再向后遍历,直接创建一个节点插在头部
  3. 如果一个小块内存超过四次都没有成功分配出内存,则认为他已经没有足够的内存了,则会抛弃(之后不在考虑在这个节点上分配内存)
  4. 小块内存节点的内存不回收,但是大内存块的节点可以回收,提供回收方法
  5. 内存对齐,多处内存对齐减少内存跨 cache 的数量
  6. nginx内存池注重时间(空间换时间),内存的利用度并不高,与c++ sgi stl的二级内存池有很大的差异,这是由于nginx的业务场景所决定的
目录
相关文章
|
3月前
|
存储 网络协议 应用服务中间件
Nginx源码阅读:ngx_palloc 内存池
Nginx源码阅读:ngx_palloc 内存池
55 0
|
3月前
|
应用服务中间件 nginx
Nginx-内存池
Nginx-内存池
26 0
|
4月前
|
应用服务中间件 nginx
简单理解Nginx内存池:优化性能的关键
简单理解Nginx内存池:优化性能的关键
103 0
|
存储 网络协议 Java
内存池组件以及根据nginx内存池源码设计实现简易内存池
内存池组件以及根据nginx内存池源码设计实现简易内存池
内存池组件以及根据nginx内存池源码设计实现简易内存池
|
机器学习/深度学习 算法 应用服务中间件
Nginx源码剖析之内存池和内存管理
Nginx(发音同 engine x)是一款轻量级的Web 服务器/反向代理服务器及电子邮件(IMAP/POP3)代理服务器,并在一个BSD-like 协议下发行。
923 0
|
应用服务中间件 nginx 机器学习/深度学习
nginx中的内存池
http://www.cnblogs.com/sld666666/archive/2010/06/27/1766255.html 1.为什么需要内存池     为什么需要内存池? a. 在大量的小块内存的申请和释放的时候,能更快地进行内存分配(对比malloc和free) b.减少内存碎片,防止内存泄露。
865 0
|
3天前
|
域名解析 缓存 负载均衡
Nginx正向代理域名的配置
Nginx正向代理域名的配置
|
3天前
|
前端开发 JavaScript 应用服务中间件
修改Jeecg-boot context-path(附加图片+Nginx配置)
修改Jeecg-boot context-path(附加图片+Nginx配置)
10 0
|
14天前
|
应用服务中间件 nginx
nginx进行反向代理的配置
在Nginx中设置反向代理的步骤:编辑`/etc/nginx/nginx.conf`,在http段加入配置,创建一个监听80端口、服务器名为example.com的虚拟主机。通过`location /`将请求代理到本地3000端口,并设置代理头。保存配置后,使用`sudo nginx -s reload`重载服务。完成配置,通过example.com访问代理服务器。
22 0