Nginx基础. Nginx数组与链表

ngx_array_t 

实现文件： ./src/core/ngx_array.h     ./src/core/ngx_array.c

1. 数据结构定义

typedef struct {
    void        *elts;          //数组数据区起始位置
    ngx_uint_t   nelts;         //当前存放元素个数
    size_t       size;          //存放的每个元素的大小
    ngx_uint_t   nalloc;        //数组最大能存放的元素个数
    ngx_pool_t  *pool;          //使用的内存池对象
} ngx_array_t;

单纯的从结构定义可以看出, 数组是与内存池绑定的, 占用的空间由内存池分配


2. 数组操作

1.）创建
ngx_array_t *ngx_array_create(ngx_pool_t *p, ngx_uint_t n, size_t size);
2.) 初始化
static ngx_inline ngx_int_t
ngx_array_init(ngx_array_t *array, ngx_pool_t *pool, ngx_uint_t n, size_t size)；
3.) 销毁
void ngx_array_destroy(ngx_array_t *a);
4.) 加入元素
void *ngx_array_push(ngx_array_t *a);
5.) 加入n个相同元素
void *ngx_array_push_n(ngx_array_t *a, ngx_uint_t n);

3. 操作详解
关于数组的操作, 大多简单. 只拿出几个谈谈
先看的当然是数组的创建函数, 但是它就是简单的内存分配以及变量初始化, 这里就不贴出来了

下面是数组的销毁动作, 主要就是修改了内存池的last指针, 并没有调用free等释放内存的操作，显然，这种维护效率是很高的。

void
ngx_array_destroy(ngx_array_t *a)
{
    ngx_pool_t  *p;

    p = a->pool;

     //下面是对数组内容和其结构的"删除", 实际上只是指针的移动. 如果正巧他们不是正好在last指针前面, 那么也就不管了, 反正内存是统一管理的
    if ((u_char *) a->elts + a->size * a->nalloc == p->d.last) {
        p->d.last -= a->size * a->nalloc;
    }

    if ((u_char *) a + sizeof(ngx_array_t) == p->d.last) {
        p->d.last = (u_char *) a;
    }
}

最后, 看看如何添加一个数组元素
根据之前学习STL的经验, 如果当前元素超过了最大元素个数, 那么就会重新分配一段内存给这个数组

void *
ngx_array_push(ngx_array_t *a)
{
    void        *elt, *new;
    size_t       size;
    ngx_pool_t  *p;

     //如果这段数组内存还可以存的下新的元素, 那么处理就简单了
    if (a->nelts == a->nalloc) {

        /* the array is full */
          //首先size得到原来数组的大小
        size = a->size * a->nalloc;

        p = a->pool;

          //判断last指针是否正好在这段数组内存的后面, 如果正好, 那么我们继续判断是否接下来还有空间可以存数组元素
          //这里就跟STL里的vector不同了. 因为我们是在内存池里操作, 如果发现这段数组内存后面正好还有空余的, 那么就直接利用把, 省的再繁杂的操作
        if ((u_char *) a->elts + size == p->d.last
            && p->d.last + a->size <= p->d.end)
        {
            /*
             * the array allocation is the last in the pool
             * and there is space for new allocation
             */

            p->d.last += a->size;
               //因为这里是在原有数组已满的基础上添加元素,又正好有这段内存, 所以需要修改最大元素存储的数量
            a->nalloc++;

        } else {
            /* allocate a new array */
               //否则的话, 只能老老实实的分配一段新的内存, 且大小是原来的两倍
            new = ngx_palloc(p, 2 * size);
            if (new == NULL) {
                return NULL;
            }
                //将原来的元素都复制过来
            ngx_memcpy(new, a->elts, size);
            a->elts = new;
            a->nalloc *= 2;
        }
    }
     //将新元素需要的内存返回
    elt = (u_char *) a->elts + a->size * a->nelts;
    a->nelts++;

    return elt;
}

ngx_list_t

链表是Nginx封装的链表容器, 它在Nginx中使用的非常频繁.
相比较libevent中的TAILQ队列, Nginx中的list理解起来要容易的多
下面就简单的认识一下这个链表.

1. 数据结构的定义

typedef struct ngx_list_part_s ngx_list_part_t;  

struct ngx_list_part_s {
    void             *elts;           //数组的起始地址
    ngx_uint_t        nelts;          //当前存放的元素个数
    ngx_list_part_t  *next;  
};


typedef struct {
    ngx_list_part_t  *last;           //指向链表最后一个节点
    ngx_list_part_t   part;           //链表头中包含的第一个节点(part)  
    size_t            size;           //虽然存储的类型是任意的, 但还是要通过size来限制每个元素占用的空间大小, 即数组中元素大小必须小于或等于size
    ngx_uint_t        nalloc;         //链表的数组元素一旦分配后是不可更改的. nalloc表示每个数组容量
    ngx_pool_t       *pool;
} ngx_list_t;

ngx_list_t描述整个链表, 而ngx_list_part_t只描述链表的一个元素.
要注意的是, ngx_list_t不是一个单纯的链表, 它是存储数组的链表, 即每个链表元素ngx_list_part_t是一个数组, 拥有连续的内存
该数组既依赖ngx_list_t结构中的size和nalloc来表示数组的容量, 同时又依靠每个ngx_list_part_t成员中的nelts来表示当前已经使用了多少容量.

对于这样的设计, 有什么好处呢？
1. 链表中存储的元素是灵活的, 可以是任何一种数据结构
2. 链表元素需要占用的内存由ngx_list_t管理, 它已经通过数组分配好了
3. 小块的内存使用链表访问是低效率的, 使用数组偏移来访问则高效的多


2. 链表的操作

ngx_list_t *
ngx_list_create(ngx_pool_t *pool, ngx_uint_t n, size_t size)
{
    ngx_list_t  *list;

    list = ngx_palloc(pool, sizeof(ngx_list_t));
    if (list == NULL) {
        return NULL;
    }

    if (ngx_list_init(list, pool, n, size) != NGX_OK) {
        return NULL;
    }

    return list;
}

在ngx_list_init中, 不仅初始化了一些变量, 还分配了 n*size 大小内存的一个数组. 说明最初创建的list会自带一个数组元素

除了初始化, 还有一个要看的就是插入元素了
既然链表的每个元素是数组, 那么新值插入的位置就是最后一个数组元素的末尾, 或是另开一个链表元素来装这个值

void *
ngx_list_push(ngx_list_t *l)
{
    void             *elt;
    ngx_list_part_t  *last;

    last = l->last;

     //如果我们要插入的那个数组已经满了
    if (last->nelts == l->nalloc) {

        /* the last part is full, allocate a new list part */

          //继续分配
        last = ngx_palloc(l->pool, sizeof(ngx_list_part_t));
        if (last == NULL) {
            return NULL;
        }

        last->elts = ngx_palloc(l->pool, l->nalloc * l->size);
        if (last->elts == NULL) {
            return NULL;
        }

        last->nelts = 0;
        last->next = NULL;
          //新的数组元素放在链表的末尾
        l->last->next = last;
        l->last = last;
    }
     //返回新值要插入的空间起始地址
    elt = (char *) last->elts + l->size * last->nelts;
    last->nelts++;

    return elt;
}