菜鸟nginx源代码剖析数据结构篇（七） 哈希表 ngx_hash_t（下）

 

菜鸟nginx源代码剖析数据结构篇（七） 哈希表 ngx_hash_t（下）

 

Author：Echo Chen（陈斌）

Email：chenb19870707@gmail.com

Blog：Blog.csdn.net/chen19870707

Date：Nov 3rd, 2014

在前面一篇文章《菜鸟nginx源代码剖析数据结构篇（六） 哈希表 ngx_hash_t（上）》 里介绍了 普通哈希表 和 带有通配符的哈希表 的基本结构和初始化方法，因为篇幅的原因未能解析完结。这篇继续解源代码中剩余的部分。

1.普通哈希表ngx_hash_t查找 ngx_hash_find

普通哈希表的查找比較简单，思想就是先依据hash值找到相应桶，然后遍历这个桶的每个元素，逐字匹配是否keyword全然同样。全然同样则找到，否则继续，直至找到这个桶的结尾(value = NULL)。

/* @hash 表示哈希表的结构体
 * @key  表示依据哈希方法计算出来的hash值
 * @name 表示实际keyword地址
 * @len  表示实际keyword长度
 */
void *ngx_hash_find(ngx_hash_t *hash, ngx_uint_t key, u_char *name, size_t len)
{
    ngx_uint_t       i;
    ngx_hash_elt_t  *elt;

    //依据hash值找到桶索引
    elt = hash->buckets[key % hash->size];

    if (elt == NULL) {
        return NULL;
    }

    //桶结束的标志为 value 为 NULL
    while (elt->value) {
        //keyword长度不匹配，下一个
        if (len != (size_t) elt->len) {
            goto next;
        }

        //遍历keyword每个字符，若所有对得上，则找到，否则有一个不同下一个
        for (i = 0; i < len; i++) {
            if (name[i] != elt->name[i]) {
                goto next;
            }
        }

        return elt->value;

    next:
        //从eltkeyword開始向后移动keyword长度个。并行对齐，即为下一个ngx_hash_elt_t
        elt = (ngx_hash_elt_t *) ngx_align_ptr(&elt->name[0] + elt->len,
                                               sizeof(void *));
        continue;
    }

    return NULL;
}

2.支持通配符哈希表的前置通配符查找 ngx_hash_find_wc_head

 

还记得上节在ngx_hash_wildcard_init中，用value指针低2位来携带信息吗？其是有特殊意义的。例如以下图所看到的

• 00 - value 是 "example.com" 和 "*.example.com"的数据指针
• 01 - value 不过 "*.example.com"的数据指针
• 10 - value 是 支持通配符哈希表是 "example.com" 和 "*.example.com" 指针
• 11 - value 不过 "*.example.com"的指针
  
  

查找的思路就是依据value的指针信息来搜索，源码例如以下：

 

/* @hwc  表示支持通配符的哈希表的结构体
 * @name 表示实际keyword地址
 * @len  表示实际keyword长度
 */
void *ngx_hash_find_wc_head(ngx_hash_wildcard_t *hwc, u_char *name, size_t len)
{
    void        *value;
    ngx_uint_t   i, n, key;

    n = len;

    //从后往前搜索第一个dot。则n 到 len-1 即为keyword中最后一个 子keyword
    while (n) {
        if (name[n - 1] == '.') {
            break;
        }

        n--;
    }

    key = 0;

    //n 到 len-1 即为keyword中最后一个 子keyword，计算其hash值
    for (i = n; i < len; i++) {
        key = ngx_hash(key, name[i]);
    }

    //调用普通查找找到keyword的value（用户自己定义数据指针）
    value = ngx_hash_find(&hwc->hash, key, &name[n], len - n);

    /**还记得上节在ngx_hash_wildcard_init中。用value指针低2位来携带信息吗？其是有特殊意义的，例如以下：
     * 00 - value 是 "example.com" 和 "*.example.com"的数据指针
     * 01 - value 不过 "*.example.com"的数据指针
     * 10 - value 是 支持通配符哈希表是 "example.com" 和 "*.example.com" 指针
     * 11 - value 不过 "*.example.com"的指针
     */
    if (value)
    {

        if ((uintptr_t) value & 2) {

            //搜索到了最后一个子keyword且没有通配符，如"example.com"的example
            if (n == 0) {
                //value低两位为11，仅为"*.example.com"的指针。这里没有通配符，没招到，返回NULL
                if ((uintptr_t) value & 1) {
                    return NULL;
                }

                //value低两位为10，为"example.com"的指针，value就在下一级的ngx_hash_wildcard_t 的value中，去掉携带的低2位11
                hwc = (ngx_hash_wildcard_t *)
                                          ((uintptr_t) value & (uintptr_t) ~3);
                return hwc->value;
            }

            //还未搜索完，低两位为11或10，继续去下级ngx_hash_wildcard_t中搜索
            hwc = (ngx_hash_wildcard_t *) ((uintptr_t) value & (uintptr_t) ~3);

            //继续搜索 keyword中剩余部分，如"example.com"。搜索 0 到 n -1 即为 example
            value = ngx_hash_find_wc_head(hwc, name, n - 1);

            //若找到，则返回
            if (value)
            {
                return value;
            }

            //低两位为00 找到，即为wc->value
            return hwc->value;
        }

        //低两位为01
        if ((uintptr_t) value & 1)
        {
            //keyword没有通配符，错误返回空
            if (n == 0)
            {
                return NULL;
            }

            //有通配符，直接返回
            return (void *) ((uintptr_t) value & (uintptr_t) ~3);
        }

        //低两位为00。直接返回
        return value;
    }

    return hwc->value;
}

 

3.支持通配符哈希表的后置通配符查找 ngx_hash_find_wc_tail

 

ngx_hash_find_wc_tail与前置通配符查找差点儿相同，这里value低两位仅有两种标志，更加简单：

• 00 - value 是指向 用户自己定义数据
• 11 - value的指向下一个哈希表
  源码例如以下：

void *ngx_hash_find_wc_tail(ngx_hash_wildcard_t *hwc, u_char *name, size_t len)
{
    void        *value;
    ngx_uint_t   i, key;


    key = 0;

    //从前往前搜索第一个dot。则0 到 i 即为keyword中第一个 子keyword
    for (i = 0; i < len; i++)
    {
        if (name[i] == '.')
        {
            break;
        }
        //计算哈希值
        key = ngx_hash(key, name[i]);
    }

    //没有通配符，返回NULL
    if (i == len)
    {
        return NULL;
    }

    //调用普通查找找到keyword的value（用户自己定义数据指针）
    value = ngx_hash_find(&hwc->hash, key, name, i);


    /**还记得上节在ngx_hash_wildcard_init中，用value指针低2位来携带信息吗？其是有特殊意义的，例如以下：
     * 00 - value 是数据指针
     * 11 - value的指向下一个哈希表
     */
    if (value)
    {
        //低2位为11，value的指向下一个哈希表，递归搜索
        if ((uintptr_t) value & 2)
        {

            i++;

            hwc = (ngx_hash_wildcard_t *) ((uintptr_t) value & (uintptr_t) ~3);

            value = ngx_hash_find_wc_tail(hwc, &name[i], len - i);

            //找到低两位00，返回
            if (value)
            {
                return value;
            }

            //找打低两位11，返回hwc->value
            return hwc->value;
        }

        return value;
    }

    //低2位为00。直接返回数据
    return hwc->value;
}

 

 

4.组合哈希表查找 ngx_hash_find_combined

组合哈希表的查找思路很easy，先在普通哈希表中查找。没找到再去前置通配符哈希表中查找，最后去后置通配符哈希表中查找。源码例如以下：

void *ngx_hash_find_combined(ngx_hash_combined_t *hash, ngx_uint_t key, u_char *name,size_t len)
{
    void  *value;

    //在普通hash表中查找
    if (hash->hash.buckets) {
        value = ngx_hash_find(&hash->hash, key, name, len);

        if (value) {
            return value;
        }
    }

    if (len == 0) {
        return NULL;
    }

    //在前置通配符哈希表中查找
    if (hash->wc_head && hash->wc_head->hash.buckets) {
        value = ngx_hash_find_wc_head(hash->wc_head, name, len);

        if (value) {
            return value;
        }
    }

    //在后置通配符哈希表中查找
    if (hash->wc_tail && hash->wc_tail->hash.buckets) {
        value = ngx_hash_find_wc_tail(hash->wc_tail, name, len);

        if (value) {
            return value;
        }
    }

    return NULL;
}

 

 

5.支持通配符哈希表初始化 ngx_hash_wildcard_init

首先看一下ngx_hash_wildcard_init 的内存结构，当构造此类型的hash表的时候，实际上是构造了一个hash表的一个“链表”，是通过hash表中的key“链接”起来的。

比方：对于“*.abc.com”将会构造出2个hash表，第一个hash表中有一个key为com的表项。该表项的value包括有指向第二个hash表的指针。而第二个hash表中有一个表项abc，该表项的value包括有指向*.abc.com相应的value的指针。那么查询的时候，比方查询www.abc.com的时候。先查com。通过查com能够找到第二级的hash表，在第二级hash表中，再查找abc，依次类推，直到在某一级的hash表中查到的表项相应的value相应一个真正的值而非一个指向下一级hash表的指针的时候，查询过程结束。

 

 

理解了这个，我们就能够看源码了，ngx_hash_wildcard是一个递归函数，递归创建如上图的hash链表，例如以下为凝视版源码。

精彩的读点有：

• 因为指针都字节对齐了，低4位肯定为0。这样的操作（name->value = (void *) ((uintptr_t) wdc | (dot ? 3 : 2)) ） 巧妙的使用了指针的低位携带额外信息。节省了内存。让人不得不佩服ngx设计者的想象力。

/*hinit为初始化结构体指针。names为预增加哈希表数组，elts为预增加数组大小
特别要注意的是这里的key已经都是被预处理过的。比如：“*.abc.com”或者“.abc.com”被预处理完毕以后。
变成了“com.abc.”。而“mail.xxx.*”则被预处理为“mail.xxx.”*/
ngx_int_t ngx_hash_wildcard_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names,ngx_uint_t nelts)
{
    size_t                len, dot_len;
    ngx_uint_t            i, n, dot;
    ngx_array_t           curr_names, next_names;
    ngx_hash_key_t       *name, *next_name;
    ngx_hash_init_t       h;
    ngx_hash_wildcard_t  *wdc;

    //初始化暂时动态数组curr_names,curr_names是存放当前keyword的数组
    if (ngx_array_init(&curr_names, hinit->temp_pool, nelts,
                       sizeof(ngx_hash_key_t))
        != NGX_OK)
    {
        return NGX_ERROR;
    }

    //初始化暂时动态数组next_names,next_names是存放keyword去掉后剩余keyword
    if (ngx_array_init(&next_names, hinit->temp_pool, nelts, sizeof(ngx_hash_key_t)) != NGX_OK)
    {
        return NGX_ERROR;
    }

    //遍历 names 数组
    for (n = 0; n < nelts; n = i)
    {
        dot = 0;

        //查找 dot
        for (len = 0; len < names[n].key.len; len++)
        {
            if (names[n].key.data[len] == '.')
            {
                dot = 1;
                break;
            }
        }

        //将keyworddot曾经的keyword放入curr_names
        name = ngx_array_push(&curr_names);
        if (name == NULL) {
            return NGX_ERROR;
        }

        name->key.len = len;
        name->key.data = names[n].key.data;
        name->key_hash = hinit->key(name->key.data, name->key.len);
        name->value = names[n].value;

        dot_len = len + 1;

        //len指向dot后剩余keyword
        if (dot)
        {
            len++;
        }

        next_names.nelts = 0;

        //假设names[n] dot后还有剩余keyword。将剩余keyword放入next_names中
        if (names[n].key.len != len)
        {
            next_name = ngx_array_push(&next_names);
            if (next_name == NULL) {
                return NGX_ERROR;
            }

            next_name->key.len = names[n].key.len - len;
            next_name->key.data = names[n].key.data + len;
            next_name->key_hash = 0;
            next_name->value = names[n].value;

        }

        //假设上面搜索到的keyword没有dot，从n+1遍历names，将keyword比它长的所有放入next_name
        for (i = n + 1; i < nelts; i++)
        {
            //前len个keyword同样
            if (ngx_strncmp(names[n].key.data, names[i].key.data, len) != 0) {
                break;
            }


            if (!dot
                && names[i].key.len > len
                && names[i].key.data[len] != '.')
            {
                break;
            }

            next_name = ngx_array_push(&next_names);
            if (next_name == NULL) {
                return NGX_ERROR;
            }

            next_name->key.len = names[i].key.len - dot_len;
            next_name->key.data = names[i].key.data + dot_len;
            next_name->key_hash = 0;
            next_name->value = names[i].value;

        }

        //假设next_name非空
        if (next_names.nelts)
        {
            h = *hinit;
            h.hash = NULL;

            //递归。创建一个新的哈西表
            if (ngx_hash_wildcard_init(&h, (ngx_hash_key_t *) next_names.elts,next_names.nelts) != NGX_OK)
            {
                return NGX_ERROR;
            }

            wdc = (ngx_hash_wildcard_t *) h.hash;

            //如上图，将用户value值放入新的hash表
            if (names[n].key.len == len)
            {
                wdc->value = names[n].value;
            }

            //并将当前value值指向新的hash表
            name->value = (void *) ((uintptr_t) wdc | (dot ? 3 : 2));

        } else if (dot)
        {
            name->value = (void *) ((uintptr_t) name->value | 1);
        }
    }

    //将最外层hash初始化
    if (ngx_hash_init(hinit, (ngx_hash_key_t *) curr_names.elts,curr_names.nelts) != NGX_OK)
    {
        return NGX_ERROR;
    }

    return NGX_OK;
}

 

6. 哈希键数组初始化 ngx_hash_keys_array_init

 

初始化ngx_hash_keys_arrays_t 结构体。type的取值范围仅仅有两个，NGX_HASH_SMALL表示初始化元素较少，NGX_HASH_LARGE表示初始化元素较多。在向ha中增加时必须调用此方法。

ngx_int_t ngx_hash_keys_array_init(ngx_hash_keys_arrays_t *ha, ngx_uint_t type)
{
    ngx_uint_t  asize;

    if (type == NGX_HASH_SMALL)
    {
        asize = 4;
        ha->hsize = 107;
    }
    else
    {
        asize = NGX_HASH_LARGE_ASIZE;
        ha->hsize = NGX_HASH_LARGE_HSIZE;
    }

    //初始化 存放非通配符keyword的数组
    if (ngx_array_init(&ha->keys, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)
    {
        return NGX_ERROR;
    }

    //初始化 存放前置通配符处理好的keyword 数组
    if (ngx_array_init(&ha->dns_wc_head, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)
    {
        return NGX_ERROR;
    }

    //初始化 存放后置通配符处理好的keyword 数组
    if (ngx_array_init(&ha->dns_wc_tail, ha->temp_pool, asize, sizeof(ngx_hash_key_t))!= NGX_OK)
    {
        return NGX_ERROR;
    }

    /*初始化 二位数组 ，这个数组存放的第一个维度代表的是bucket的编号，
      那么keys_hash[i]中存放的是全部的key算出来的hash值对hsize取模以后的值为i的key。
      如果有3个key,各自是key1,key2和key3如果hash值算出来以后对hsize取模的值都是i，
      那么这三个key的值就顺序存放在keys_hash[i][0],keys_hash[i][1], keys_hash[i][2]。
      该值在调用的过程中用来保存和检測是否有冲突的key值。也就是是否有反复。*/
    ha->keys_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);
    if (ha->keys_hash == NULL)
    {
        return NGX_ERROR;
    }

    // 该数组在调用的过程中用来保存和检測是否有冲突的前向通配符的key值，也就是是否有反复。
    ha->dns_wc_head_hash = ngx_pcalloc(ha->temp_pool,sizeof(ngx_array_t) * ha->hsize);

    if (ha->dns_wc_head_hash == NULL)
    {
        return NGX_ERROR;
    }

    // 该数组在调用的过程中用来保存和检測是否有冲突的后向通配符的key值，也就是是否有反复。
    ha->dns_wc_tail_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);
    if (ha->dns_wc_tail_hash == NULL)
    {
        return NGX_ERROR;
    }

    return NGX_OK;
}

 

7. 向ngx_hash_keys_array中加入keyword

 

ngx_int_t ngx_hash_keys_array_init(ngx_hash_keys_arrays_t *ha, ngx_uint_t type)
{
    ngx_uint_t  asize;

    if (type == NGX_HASH_SMALL)
    {
        asize = 4;
        ha->hsize = 107;
    }
    else
    {
        asize = NGX_HASH_LARGE_ASIZE;
        ha->hsize = NGX_HASH_LARGE_HSIZE;
    }

    //初始化 存放非通配符keyword的数组
    if (ngx_array_init(&ha->keys, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)
    {
        return NGX_ERROR;
    }

    //初始化 存放前置通配符处理好的keyword 数组
    if (ngx_array_init(&ha->dns_wc_head, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)
    {
        return NGX_ERROR;
    }

    //初始化 存放后置通配符处理好的keyword 数组
    if (ngx_array_init(&ha->dns_wc_tail, ha->temp_pool, asize, sizeof(ngx_hash_key_t))!= NGX_OK)
    {
        return NGX_ERROR;
    }

    /*初始化 二位数组 ，这个数组存放的第一个维度代表的是bucket的编号。
      那么keys_hash[i]中存放的是全部的key算出来的hash值对hsize取模以后的值为i的key。
      如果有3个key,各自是key1,key2和key3如果hash值算出来以后对hsize取模的值都是i，
      那么这三个key的值就顺序存放在keys_hash[i][0],keys_hash[i][1], keys_hash[i][2]。
      该值在调用的过程中用来保存和检測是否有冲突的key值。也就是是否有反复。*/
    ha->keys_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);
    if (ha->keys_hash == NULL)
    {
        return NGX_ERROR;
    }

    // 该数组在调用的过程中用来保存和检測是否有冲突的前向通配符的key值。也就是是否有反复。
    ha->dns_wc_head_hash = ngx_pcalloc(ha->temp_pool,sizeof(ngx_array_t) * ha->hsize);

    if (ha->dns_wc_head_hash == NULL)
    {
        return NGX_ERROR;
    }

    // 该数组在调用的过程中用来保存和检測是否有冲突的后向通配符的key值，也就是是否有反复。
    ha->dns_wc_tail_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);
    if (ha->dns_wc_tail_hash == NULL)
    {
        return NGX_ERROR;
    }

    return NGX_OK;
}

-

Echo Chen：Blog.csdn.net/chen19870707

-