nginx数组ngx_array_t

2024-05-04 22:32
文章标签 数组 nginx array ngx

本文主要是介绍nginx数组ngx_array_t，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

本博客（http://blog.csdn.net/livelylittlefish ）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！

【注】懒得写，该哥们写的挺好


Content

0. 序

1. 数组结构

1.1 ngx_array_t结构

1.2 ngx_array_t的逻辑结构

2. 数组操作

2.1 创建数组

2.2 销毁数组

2.3 添加1个元素

3. 一个例子

3.1 代码

3.2 如何编译

3.3 运行结果

4. 小结

0. 序

本文开始介绍nginx的容器，先从最简单的数组开始。

数组实现文件：文件：./src/core/ngx_array.h/.c。.表示nginx-1.0.4代码目录，本文为/usr/src/nginx-1.0.4。

1. 数组结构

1.1 ngx_array_t结构

nginx的数组结构为ngx_array_t，定义如下。

[cpp]  view plain copy
  1. struct ngx_array_s {  
  2.     void        *elts;    //数组数据区起始位置  
  3.     ngx_uint_t   nelts;   //实际存放的元素个数  
  4.     size_t       size;    //每个元素大小  
  5.     ngx_uint_t   nalloc;  //数组所含空间个数，即实际分配的小空间的个数  
  6.     ngx_pool_t  *pool;    //该数组在此内存池中分配  
  7. };  
  8.    
  9. typedef struct ngx_array_s  ngx_array_t;  

sizeof(ngx_array_t)=20。由其定义可见，nginx的数组也要从内存池中分配。将分配nalloc个大小为size的小空间，实际分配的大小为(nalloc * size)。详见下文的分析。

1.2 ngx_array_t的逻辑结构

ngx_array_t结构引用了ngx_pool_t结构，因此本文参考nginx-1.0.4源码分析—内存池结构ngx_pool_t及内存管理一文画出相关结构的逻辑图，如下。注：本文采用UML的方式画出该图。 

 

 2. 数组操作

数组操作共有5个，如下。

[cpp]  view plain copy
  1. //创建数组  
  2. ngx_array_t*ngx_array_create(ngx_pool_t *p, ngx_uint_t n, size_t size);  
  3.    
  4. //销毁数组  
  5. voidngx_array_destroy(ngx_array_t *a);  
  6.    
  7. //向数组中添加元素  
  8. void*ngx_array_push(ngx_array_t *a);  
  9. void*ngx_array_push_n(ngx_array_t *a, ngx_uint_t n);  
  10.    
  11. //初始化数组  
  12. staticngx_inline ngx_int_t  
  13. ngx_array_init(ngx_array_t*array, ngx_pool_t *pool, ngx_uint_t n, size_t size)  
因实现都很简单，本文简单分析前3个函数。

2.1 创建数组

创建数组的操作实现如下，首先分配数组头(20B)，然后分配数组数据区，两次分配均在传入的内存池(pool指向的内存池)中进行。然后简单初始化数组头并返回数组头的起始位置。

[cpp]  view plain copy
  1. ngx_array_t*  
  2. ngx_array_create(ngx_pool_t*p, ngx_uint_t n, size_t size)  
  3. {  
  4.     ngx_array_t *a;  
  5.    
  6.     a = ngx_palloc(p,sizeof(ngx_array_t));  //从内存池中分配数组头  
  7.     if (a == NULL) {  
  8.         return NULL;  
  9.     }  
  10.    
  11.     a->elts = ngx_palloc(p,n * size);  //接着分配n*size大小的区域作为数组数据区  
  12.     if (a->elts == NULL) {  
  13.         return NULL;  
  14.     }  
  15.    
  16.     a->nelts = 0;    //初始化  
  17.     a->size = size;  
  18.     a->nalloc = n;  
  19.     a->pool = p;  
  20.    
  21.     return a;  //返回数组头的起始位置  
  22. }  
创建数组后内存池的物理结构图如下。

 

 2.2 销毁数组

销毁数组的操作实现如下，包括销毁数组数据区和数组头。这里的销毁动作实际上就是修改内存池的last指针，并没有调用free等释放内存的操作，显然，这种维护效率是很高的。

[cpp]  view plain copy
  1. void  
  2. ngx_array_destroy(ngx_array_t*a)  
  3. {  
  4.     ngx_pool_t *p;  
  5.    
  6.     p = a->pool;  
  7.    
  8.     if ((u_char *) a->elts+ a->size * a->nalloc == p->d.last) {  //先销毁数组数据区  
  9.         p->d.last -=a->size * a->nalloc;  //设置内存池的last指针  
  10.     }  
  11.    
  12.     if ((u_char *) a +sizeof(ngx_array_t) == p->d.last) {  //接着销毁数组头  
  13.         p->d.last = (u_char*) a;          //设置内存池的last指针  
  14.     }  
  15. }  

2.3 添加1个元素

向数组添加元素的操作有两个，ngx_array_push和ngx_array_push_n，分别添加一个和多个元素。

但实际的添加操作并不在这两个函数中完成，例如ngx_array_push返回可以在该数组数据区中添加这个元素的位置，ngx_array_push_n则返回可以在该数组数据区中添加n个元素的起始位置，而添加操作即在获得添加位置之后进行，如后文的例子。

[cpp]  view plain copy
  1. void *  
  2. ngx_array_push(ngx_array_t*a)  
  3. {  
  4.     void       *elt, *new;  
  5.     size_t      size;  
  6.     ngx_pool_t *p;  
  7.    
  8.     if (a->nelts ==a->nalloc) {  //数组数据区满  
  9.    
  10.         /* the arrayis full */  
  11.    
  12.         size = a->size *a->nalloc;  //计算数组数据区的大小  
  13.    
  14.         p = a->pool;  
  15.    
  16.         if ((u_char *)a->elts + size == p->d.last  //若内存池的last指针指向数组数据区的末尾  
  17.             &&p->d.last + a->size <= p->d.end) //且内存池未使用的区域可以再分配一个size大小的小空间  
  18.         {  
  19.             /* 
  20.              * the array allocation is the lastin the pool 
  21.              * and there is space for newallocation 
  22.              */  
  23.    
  24.             p->d.last +=a->size;  //分配一个size大小的小空间(a->size为数组一个元素的大小)  
  25.             a->nalloc++;           //实际分配小空间的个数加1  
  26.    
  27.         } else {  
  28.             /* allocate a new array */  
  29.    
  30.             new =ngx_palloc(p, 2 * size);  //否则，扩展数组数据区为原来的2倍  
  31.             if (new == NULL) {  
  32.                 return NULL;  
  33.             }  
  34.    
  35.             ngx_memcpy(new,a->elts, size);//将原来数据区的内容拷贝到新的数据区  
  36.             a->elts = new;  
  37.             a->nalloc *= 2;             //注意：此处转移数据后，并未释放原来的数据区，内存池将统一释放  
  38.         }  
  39.     }  
  40.    
  41.     elt = (u_char *)a->elts + a->size * a->nelts; //数据区中实际已经存放数据的子区的末尾  
  42.     a->nelts++;                                  //即最后一个数据末尾，该指针就是下一个元素开始的位置  
  43.    
  44.     return elt;    //返回该末尾指针，即下一个元素应该存放的位置  
  45. }  

由此可见，向数组中添加元素实际上也是在修该内存池的last指针(若数组数据区满)及数组头信息，即使数组满了，需要扩展数据区内容，也只需要内存拷贝完成，并不需要数据的移动操作，这个效率也是相当高的。（lsj：2倍分配扩展）

下图是向数组中添加10个整型元素后的一个例子。代码可参考下文的例子。当然，数组元素也不仅限于例子的整型数据，也可以是其他类型的数据，如结构体等。

 

3. 一个例子

理解并掌握开源软件的最好方式莫过于自己写一些测试代码，或者改写软件本身，并进行调试来进一步理解开源软件的原理和设计方法。本节给出一个创建内存池并从中分配一个数组的简单例子。

3.1代码

[cpp]  view plain copy
  1. /** 
  2.  * ngx_array_t test, to test ngx_array_create, ngx_array_push 
  3.  */  
  4.   
  5. #include <stdio.h>  
  6. #include "ngx_config.h"  
  7. #include "ngx_conf_file.h"  
  8. #include "nginx.h"  
  9. #include "ngx_core.h"  
  10. #include "ngx_string.h"  
  11. #include "ngx_palloc.h"  
  12. #include "ngx_array.h"  
  13.   
  14. volatile ngx_cycle_t  *ngx_cycle;  
  15.   
  16. void ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,  
  17.             const char *fmt, ...)  
  18. {  
  19. }  
  20.   
  21. void dump_pool(ngx_pool_t* pool)  
  22. {  
  23.     while (pool)  
  24.     {  
  25.         printf("pool = 0x%x\n", pool);  
  26.         printf("  .d\n");  
  27.         printf("    .last = 0x%x\n", pool->d.last);  
  28.         printf("    .end = 0x%x\n", pool->d.end);  
  29.         printf("    .next = 0x%x\n", pool->d.next);  
  30.         printf("    .failed = %d\n", pool->d.failed);  
  31.         printf("  .max = %d\n", pool->max);  
  32.         printf("  .current = 0x%x\n", pool->current);  
  33.         printf("  .chain = 0x%x\n", pool->chain);  
  34.         printf("  .large = 0x%x\n", pool->large);  
  35.         printf("  .cleanup = 0x%x\n", pool->cleanup);  
  36.         printf("  .log = 0x%x\n", pool->log);  
  37.         printf("available pool memory = %d\n\n", pool->d.end - pool->d.last);  
  38.         pool = pool->d.next;  
  39.     }  
  40. }  
  41.   
  42. void dump_array(ngx_array_t* a)  
  43. {  
  44.     if (a)  
  45.     {  
  46.         printf("array = 0x%x\n", a);  
  47.         printf("  .elts = 0x%x\n", a->elts);  
  48.         printf("  .nelts = %d\n", a->nelts);  
  49.         printf("  .size = %d\n", a->size);  
  50.         printf("  .nalloc = %d\n", a->nalloc);  
  51.         printf("  .pool = 0x%x\n", a->pool);  
  52.   
  53.         printf("elements: ");  
  54.         int *ptr = (int*)(a->elts);  
  55.         for (; ptr < (int*)(a->elts + a->nalloc * a->size); )  
  56.         {  
  57.             printf("0x%x  ", *ptr++);  
  58.         }  
  59.         printf("\n");  
  60.     }  
  61. }  
  62.   
  63. int main()  
  64. {  
  65.     ngx_pool_t *pool;  
  66.     int i;  
  67.   
  68.     printf("--------------------------------\n");  
  69.     printf("create a new pool:\n");  
  70.     printf("--------------------------------\n");  
  71.     pool = ngx_create_pool(1024, NULL);  
  72.     dump_pool(pool);  
  73.   
  74.     printf("--------------------------------\n");  
  75.     printf("alloc an array from the pool:\n");  
  76.     printf("--------------------------------\n");  
  77.     ngx_array_t *a = ngx_array_create(pool, 10, sizeof(int));  
  78.     dump_pool(pool);  
  79.   
  80.     for (i = 0; i < 10; i++)  
  81.     {  
  82.         int *ptr = ngx_array_push(a);  
  83.         *ptr = i + 1;  
  84.     }  
  85.   
  86.     dump_array(a);  
  87.   
  88.     ngx_array_destroy(a);  
  89.     ngx_destroy_pool(pool);  
  90.     return 0;  
  91. }  
3.2如何编译

请参考nginx-1.0.4源码分析—内存池结构ngx_pool_t及内存管理一文。本文编写的makefile文件如下。

[plain]  view plain copy
  1. CXX = gcc  
  2. CXXFLAGS +=-g -Wall -Wextra  
  3.    
  4. NGX_ROOT =/usr/src/nginx-1.0.4  
  5.    
  6. TARGETS =ngx_array_t_test  
  7. TARGETS_C_FILE= $(TARGETS).c  
  8.    
  9. CLEANUP = rm-f $(TARGETS) *.o  
  10.    
  11. all:$(TARGETS)  
  12.    
  13. clean:  
  14. $(CLEANUP)  
  15.    
  16. CORE_INCS =-I. \  
  17. -I$(NGX_ROOT)/src/core \  
  18. -I$(NGX_ROOT)/src/event \  
  19. -I$(NGX_ROOT)/src/event/modules \  
  20. -I$(NGX_ROOT)/src/os/unix \  
  21. -I$(NGX_ROOT)/objs \  
  22.    
  23. NGX_PALLOC =$(NGX_ROOT)/objs/src/core/ngx_palloc.o  
  24. NGX_STRING =$(NGX_ROOT)/objs/src/core/ngx_string.o  
  25. NGX_ALLOC =$(NGX_ROOT)/objs/src/os/unix/ngx_alloc.o  
  26. NGX_ARRAY =$(NGX_ROOT)/objs/src/core/ngx_array.o  
  27.    
  28. $(TARGETS):$(TARGETS_C_FILE)  
  29. $(CXX) $(CXXFLAGS) $(CORE_INCS) $(NGX_PALLOC) $(NGX_STRING)$(NGX_ALLOC) $(NGX_ARRAY) $^ -o $@  
3.3运行结果
[plain]  view plain copy
  1. # ./ngx_array_t_test  
  2. -------------------------------- create a new pool:  
  3. -------------------------------- pool = 0x860b020 .d .last = 0x860b048  
  4.     .end = 0x860b420  
  5.     .next = 0x0  
  6.     .failed = 0 .max = 984  
  7.   .current = 0x860b020  
  8.   .chain = 0x0  
  9.   .large = 0x0  
  10.   .cleanup = 0x0  
  11.   .log = 0x0 available pool memory = 984  
  12. -------------------------------- alloc an array from the pool:  
  13. -------------------------------- pool = 0x860b020 .d .last = 0x860b084  
  14.     .end = 0x860b420  
  15.     .next = 0x0  
  16.     .failed = 0 .max = 984  
  17.   .current = 0x860b020  
  18.   .chain = 0x0  
  19.   .large = 0x0  
  20.   .cleanup = 0x0  
  21.   .log = 0x0 available pool memory = 924  
  22. array = 0x860b048 .elts = 0x860b05c  
  23.   .nelts = 10  
  24.   .size = 4  
  25.   .nalloc = 10  
  26.   .pool = 0x860b020 elements: 0x1  0x2  0x3  0x4  0x5  0x6  0x7  0x8  0x9  0xa    

该例子中内存池和数组的(内存)物理结构可参考2.3节的图。

4. 小结

本文针对nginx-1.0.4的容器——数组结构进行了较为全面的分析，包括数组相关数据结构，数组的创建、销毁，以及向数组中添加元素等。最后通过一个简单例子向读者展示nginx数组的创建、添加元素和销毁操作，同时借此向读者展示编译测试代码的方法。

敬请关注后续的分析。谢谢！

这篇关于nginx数组ngx_array_t的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/960229。

相关文章

hdu2241（二分+合并数组）

hdu2241（二分+合并数组）

题意：判断是否存在a+b+c = x，a，b，c分别属于集合A,B,C 如果用暴力会超时，所以这里用到了数组合并，将b,c数组合并成d，d数组存的是b，c数组元素的和，然后对d数组进行二分就可以了 代码如下（附注释）： #include<iostream>#include<algorithm>#include<cstring>#include<stack>#include<que
阅读更多...
hdu 1166 敌兵布阵（树状数组 or 线段树）

hdu 1166 敌兵布阵（树状数组 or 线段树）

题意是求一个线段的和，在线段上可以进行加减的修改。 树状数组的模板题。 代码： #include <stdio.h>#include <string.h>const int maxn = 50000 + 1;int c[maxn];int n;int lowbit(int x){return x & -x;}void add(int x, int num){while
阅读更多...
C语言：柔性数组

C语言：柔性数组

数组定义 柔性数组 err int arr[0] = {0}; // ERROR 柔性数组 // 常见struct Test{int len;char arr[1024];} // 柔性数组struct Test{int len;char arr[0];}struct Test *t；t = malloc(sizeof(Test) + 11);strcpy(t->arr,
阅读更多...
C 语言基础之数组

C 语言基础之数组

文章目录 什么是数组数组变量的声明多维数组 什么是数组 数组，顾名思义，就是一组数。 假如班上有 30 个同学，让你编程统计每个人的分数，求最高分、最低分、平均分等。如果不知道数组，你只能这样写代码： int ZhangSan_score = 95;int LiSi_score = 90;......int LiuDong_score = 100;int Zhou
阅读更多...
Windows下Nginx的安装及开机启动

Windows下Nginx的安装及开机启动

1、将nginx-1.16.1.zip解压拷贝至D:\web\nginx目录下。 2、启动Nginx，两种方法： （1）直接双击nginx.exe，双击后一个黑色的弹窗一闪而过。 （2）打开cmd命令窗口，切换到nginx目录下，输入命令 nginx.exe 或者 start nginx ，回车即可。 3、检查nginx是否启动成功。 直接在浏览器地址栏输入网址 http://lo
阅读更多...
nginx介绍及常用功能

nginx介绍及常用功能

什么是nginx nginx跟Apache一样，是一个web服务器（网站服务器），通过HTTP协议提供各种网络服务。 Apache：重量级的，不支持高并发的服务器。在Apache上运行数以万计的并发访问，会导致服务器消耗大量内存。操作系统对其进行进程或线程间的切换也消耗了大量的CPU资源，导致HTTP请求的平均响应速度降低。这些都决定了Apache不可能成为高性能WEB服务器  nginx：
阅读更多...
web群集--nginx配置文件location匹配符的优先级顺序详解及验证

web群集--nginx配置文件location匹配符的优先级顺序详解及验证

文章目录 前言优先级顺序优先级顺序(详解)1. 精确匹配（Exact Match）2. 正则表达式匹配（Regex Match）3. 前缀匹配（Prefix Match） 匹配规则的综合应用验证优先级 前言 location的作用 在 NGINX 中，location 指令用于定义如何处理特定的请求 URI。由于网站往往需要不同的处理方式来适应各种请求，NGINX 提供了多种匹
阅读更多...
计算数组的斜率，偏移，R2

计算数组的斜率，偏移，R2

模拟Excel中的R2的计算。         public bool fnCheckRear_R2(List<double[]> lRear, int iMinRear, int iMaxRear, ref double dR2)         {             bool bResult = true;             int n = 0;             dou
阅读更多...
C# double[] 和Matlab数组MWArray[]转换

C# double[] 和Matlab数组MWArray[]转换

C# double[] 转换成MWArray[], 直接赋值就行             MWNumericArray[] ma = new MWNumericArray[4];             double[] dT = new double[] { 0 };             double[] dT1 = new double[] { 0,2 };
阅读更多...
nginx长连接的问题

nginx长连接的问题

转自： http://www.360doc.com/content/12/1108/17/1073512_246644318.shtml
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2