Nginx erweiterte Datenstruktur-Quellcode-Analyse (2) ----- dynamisches Array

ngx_array_t ist ein sequentieller Container, der in Nginx weit verbreitet ist. Es speichert Elemente in Form eines Arrays und unterstützt die dynamische Änderung der Array-Größe, wenn die Obergrenze der Array-Kapazität erreicht ist. Es ähnelt dem Vektorcontainer in C++ und verfügt über einen integrierten Speicherpool, der von Nginx gekapselt wird. Daher wird der von ihm zugewiesene Speicher auch im Speicherpool angewendet.

ngx_array_t hat die folgenden drei Vorteile:

(1) Schnelle Zugriffsgeschwindigkeit;

(2) Berücksichtigt die Unsicherheit in der Anzahl der Elemente.

(3) Verantwortlich für die Zuweisung des von Elementen belegten Speichers wird über eine einheitliche Verwaltung von Speicherpools verfügen.

Es gibt zwei Möglichkeiten, das dynamische Array zu erweitern:

(1) Wenn der verbleibende Platz im aktuellen Speicherpool Wenn er größer oder gleich dem diesmal benötigten neuen Speicherplatz ist, wird durch diese Erweiterung nur der neue Speicherplatz erweitert.

(2) Wenn der verbleibende Speicherplatz im aktuellen Speicherpool kleiner ist als der Speicherplatz, der dieses Mal hinzugefügt werden muss, dann gilt für die ngx_array_push-Methode die Das ursprüngliche dynamische Array wird verdoppelt, und für ngx_array_push_n wird der Umfang der Erweiterung basierend auf den Parametern und der Kapazität des ursprünglichen dynamischen Arrays bestimmt.

Struktur des dynamischen Arrays:

Initialisierung des dynamischen Arrays:

typedef struct {
    void        *elts;//首地址
    ngx_uint_t   nelts;//已使用的元素个数
    size_t       size;//每个数组元素占用的内存大小
    ngx_uint_t   nalloc;//可以容纳元素的个数的总大小
    ngx_pool_t  *pool;//内存池对象
} ngx_array_t;

Dynamisches Array erstellen:

static ngx_inline ngx_int_t
ngx_array_init(ngx_array_t *array, ngx_pool_t *pool, ngx_uint_t n, size_t size)//初始化数组
{
    /*
     * set "array->nelts" before "array->elts", otherwise MSVC thinks
     * that "array->nelts" may be used without having been initialized
     */

    array->nelts = 0;          //首地址为0
    array->size = size;        //每个元素所占内存大小
    array->nalloc = n;         //分配的元素个数
    array->pool = pool;        //内存池对象
    //申请n*size这么大的内存空间
    array->elts = ngx_palloc(pool, n * size);
    if (array->elts == NULL) {
        return NGX_ERROR;
    }

    return NGX_OK;
}

Dynamisches Array zerstören:

ngx_array_t *
ngx_array_create(ngx_pool_t *p, ngx_uint_t n, size_t size)//创建数组
{
    ngx_array_t *a;

    a = ngx_palloc(p, sizeof(ngx_array_t));//申请数组本身的内存
    if (a == NULL) {
        return NULL;
    }

    if (ngx_array_init(a, p, n, size) != NGX_OK) {//初始化，即申请可以存储元素的内存 
        return NULL;
    }

    return a;
}

Hinzufügen ein Element zum dynamischen Array:

void
ngx_array_destroy(ngx_array_t *a)//销毁数组
{
    ngx_pool_t  *p;

    p = a->pool;

    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;
    }
}<span style="white-space:pre">	</span>

N Elemente zum aktuellen dynamischen Array hinzufügen:

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 = a->size * a->nalloc;

        p = a->pool;

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

void *
ngx_array_push_n(ngx_array_t *a, ngx_uint_t n)//加入n个元素
{
    void        *elt, *new;
    size_t       size;
    ngx_uint_t   nalloc;
    ngx_pool_t  *p;

    size = n * a->size;

    if (a->nelts + n > a->nalloc) {//如果加在一起的个数大于数组元素个数

        /* the array is full */

        p = a->pool;

        if ((u_char *) a->elts + a->size * a->nalloc == p->d.last//等号仍然不知到为什么要判断？？？？
            && p->d.last + size <= p->d.end) //若内存池节点剩余内存可以存放加入的元素
        {
            /*
             * the array allocation is the last in the pool
             * and there is space for new allocation
             */

            p->d.last += size;
            a->nalloc += n;

        } else {
            /* allocate a new array */

            nalloc = 2 * ((n >= a->nalloc) ? n : a->nalloc);//在加入的元素个数和原来数组可存放的元素个数中选择比较大的那个乘以2

            new = ngx_palloc(p, nalloc * a->size);//申请内存
            if (new == NULL) {
                return NULL;
            }

            ngx_memcpy(new, a->elts, a->nelts * a->size);//复制原来的元素
            a->elts = new;                               //更新两个变量
            a->nalloc = nalloc;
        }
    }

    elt = (u_char *) a->elts + a->size * a->nelts;    //可存放元素的内存起始地址
    a->nelts += n;                                    //更新

    return elt;
}

Urheberrechtserklärung: Dieser Artikel ist ein Originalartikel des Bloggers und darf nicht ohne die Erlaubnis des Bloggers reproduziert werden.

Das Obige stellt die erweiterte Nginx-Datenstruktur-Quellcode-Analyse (2) vor, einschließlich Aspekten des Inhalts. Ich hoffe, dass es für Freunde hilfreich sein wird, die sich für PHP-Tutorials interessieren.