Nginx源码阅读（ngx_pool_t）

最新推荐文章于 2024-08-16 12:55:30 发布
最新推荐文章于 2024-08-16 12:55:30 发布
阅读量432 收藏
点赞数
分类专栏： Nginx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hz5034/article/details/54647372
版权 
// src/core/ngx_palloc.h

struct ngx_pool_s {
    ngx_pool_data_t       d;
    size_t                max; /* 全部可使用内存的大小，包含已使用和未使用内存。
                                  区别小块和大块内存的标准，小于等于max为小块内存，大于max为大块内存。 */
    ngx_pool_t           *current; // 在多个ngx_pool_t连成的链表中，current指向分配内存时遍历的第一个ngx_pool_t
    ngx_chain_t          *chain;
    ngx_pool_large_t     *large; // 指向多个ngx_pool_large_t连成的链表
    ngx_pool_cleanup_t   *cleanup; // 指向多个ngx_pool_cleanup_t连成的链表
    ngx_log_t            *log;
};


typedef struct {
    u_char               *last; // 指向未使用内存的首部
    u_char               *end; // 指向未使用内存的尾部
    ngx_pool_t           *next; // 多个ngx_pool_t通过next连成链表
    ngx_uint_t            failed; /* 每当剩余空间不足以分配出小块内存时，failed成员就会加1。
                                     failed成员大于4后，ngx_pool_t的current将移向下一个小块内存池。 */
} ngx_pool_data_t;


struct ngx_pool_large_s {
    ngx_pool_large_t     *next; // 多个ngx_pool_large_t通过next连成链表
    void                 *alloc; // 指向ngx_alloc分配出的大块内存
};

struct ngx_pool_cleanup_s {
    ngx_pool_cleanup_pt   handler; // typedef void (*ngx_pool_cleanup_pt)(void *data);
    void                 *data;
    ngx_pool_cleanup_t   *next; // 多个ngx_pool_cleanup_t通过next连成链表
};
// src/core/ngx_palloc.c

//创建内存池
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;

    // max = min{size - sizeof(ngx_pool_t), NGX_MAX_ALLOC_FROM_POOL}
    size = size - sizeof(ngx_pool_t);
    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;
}


// 销毁内存池
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) {
        if (c->handler) {
            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
                           "run cleanup: %p", c);
            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;
        }
    }
}


// 重置内存池。把大块内存释放给操作系统，而小块内存则在不释放的情况下复用
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;
}


/* ngx_palloc和ngx_pnalloc都是根据pool->max和size的大小关系，从pool中分配大小为size的内存块。
   两者的区别在于分配小块内存时是否对齐d.last。 */
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);
}


void *
ngx_pnalloc(ngx_pool_t *pool, size_t size)
{
#if !(NGX_DEBUG_PALLOC)
    if (size <= pool->max) {
        return ngx_palloc_small(pool, size, 0); // 不对齐
    }
#endif

    return ngx_palloc_large(pool, size);
}


// 分配小块内存
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;

    // 遍历ngx_pool_t链表，分配大小为size的小块内存
    do {
        m = p->d.last;

        if (align) {
            m = ngx_align_ptr(m, NGX_ALIGNMENT); // 对齐d.last
        }

        if ((size_t) (p->d.end - m) >= size) {
            p->d.last = m + size;

            return m;
        }

        p = p->d.next;

    } while (p);

    // 没有找到大小为size的小块内存，在链表尾部插入一个ngx_pool_t，分配大小为size的小块内存
    return ngx_palloc_block(pool, size);
}


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;

    // 链表中d.failed的值依次为6, ..., 6, 5, 4, 3, 2, 1, 0，其中current指向5
    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;
}


// 分配大块内存
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) {
        if (large->alloc == NULL) {
            large->alloc = p;
            return p;
        }

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

    // 没有找到alloc为NULL的ngx_pool_large_t，从小块内存池中分配一个新的ngx_pool_large_t
    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
    if (large == NULL) {
        ngx_free(p);
        return NULL;
    }

    large->alloc = p;
    // 在链表头部插入新建的ngx_pool_large_t
    large->next = pool->large;
    pool->large = large;

    return p;
}


// 这样分配出的内存不管申请的size有多小，都是不会使用小块内存池的，它会从进程的堆中分配内存，并挂在大块内存组成的large单链表中
void *
ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
{
    void              *p;
    ngx_pool_large_t  *large;

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


// 释放地址为p的大块内存， 注意需要置alloc为NULL
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;
}


// 在ngx_palloc的基础上增加了清零分配的内存
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;
}
hz5034
关注
专栏目录
nginx源代码分析之内存池(ngx_pool_t)技术
nicomy2018的博客
07-10 1145
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 由于业务的需要经常用nginx作为反向代理服务器，提供http的web服务、rtmp和hls的流媒体服务，虽然对于nginx的配置和使用了然于胸，但是对于nginx的实现原理却知之甚少，知其然却不知其所以然，作为一个码龄超过20年的c++程序员显然是有些说不过去的，从本期开始将会不定期的更新对于ng...
[nginx] nginx内存池ngx_pool_t的介绍
LIncoLN的博客
11-12 612
本文详细介绍nginx中内存池的设计和实现。   nginx pool 由 小内存拉链、大内存拉链、回调函数拉链组成。创建的第一个ngx_pool_s头部，会作为整个pool的head，保存一些拉链信息。 1 创建一个ngx_pool： struct ngx_pool_s { ngx_pool_data_t d; size_t m...
nginx内存池源码剖析
weixin_43825537的博客
05-28 202
nginx的简单介绍 Nginx是一款轻量级的Web服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器，在BSD-like 协议下发行。其特点是占有内存少，并发能力强，事实上nginx的并发能力在同类型的网页服务器中表现较好，中国大陆使用nginx网站用户有：百度、京东、新浪、网易、腾讯、淘宝等,下面，我们将对Nginx的内存池部分源码进行剖析。 nginx内存池之创建内存池 源代码： ngx_pool_t * ngx_create_pool(size_t size, ngx_lo.
指针为什么要动态分配空间
weixin_45232028的博客
09-16 2188
你需要分清“指针所占用的内存空间”和“指针指向的内存空间”之间的区别。指针变量需要存储它所指向的内存地址，涉及到存储就需要空间，例如在64位程序中，任何一个指针变量都占用64位即8字节的内存空间。而指针所指向的内存空间，指的是根据指针变量中存储的内存地址寻址到对应位置的内存空间。这就好比房间和门牌号的关系，门牌号需要写在一个牌子上，这个牌子就是指针变量所占用的内存空间，而房间本身则是指针变量指向的内存空间。 第二，sizeof关键字的结果是在编译期就计算好的，对于double类型的指针p来说，sizeof(
【Nginx源码】ngx_command_t学习
Edidaughter的博客
08-07 209
【代码】【Nginx源码】ngx_command_t学习。
NGINX源码之：ngx_hash
qq_22351805的博客
07-15 910
ngx_hash源码分析，与demo示例
Nginx源码阅读：ngx_palloc 内存池
菊头蝙蝠的博客
05-19 847
Nginx源码阅读：ngx_palloc 内存池
nginx源码：ngx_array_s，ngx_pool_s赏析
最新发布
weixin_42418361的博客
08-16 163
nginx源码
Nginx源码阅读：共享内存ngx_shm_t和它的组织方式ngx_shm_zone_t、ngx_list_t
菊头蝙蝠的博客
05-20 770
Nginx源码阅读：共享内存以及它的组织方式
nginx upstream server主动健康检测模块ngx_http_upstream_check_module 使用和源码分析(下）
一个致力于开源代码学习、分析和交流的博客
02-06 1642
本文介绍了在ngx_http_upstream_check_module模块中扩展实现udp健康检测的能力。
聊一聊nginx ngx_http_proxy_module模块
huzilinitachi的专栏
04-24 4887
        什么是代理？代理是作为中间层，作用于上下游两端。将下游的“请求”转移提交到上游，将上游的“响应”提交给下游。代理不仅在设计模式等程序设计中有比较广泛的使用，同时在大型的系统工程中使用也比较广泛，在web服务器领域，代理出现的频率也是很高的。        web服务中的代理有正向代理和反向代理两种，在大型的web服务中，反向代理是一种非常常用的技术，使用反向代理技能起到转发请求的作...
nginx源码分析—内存池结构ngx_pool_t及内存管理
热门推荐
学习，思考，记录，分享。
07-06 3万+
本博客（http://blog.csdn.net/livelylittlefish）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！Content0. 序1. 内存池结构1.1 ngx_pool_t结构1.2 其他相关结构1.3 ngx_pool_t的逻辑结构2. 内存池操作2.1 创建内存池2.2 销毁内存池2.3 重置内存池2.4 分配内存2.4.1 ngx_palloc()函
Nginx源码阅读（main）
Jiajun Zhu
01-20 3175
/* src/core/nginx.c */int ngx_cdecl // #define ngx_cdecl，一个空的define，跨平台支持 main(int argc, char *const *argv) { ngx_buf_t *b; ngx_log_t *log; ngx_uint_t i; ngx_
Nginx源码阅读（worker进程处理http请求流程）
Jiajun Zhu
12-06 1381
worker进程循环执行以下步骤，其中第5步是nginx真正处理http请求的过程 1、抢锁（非阻塞，没抢到锁就只处理旧连接上的http请求，不接收新连接） 抢到锁： 若上次抢到锁，意味着监听套接字已经在epoll中了，do nothing 若上次没抢到锁，意味着监听套接字不在epoll中，需要将监听套接字添加到epoll中 没抢到锁： 若上次抢到锁，意味着监听套接字还在epoll中，需...
Nginx源码阅读（ngx_http_init_connection）
Jiajun Zhu
07-15 1120
ngx_http_init_connection() void ngx_http_init_connection(ngx_connection_t *c) { ngx_uint_t i; ngx_event_t *rev; struct sockaddr_in *sin; ngx_http_port_t ...
Nginx源码阅读（ngx_http_process_request_line）
Jiajun Zhu
07-15 1047
ngx_http_process_request_line() static void ngx_http_process_request_line(ngx_event_t *rev) { ssize_t n; ngx_int_t rc, rv; ngx_str_t host; ngx_con...
Nginx源码阅读（ngx_event_accept）
Jiajun Zhu
04-02 973
static ngx_int_t ngx_event_process_init(ngx_cycle_t *cycle) { ngx_uint_t m, i; ngx_event_t *rev, *wev; ngx_listening_t *ls; ngx_connection_t *c, *next, *old; ...
Nginx源码阅读（ngx_worker_process_cycle）
Jiajun Zhu
08-18 946
ngx_worker_process_cycle()static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data) { ngx_int_t worker = (intptr_t) data; ngx_process = NGX_PROCESS_WORKER; ngx_worker = worker;
详解Nginx ngx_pool_s结构：内存池与网络模型
本文主要探讨了Nginx的内部实现原理，特别是围绕ngx_pool_s结构进行深入解析。Nginx采用高效的事件驱动架构，其中核心的概念包括Reactor模型，它是一种常见的处理并发I/O的模式，通过多路复用器（如Linux上的select...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值