菜鸟nginx源代码剖析数据结构篇内存池ngx_pool_t

Posted 2020-09-25 wzjhoutai

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了菜鸟nginx源代码剖析数据结构篇内存池ngx_pool_t相关的知识，希望对你有一定的参考价值。

菜鸟nginx源代码剖析数据结构篇（九）内存池ngx_pool_t

Author：Echo Chen（陈斌）

Email：chenb19870707@gmail.com

Blog：Blog.csdn.net/chen19870707

Date：Nov 11th, 2014

今天是一年一度的光棍节。还没有女朋友的程序员童鞋最好还是new一个出来，内存管理一直是C/C++中最棘手的部分。远不止new/delete、malloc/free这么简单。
随着代码量的递增，程序结构复杂度的提高。今天我们就一起研究一下以静止著称的nginx的内存池。

1.源码位置

头文件：http://trac.nginx.org/nginx/browser/nginx/src/core/ngx_palloc.h

源文件：http://trac.nginx.org/nginx/browser/nginx/src/core/ngx_palloc.c

2.数据结构定义

先来学习一下nginx内存池的几个主要数据结构：

ngx_pool_data_t（内存池数据块结构）

   1: typedef struct {

   2:     u_char               *last;

   3:     u_char               *end;

   4:     ngx_pool_t           *next;

   5:     ngx_uint_t            failed;

   6: } ngx_pool_data_t;

last：是一个unsigned char 类型的指针。保存的是/当前内存池分配到末位地址。即下一次分配从此处開始。
end：内存池结束位置；
next：内存池里面有非常多块内存，这些内存块就是通过该指针连成链表的，next指向下一块内存。
failed：内存池分配失败次数。

ngx_pool_s（内存池头部结构）

   1: struct ngx_pool_s {

   2:     ngx_pool_data_t       d;

   3:     size_t                max;

   4:     ngx_pool_t           *current;

   5:     ngx_chain_t          *chain;

   6:     ngx_pool_large_t     *large;

   7:     ngx_pool_cleanup_t   *cleanup;

   8:     ngx_log_t            *log;

   9: };

d：内存池的数据块。
max：内存池数据块的最大值；
current：指向当前内存池；
chain：该指针挂接一个ngx_chain_t结构；
large：大块内存链表，即分配空间超过max的情况使用；
cleanup：释放内存池的callback
log：日志信息

由ngx_pool_data_t和ngx_pool_t组成的nginx内存池结构例如以下图所看到的：

3.相关函数介绍

在分析内存池方法前。须要对几个基本的内存相关函数作一下介绍:

ngx_alloc：（仅仅是对malloc进行了简单的封装）

   1: void *

   2: ngx_alloc(size_t size, ngx_log_t *log)

   3: {

   4:     void  *p;

5:

   6:     p = malloc(size);

   7:     if (p == NULL) {

   8:         ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,

   9:                       "malloc(%uz) failed", size);

  10:     }

11:

  12:     ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, log, 0, "malloc: %p:%uz", p, size);

13:

  14:     return p;

  15: }

ngx_calloc：（调用malloc并初始化为0）

   1: void *

   2: ngx_calloc(size_t size, ngx_log_t *log)

   3: {

   4:     void  *p;

5:

   6:     p = ngx_alloc(size, log);

7:

   8:     if (p) {

   9:         ngx_memzero(p, size);

  10:     }

11:

  12:     return p;

  13: }

ngx_memzero：

   1: #define ngx_memzero(buf, n)       (void) memset(buf, 0, n)

ngx_free ：

   1: #define ngx_free          free

ngx_memalign：

   1: void *

   2: ngx_memalign(size_t alignment, size_t size, ngx_log_t *log)

   3: {

   4:     void  *p;

   5:     int    err;

6:

   7:     err = posix_memalign(&p, alignment, size);

8:

   9:     if (err) {

  10:         ngx_log_error(NGX_LOG_EMERG, log, err,

  11:                       "posix_memalign(%uz, %uz) failed", alignment, size);

  12:         p = NULL;

  13:     }

14:

  15:     ngx_log_debug3(NGX_LOG_DEBUG_ALLOC, log, 0,

  16:                    "posix_memalign: %p:%uz @%uz", p, size, alignment);

17:

  18:     return p;

  19: }

这里alignment主要是针对部分unix平台须要动态的对齐，对POSIX 1003.1d提供的posix_memalign( )进行封装，在大多数情况下，编译器和C库透明地帮你处理对齐问题。nginx中通过宏NGX_HAVE_POSIX_MEMALIGN来控制；调用posix_memalign( )成功时会返回size字节的动态内存。而且这块内存的地址是alignment的倍数。
參数alignment必须是2的幂。还是void指针的大小的倍数。返回的内存块的地址放在了memptr里面。函数返回值是0.

4.内存池基本操作

内存池对外的主要方法有：

创建内存池	ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log);
销毁内存池	void ngx_destroy_pool(ngx_pool_t *pool);
重置内存池	void ngx_reset_pool(ngx_pool_t *pool);
内存申请（对齐）	void * ngx_palloc(ngx_pool_t *pool, size_t size);
内存申请（不正确齐）	void * ngx_pnalloc(ngx_pool_t *pool, size_t size);
内存清除	ngx_int_t ngx_pfree(ngx_pool_t pool, void p);

4.1 创建内存池ngx_create_pool

ngx_create_pool用于创建一个内存池，我们创建时。传入我们的须要的初始大小：

   1: ngx_pool_t *

   2: ngx_create_pool(size_t size, ngx_log_t *log)

   3: {

   4:     ngx_pool_t  *p;

5:

   6:     //以16（NGX_POOL_ALIGNMENT）字节对齐分配size内存

   7:     p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);

   8:     if (p == NULL) {

   9:         return NULL;

  10:     }

11:

  12:     //初始状态：last指向ngx_pool_t结构体之后数据取起始位置

  13:     p->d.last = (u_char *) p + sizeof(ngx_pool_t);

  14:     //end指向分配的整个size大小的内存的末尾

  15:     p->d.end = (u_char *) p + size;

16:

  17:     p->d.next = NULL;

  18:     p->d.failed = 0;

19:

  20:     size = size - sizeof(ngx_pool_t);

  21:     //#define NGX_MAX_ALLOC_FROM_POOL  (ngx_pagesize - 1)，内存池最大不超过4095，x86中页的大小为4K

  22:     p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;

23:

  24:     p->current = p;

  25:     p->chain = NULL;

  26:     p->large = NULL;

  27:     p->cleanup = NULL;

  28:     p->log = log;

29:

  30:     return p;

  31: }

nginx对内存的管理分为大内存与小内存，当某一个申请的内存大于某一个值时，就须要从大内存中分配空间，否则从小内存中分配空间。

nginx中的内存池是在创建的时候就设定好了大小。在以后分配小块内存的时候，假设内存不够。则是又一次创建一块内存串到内存池中，而不是将原有的内存池进行扩张。当要分配大块内存是，则是在内存池外面再分配空间进行管理的，称为大块内存池。

4.2 内存申请 ngx_palloc

   1: void *

   2: ngx_palloc(ngx_pool_t *pool, size_t size)

   3: {

   4:     u_char      *m;

   5:     ngx_pool_t  *p;

6:

   7:     //假设申请的内存大小小于内存池的max值

   8:     if (size <= pool->max) {

9:

  10:         p = pool->current;

11:

  12:         do {

  13:             //对内存地址进行对齐处理

  14:             m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);

15:

  16:             //假设当前内存块够分配内存，则直接分配

  17:             if ((size_t) (p->d.end - m) >= size)

  18:             {

  19:                 p->d.last = m + size;

20:

  21:                 return m;

  22:             }

23:

  24:             //假设当前内存块有效容量不够分配，则移动到下一个内存块进行分配

  25:             p = p->d.next;

26:

  27:         } while (p);

28:

  29:         //当前全部内存块都没有空暇了，开辟一块新的内存，例如以下2详解

  30:         return ngx_palloc_block(pool, size);

  31:     }

32:

  33:     //分配大块内存

  34:     return ngx_palloc_large(pool, size);

  35: }

须要说明的几点：

1、ngx_align_ptr。这是一个用来内存地址取整的宏。很静止，一句话就搞定了。作用不言而喻，取整能够减少CPU读取内存的次数，提高性能。由于这里并没有真正意义调用malloc等函数申请内存，而是移动指针标记而已，所以内存对齐的活，C编译器帮不了你了，得自己动手。

   1: #define ngx_align_ptr(p, a)                                                   \\

nginx源码分析——内存池

nginx源码分析--内存池

内存池及 nginx内存池

Nginx 源码学习内存池及优秀案例赏析：Nginx内存池设计

菜鸟nginx源代码剖析配置与部署篇手把手实现nginx "I love you"

Nginx 模块自主开发六：源码剖析配置文件解析过程

菜鸟nginx源代码剖析数据结构篇 内存池ngx_pool_t