菜鸟nginx源码剖析数据结构篇(八) 缓冲区链表ngx_chain_t

菜鸟nginx源码剖析数据结构篇(八) 缓冲区链表 ngx_chain_t

  • Author:Echo Chen(陈斌)
  • Email:[email protected]
  • Blog:Blog.csdn.net/chen19870707
  • Date:Nov 6th, 2014

    1.缓冲区链表结构ngx_chain_t和ngx_buf_t

    nginx的缓冲区链表如下图所示,ngx_chain_t为链表,ngx_buf_t为缓冲区结点:

    2.源代码位置

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

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

    3.数据结构定义

    ngx_buf_t为缓冲区结点,其定义如下:

       1: typedef struct ngx_buf_s    ngx_buf_t;
       2: typedef void  *ngx_buf_tag_t;
       3: struct ngx_buf_s {
       4:     /*
       5:      * pos通常是用来告诉使用者本次应该从pos这个位置开始处理内存中的数据,这样设置是因为同一个
       6:      * ngx_buf_t可能被多次反复处理。当然,pos的含义是由使用它的模板定义的
       7:      */
       8:     u_char  *pos;
       9:                                
      10:     /* last通常表示有效的内容到此为止,注意,pos与last之间的内存是希望nginx处理的内容 */
      11:     u_char  *last;
      12:                                
      13:     /*
      14:      * 处理文件时,file_pos与file_last的含义与处理内存时的pos与last相同,
      15:      * file_pos表示将要处理的文件位置,file_last表示截至的文件位置。
      16:      */
      17:     off_t   file_pos;
      18:     off_t   file_last;
      19:                                
      20:     /* 如果ngx_buf_t缓冲区用于内存,那么start指向这段内存的起始地址 */
      21:     u_char  *start;
      22:                                
      23:     /* 与start成员对应,指向缓冲区内存的末尾 */
      24:     u_char  *end;
      25:                                
      26:     /* 表示当前缓冲区的类型,例如由哪个模块使用就指向这个模块ngx_module_t变量的地址 */
      27:     ngx_buf_tag_t  tag;
      28:                                
      29:     /* 引用的文件 */
      30:     ngx_file_t  *file;
      31:                                
      32:     /*
      33:      * 当前缓冲区的影子缓冲区,该成员很少用到。当缓冲区转发上游服务器的响应时才使用了shadow成员,
      34:      * 这是因为nginx太节约内存了,分配一块内存并使用ngx_buf_t表示接收到的上游服务器响应后,
      35:      * 在向下游客户端转发时可能会把这块内存存储到文件中,也可能直接向下游发送,此时nginx绝对不会
      36:      * 重新复制一份内存用于新的目的,而是再次建立一个ngx_buf_t结构体指向原内存,这样多个ngx_buf_t
      37:      * 结构体指向了同一份内存,它们之间的关系就通过shadow成员来引用,一般不建议使用。
      38:      */
      39:     ngx_buf_t   *shadow;
      40:                                
      41:     /* 临时内存标志位,为1时表示数据在内存中且这段内存可以修改 */
      42:     unsigned    temporay:1;
      43:                                
      44:     /* 标志位,为1时表示数据在内存中且这段内存不可以修改 */
      45:     unsigned    memory:1;
      46:                                
      47:     /* 标志位,为1时表示这段内存是用nmap系统调用映射过来的,不可以修改 */
      48:     unsigned    mmap:1;
      49:                                
      50:     /* 标志位,为1时表示可回收 */
      51:     unsigned    recycled:1;
      52:                                
      53:     /* 标志位,为1时表示这段缓冲区处理的是文件而不是内存 */
      54:     unsigned    in_file:1;
      55:                                
      56:     /* 标志位,为1时表示需要执行flush操作 */
      57:     unsigned    flush:1;
      58:                                
      59:     /*
      60:      * 标志位,对于操作这块缓冲区时是否使用同步方式,需谨慎考虑,这可能会阻塞nginx进程,nginx中所有
      61:      * 操作几乎都是异步的,这是它支持高并发的关键。有些框架代码在sync为1时可能会有阻塞的方式进行I/O
      62:      * 操作,它的意义视使用它的nginx模块而定。
      63:      */
      64:     unsigned    sync:1;
      65:                                
      66:     /*
      67:      * 标志位,表示是否是最后一块缓冲区,因为ngx_buf_t可以由ngx_chain_t链表串联起来,因此为1时,
      68:      * 表示当前是最后一块待处理的缓冲区。   
      69:      */
      70:     unsigned    last_buf:1;
      71:                                
      72:     /* 标志位,表示是否是ngx_chain_t中的最后一块缓冲区 */
      73:     unsigned    last_in_chain:1;
      74:                                
      75:     /* 标志位,表示是否是最后一个影子缓冲区,与shadow域配合使用。通常不建议使用它 */
      76:     unsigned    last_shadow:1;
      77:                                
      78:     /* 标志位,表示当前缓冲区是否属于临时文件 */
      79:     unsigned    temp_file:1;
      80: }

    ngx_chain_t为缓冲区链表,其结构如下:

       1: typedef struct ngx_chain_s       ngx_chain_t;
       2: struct ngx_chain_s {
       3:     ngx_buf_t    *buf;        //buf指向当前的ngx_buf_t缓冲区
       4:     ngx_chain_t  *next;       //next则用来指向下一个ngx_chain_t,如果这是最后一个ngx_chain_t,则需要把next置为NULL。
       5: };

    4.临时buffer创建ngx_create_tmp_buf

       1: ngx_buf_t *ngx_create_temp_buf(ngx_pool_t *pool, size_t size)
       2: {
       3:     ngx_buf_t *b;
       4:  
       5:     b = ngx_calloc_buf(pool);            //分配ngx_buf_t
       6:     if (b == NULL) {
       7:         return NULL;
       8:     }
       9:  
      10:     b->start = ngx_palloc(pool, size);  //给ngx_buf_t分配buffer
      11:     if (b->start == NULL) {
      12:         return NULL;
      13:     }
      14:  
      15:     /*
      16:      * set by ngx_calloc_buf():
      17:      *
      18:      *     b->file_pos = 0;
      19:      *     b->file_last = 0;
      20:      *     b->file = NULL;
      21:      *     b->shadow = NULL;
      22:      *     b->tag = 0;
      23:      *     and flags
      24:      */
      25:  
      26:     //设置起始位置pos和结束位置last,end指向缓冲区的末尾,临时标志设置为1
      27:     b->pos = b->start;
      28:     b->last = b->start;
      29:     b->end = b->last + size;
      30:     b->temporary = 1;
      31:  
      32:     return b;
      33: }

    5.创建缓冲区链表ngx_alloc_chain_link

       1: ngx_chain_t *ngx_alloc_chain_link(ngx_pool_t *pool)
       2: {
       3:     ngx_chain_t  *cl;
       4:  
       5:     cl = pool->chain;
       6:     
       7:     if (cl) 
       8:     {
       9:         pool->chain = cl->next;
      10:         return cl;
      11:     }
      12:  
      13:     cl = ngx_palloc(pool, sizeof(ngx_chain_t));
      14:     if (cl == NULL)
      15:     {
      16:         return NULL;
      17:     }
      18:  
      19:     return cl;
      20: }

    6.缓冲区链表构建ngx_create_chain_of_bufs

    构建如下的缓冲区链表,代码比较简单,很容易理解:

       1: ngx_chain_t *ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs)
       2: {
       3:     u_char       *p;
       4:     ngx_int_t     i;
       5:     ngx_buf_t    *b;
       6:     ngx_chain_t  *chain, *cl, **ll;
       7:  
       8:     //分配buf内存
       9:     p = ngx_palloc(pool, bufs->num * bufs->size);
      10:     if (p == NULL)
      11:     {
      12:         return NULL;
      13:     }
      14:  
      15:     ll = &chain;
      16:  
      17:     for (i = 0; i < bufs->num; i++)
      18:     {
      19:         //分配ngx_buf_t内存
      20:         b = ngx_calloc_buf(pool);
      21:         if (b == NULL)
      22:         {
      23:             return NULL;
      24:         }
      25:  
      26:         /*
      27:          * set by ngx_calloc_buf():
      28:          *
      29:          *     b->file_pos = 0;
      30:          *     b->file_last = 0;
      31:          *     b->file = NULL;
      32:          *     b->shadow = NULL;
      33:          *     b->tag = 0;
      34:          *     and flags
      35:          *
      36:          */
      37:  
      38:         b->pos = p;
      39:         b->last = p;
      40:         b->temporary = 1;
      41:  
      42:         b->start = p;
      43:         p += bufs->size;
      44:         b->end = p;
      45:  
      46:         //分配ngx_chain_t
      47:         cl = ngx_alloc_chain_link(pool);
      48:         if (cl == NULL)
      49:         {
      50:             return NULL;
      51:         }
      52:  
      53:         //
      54:         cl->buf = b;
      55:         *ll = cl;
      56:         ll = &cl->next;
      57:     }
      58:  
      59:     //最后一个结点指向NULL
      60:     *ll = NULL;
      61:  
      62:     return chain;
      63: }

    7.将其它缓冲区拷贝增加到已有缓冲区末尾ngx_chain_add_copy

       1: ngx_int_t ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)
       2: {
       3:     ngx_chain_t  *cl, **ll;
       4:  
       5:     ll = chain;
       6:  
       7:     //找到缓冲区末尾,即为NULL
       8:     for (cl = *chain; cl; cl = cl->next)
       9:     {
      10:         ll = &cl->next;
      11:     }
      12:  
      13:     while (in) 
      14:     {
      15:         //遍历in,依次拷贝每一个结点
      16:         cl = ngx_alloc_chain_link(pool);
      17:         if (cl == NULL)
      18:         {
      19:             return NGX_ERROR;
      20:         }
      21:  
      22:         cl->buf = in->buf;
      23:         *ll = cl;
      24:         ll = &cl->next;
      25:         in = in->next;
      26:     }
      27:  
      28:     //缓冲区末尾赋值为NULL
      29:     *ll = NULL;
      30:  
      31:     return NGX_OK;
      32: }

    8.从空闲缓冲区列表中获取一个未使用的buf ngx_get_free_buf

    ngx_chain_get_free_buf 得到链表中未使用的buf,如果没有,则分配一个。

       1: ngx_chain_t *ngx_chain_get_free_buf(ngx_pool_t *p, ngx_chain_t **free)
       2: {
       3:     ngx_chain_t  *cl;
       4:  
       5:     //若空闲链表中有结点,直接返回
       6:     if (*free)
       7:     {
       8:         cl = *free;
       9:         *free = cl->next;
      10:         cl->next = NULL;
      11:         return cl;
      12:     }
      13:  
      14:     //否则分配ngx_chain_t
      15:     cl = ngx_alloc_chain_link(p);
      16:     if (cl == NULL) {
      17:         return NULL;
      18:     }
      19:  
      20:     //并给ngx_chain_t分配buf
      21:     cl->buf = ngx_calloc_buf(p);
      22:     if (cl->buf == NULL)
      23:     {
      24:         return NULL;
      25:     }
      26:  
      27:     cl->next = NULL;
      28:  
      29:     return cl;
      30: }

    9.  buf释放 ngx_chain_update_chains

       1:  
       2: void ngx_chain_update_chains(ngx_pool_t *p, ngx_chain_t **free, ngx_chain_t **busy,
       3:     ngx_chain_t **out, ngx_buf_tag_t tag)
       4: {
       5:     ngx_chain_t  *cl;
       6:  
       7:     //让busy指向out
       8:     if (*busy == NULL)
       9:     {
      10:         *busy = *out;
      11:  
      12:     } 
      13:     else
      14:     {
      15:         for (cl = *busy; cl->next; cl = cl->next) { /* void */ }
      16:  
      17:         cl->next = *out;
      18:     }
      19:  
      20:     *out = NULL;
      21:  
      22:     while (*busy) 
      23:     {
      24:         cl = *busy;
      25:  
      26:         //这个结点内存有占用,不满足释放条件,跳出
      27:         if (ngx_buf_size(cl->buf) != 0) 
      28:         {
      29:             break;
      30:         }
      31:  
      32:         //缓冲区类型不同,直接释放
      33:         if (cl->buf->tag != tag)
      34:         {
      35:             *busy = cl->next;
      36:             ngx_free_chain(p, cl);
      37:             continue;
      38:         }
      39:  
      40:         //将该结点放入free
      41:         cl->buf->pos = cl->buf->start;
      42:         cl->buf->last = cl->buf->start;
      43:  
      44:         *busy = cl->next;
      45:         cl->next = *free;
      46:         *free = cl;
      47:     }
      48: }

    -

    Echo Chen:Blog.csdn.net/chen19870707

    -

  • 时间: 2024-10-17 01:36:01

    菜鸟nginx源码剖析数据结构篇(八) 缓冲区链表ngx_chain_t的相关文章

    菜鸟nginx源码剖析数据结构篇(八) 缓冲区链表ngx_chain_t[转]

    菜鸟nginx源码剖析数据结构篇(八) 缓冲区链表 ngx_chain_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:Nov 6th, 2014 1.缓冲区链表结构ngx_chain_t和ngx_buf_t nginx的缓冲区链表如下图所示,ngx_chain_t为链表,ngx_buf_t为缓冲区结点: 2.源代码位置 头文件:http://trac.nginx.org/ng

    菜鸟nginx源码剖析数据结构篇(六) 哈希表 ngx_hash_t(上)

    Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:October 31h, 2014 1.哈希表ngx_hash_t的优势和特点 哈希表是一种典型的以空间换取时间的数据结构,在没有冲突的情况下,对任意元素的插入.索引.删除的时间复杂度都是O(1).这样优秀的时间复杂度是通过将元素的key值以hash方法f映射到哈希表中的某一个位置来访问记录来实现的,即键值为key的元素必定存储在哈希

    菜鸟nginx源码剖析数据结构篇(九) 内存池ngx_pool_t[转]

    菜鸟nginx源码剖析数据结构篇(九) 内存池ngx_pool_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:Nov 11th, 2014 今天是一年一度的光棍节,还没有女朋友的程序猿童鞋不妨new一个出来,内存管理一直是C/C++中最棘手的部分,远不止new/delete.malloc/free这么简单.随着代码量的递增,程序结构复杂度的提高.今天我们就一起研究一下以精巧著

    菜鸟nginx源码剖析数据结构篇(十一) 共享内存ngx_shm_t[转]

    菜鸟nginx源码剖析数据结构篇(十一) 共享内存ngx_shm_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:Nov 14th, 2014 1.共享内存 共享内存是Linux下提供的最基本的进程通信方法,它通过mmap或者shmget系统调用在内存中创建了一块连续的线性地址空间,而通过munmap或者shmdt系统调用释放这块内存,使用共享内存的好处是多个进程使用同一块内存

    菜鸟nginx源码剖析数据结构篇(一) 动态数组ngx_array_t

    菜鸟nginx源码剖析数据结构篇(一)动态数组ngx_array_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:October 20h, 2014 1.ngx_array优势和特点 ngx_array _t是一个顺序容器,支持达到数组容量上限时动态改变数组的大小,类似于STL中vector,具有以下特性: 下标直接索引,访问速度快 动态增长 由slab内存池统一管理分配出的内

    菜鸟nginx源码剖析数据结构篇(四)红黑树ngx_rbtree_t[转]

    菜鸟nginx源码剖析数据结构篇(四)红黑树ngx_rbtree_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:October 27h, 2014 1.ngx_rbtree优势和特点 ngx_rbtree是一种使用红黑树实现的关联容器,关于红黑树的特性,在<手把手实现红黑树>已经详细介绍,这里就只探讨ngx_rbtree与众不同的地方:ngx_rbtree红黑树容器中的元素

    菜鸟nginx源码剖析数据结构篇(五) 基数树 ngx_radix_tree_t[转]

    菜鸟nginx源码剖析数据结构篇(五) 基数树 ngx_radix_tree_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:October 28h, 2014 1.什么是基数树 基数树(radix tree)是一种不怎么常见的数据结构,这里简单的做一下介绍:在计算机科学中,基数树,是一种基于trie(字典树)的特殊的数据结构,可以快速定位叶子结点.radix tree是一种多

    菜鸟nginx源码剖析数据结构篇(三) 单向链表 ngx_list_t[转]

    菜鸟nginx源码剖析数据结构篇(三) 单向链表 ngx_list_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:October 23h, 2014 1.ngx_list优势和特点 ngx_list _t是一个顺序容器,它实际上是动态数组和单向链表的结合体,扩容起来比动态数组简单的多,可以一次扩容一个数组,所以说它结合了 链表插入删除不需要移动的 和 数组下标快速索引 的优势

    菜鸟nginx源码剖析数据结构篇(一)动态数组ngx_array_t[转]

    菜鸟nginx源码剖析数据结构篇(一)动态数组ngx_array_t Author:Echo Chen(陈斌) Email:[email protected] Blog:Blog.csdn.net/chen19870707 Date:October 20h, 2014 1.ngx_array优势和特点 ngx_array _t是一个顺序容器,支持达到数组容量上限时动态改变数组的大小,类似于STL中vector,具有以下特性: 下标直接索引,访问速度快 动态增长 由slab内存池统一管理分配出的内