Nginx——7

哈希表 ngx_hash_t（下）

1.普通哈希表ngx_hash_t查找 ngx_hash_find

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

   1: /* @hash 表示哈希表的结构体

   2:  * @key  表示根据哈希方法计算出来的hash值

   3:  * @name 表示实际关键字地址

   4:  * @len  表示实际关键字长度

   5:  */

   6: void *ngx_hash_find(ngx_hash_t *hash, ngx_uint_t key, u_char *name, size_t len)

   7: {

   8:     ngx_uint_t       i;

   9:     ngx_hash_elt_t  *elt;

  10:  

  11:     //根据hash值找到桶索引

  12:     elt = hash->buckets[key % hash->size];

  13:  

  14:     if (elt == NULL) {

  15:         return NULL;

  16:     }

  17:  

  18:     //桶结束的标志为 value 为 NULL

  19:     while (elt->value) {

  20:         //关键字长度不匹配，下一个

  21:         if (len != (size_t) elt->len) {

  22:             goto next;

  23:         }

  24:         

  25:         //遍历关键字每一个字符，若全部对得上，则找到，否则有一个不同下一个

  26:         for (i = 0; i < len; i++) {

  27:             if (name[i] != elt->name[i]) {

  28:                 goto next;

  29:             }

  30:         }

  31:  

  32:         return elt->value;

  33:  

  34:     next:

  35:         //从elt关键字开始向后移动关键字长度个，并行对齐，即为下一个ngx_hash_elt_t

  36:         elt = (ngx_hash_elt_t *) ngx_align_ptr(&elt->name[0] + elt->len,

  37:                                                sizeof(void *));

  38:         continue;

  39:     }

  40:  

  41:     return NULL;

  42: }

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的指针信息来搜索，源代码如下：

 

   1: /* @hwc  表示支持通配符的哈希表的结构体

   2:  * @name 表示实际关键字地址

   3:  * @len  表示实际关键字长度

   4:  */

   5: void *ngx_hash_find_wc_head(ngx_hash_wildcard_t *hwc, u_char *name, size_t len)

   6: {

   7:     void        *value;

   8:     ngx_uint_t   i, n, key;

   9:  

  10:     n = len;

  11:     

  12:     //从后往前搜索第一个dot，则n 到 len-1 即为关键字中最后一个 子关键字

  13:     while (n) {

  14:         if (name[n - 1] == '.') {

  15:             break;

  16:         }

  17:  

  18:         n--;

  19:     }

  20:  

  21:     key = 0;

  22:     

  23:     //n 到 len-1 即为关键字中最后一个 子关键字，计算其hash值

  24:     for (i = n; i < len; i++) {

  25:         key = ngx_hash(key, name[i]);

  26:     }

  27:     

  28:     //调用普通查找找到关键字的value（用户自定义数据指针）

  29:     value = ngx_hash_find(&hwc->hash, key, &name[n], len - n);

  30:  

  31:     /**还记得上节在ngx_hash_wildcard_init中，用value指针低2位来携带信息吗？其是有特殊意义的，如下：

  32:      * 00 - value 是 "example.com" 和 "*.example.com"的数据指针

  33:      * 01 - value 仅仅是 "*.example.com"的数据指针

  34:      * 10 - value 是 支持通配符哈希表是 "example.com" 和 "*.example.com" 指针

  35:      * 11 - value 仅仅是 "*.example.com"的指针

  36:      */

  37:     if (value)

  38:     {

  39:  

  40:         if ((uintptr_t) value & 2) {

  41:             

  42:             //搜索到了最后一个子关键字且没有通配符，如"example.com"的example

  43:             if (n == 0) {

  44:                 //value低两位为11，仅为"*.example.com"的指针，这里没有通配符，没招到，返回NULL

  45:                 if ((uintptr_t) value & 1) {

  46:                     return NULL;

  47:                 }

  48:                 

  49:                 //value低两位为10，为"example.com"的指针，value就在下一级的ngx_hash_wildcard_t 的value中，去掉携带的低2位11

  50:                 hwc = (ngx_hash_wildcard_t *)

  51:                                           ((uintptr_t) value & (uintptr_t) ~3);

  52:                 return hwc->value;

  53:             }

  54:             

  55:             //还未搜索完，低两位为11或10，继续去下级ngx_hash_wildcard_t中搜索

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

  57:             

  58:             //继续搜索 关键字中剩余部分，如"example.com"，搜索 0 到 n -1 即为 example

  59:             value = ngx_hash_find_wc_head(hwc, name, n - 1);

  60:  

  61:             //若找到，则返回

  62:             if (value) 

  63:             {

  64:                 return value;

  65:             }

  66:             

  67:             //低两位为00 找到，即为wc->value

  68:             return hwc->value;

  69:         }

  70:  

  71:         //低两位为01

  72:         if ((uintptr_t) value & 1) 

  73:         {

  74:             //关键字没有通配符，错误返回空

  75:             if (n == 0) 

  76:             {

  77:                 return NULL;

  78:             }

  79:             

  80:             //有通配符，直接返回

  81:             return (void *) ((uintptr_t) value & (uintptr_t) ~3);

  82:         }

  83:  

  84:         //低两位为00，直接返回

  85:         return value;

  86:     }

  87:  

  88:     return hwc->value;

  89: }

 

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

 

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

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

   1: void *ngx_hash_find_wc_tail(ngx_hash_wildcard_t *hwc, u_char *name, size_t len)

   2: {

   3:     void        *value;

   4:     ngx_uint_t   i, key;

   5:  

   6:  

   7:     key = 0;

   8:  

   9:     //从前往前搜索第一个dot，则0 到 i 即为关键字中第一个 子关键字

  10:     for (i = 0; i < len; i++)

  11:     {

  12:         if (name[i] == '.')

  13:         {

  14:             break;

  15:         }

  16:         //计算哈希值

  17:         key = ngx_hash(key, name[i]);

  18:     }

  19:  

  20:     //没有通配符，返回NULL

  21:     if (i == len)

  22:     {

  23:         return NULL;

  24:     }

  25:  

  26:     //调用普通查找找到关键字的value（用户自定义数据指针）

  27:     value = ngx_hash_find(&hwc->hash, key, name, i);

  28:  

  29:  

  30:     /**还记得上节在ngx_hash_wildcard_init中，用value指针低2位来携带信息吗？其是有特殊意义的，如下：

  31:      * 00 - value 是数据指针

  32:      * 11 - value的指向下一个哈希表

  33:      */

  34:     if (value)

  35:     {

  36:         //低2位为11，value的指向下一个哈希表，递归搜索

  37:         if ((uintptr_t) value & 2)

  38:         {

  39:  

  40:             i++;

  41:  

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

  43:  

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

  45:  

  46:             //找到低两位00，返回

  47:             if (value) 

  48:             {

  49:                 return value;

  50:             }

  51:             

  52:             //找打低两位11，返回hwc->value

  53:             return hwc->value;

  54:         }

  55:  

  56:         return value;

  57:     }

  58:  

  59:     //低2位为00，直接返回数据

  60:     return hwc->value;

  61: }

 

 

4.组合哈希表查找 ngx_hash_find_combined

组合哈希表的查找思路非常简单，先在普通哈希表中查找，没找到再去前置通配符哈希表中查找，最后去后置通配符哈希表中查找，源代码如下：

   1: void *ngx_hash_find_combined(ngx_hash_combined_t *hash, ngx_uint_t key, u_char *name,size_t len)

   2: {

   3:     void  *value;

   4:     

   5:     //在普通hash表中查找

   6:     if (hash->hash.buckets) {

   7:         value = ngx_hash_find(&hash->hash, key, name, len);

   8:  

   9:         if (value) {

  10:             return value;

  11:         }

  12:     }

  13:  

  14:     if (len == 0) {

  15:         return NULL;

  16:     }

  17:     

  18:     //在前置通配符哈希表中查找

  19:     if (hash->wc_head && hash->wc_head->hash.buckets) {

  20:         value = ngx_hash_find_wc_head(hash->wc_head, name, len);

  21:  

  22:         if (value) {

  23:             return value;

  24:         }

  25:     }

  26:     

  27:     //在后置通配符哈希表中查找

  28:     if (hash->wc_tail && hash->wc_tail->hash.buckets) {

  29:         value = ngx_hash_find_wc_tail(hash->wc_tail, name, len);

  30:  

  31:         if (value) {

  32:             return value;

  33:         }

  34:     }

  35:  

  36:     return NULL;

  37: }

 

 

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设计者的想象力。

   1: /*hinit为初始化结构体指针，names为预加入哈希表数组，elts为预加入数组大小

   2: 特别要注意的是这里的key已经都是被预处理过的。例如：“*.abc.com”或者“.abc.com”被预处理完成以后，

   3: 变成了“com.abc.”。而“mail.xxx.*”则被预处理为“mail.xxx.”*/

   4: ngx_int_t ngx_hash_wildcard_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names,ngx_uint_t nelts)

   5: {

   6:     size_t                len, dot_len;

   7:     ngx_uint_t            i, n, dot;

   8:     ngx_array_t           curr_names, next_names;

   9:     ngx_hash_key_t       *name, *next_name;

  10:     ngx_hash_init_t       h;

  11:     ngx_hash_wildcard_t  *wdc;

  12:  

  13:     //初始化临时动态数组curr_names,curr_names是存放当前关键字的数组

  14:     if (ngx_array_init(&curr_names, hinit->temp_pool, nelts,

  15:                        sizeof(ngx_hash_key_t))

  16:         != NGX_OK)

  17:     {

  18:         return NGX_ERROR;

  19:     }

  20:  

  21:     //初始化临时动态数组next_names,next_names是存放关键字去掉后剩余关键字

  22:     if (ngx_array_init(&next_names, hinit->temp_pool, nelts, sizeof(ngx_hash_key_t)) != NGX_OK)

  23:     {

  24:         return NGX_ERROR;

  25:     }

  26:  

  27:     //遍历 names 数组

  28:     for (n = 0; n < nelts; n = i)

  29:     {

  30:         dot = 0;

  31:  

  32:         //查找 dot

  33:         for (len = 0; len < names[n].key.len; len++)

  34:         {

  35:             if (names[n].key.data[len] == '.')

  36:             {

  37:                 dot = 1;

  38:                 break;

  39:             }

  40:         }

  41:  

  42:         //将关键字dot以前的关键字放入curr_names

  43:         name = ngx_array_push(&curr_names);

  44:         if (name == NULL) {

  45:             return NGX_ERROR;

  46:         }

  47:  

  48:         name->key.len = len;

  49:         name->key.data = names[n].key.data;

  50:         name->key_hash = hinit->key(name->key.data, name->key.len);

  51:         name->value = names[n].value;

  52:  

  53:         dot_len = len + 1;

  54:  

  55:         //len指向dot后剩余关键字

  56:         if (dot)

  57:         {

  58:             len++;

  59:         }

  60:  

  61:         next_names.nelts = 0;

  62:  

  63:         //如果names[n] dot后还有剩余关键字，将剩余关键字放入next_names中

  64:         if (names[n].key.len != len)

  65:         {

  66:             next_name = ngx_array_push(&next_names);

  67:             if (next_name == NULL) {

  68:                 return NGX_ERROR;

  69:             }

  70:  

  71:             next_name->key.len = names[n].key.len - len;

  72:             next_name->key.data = names[n].key.data + len;

  73:             next_name->key_hash = 0;

  74:             next_name->value = names[n].value;

  75:  

  76:         }

  77:  

  78:         //如果上面搜索到的关键字没有dot，从n+1遍历names，将关键字比它长的全部放入next_name

  79:         for (i = n + 1; i < nelts; i++)

  80:         {

  81:             //前len个关键字相同

  82:             if (ngx_strncmp(names[n].key.data, names[i].key.data, len) != 0) {

  83:                 break;

  84:             }

  85:  

  86:  

  87:             if (!dot

  88:                 && names[i].key.len > len

  89:                 && names[i].key.data[len] != '.')

  90:             {

  91:                 break;

  92:             }

  93:  

  94:             next_name = ngx_array_push(&next_names);

  95:             if (next_name == NULL) {

  96:                 return NGX_ERROR;

  97:             }

  98:  

  99:             next_name->key.len = names[i].key.len - dot_len;

 100:             next_name->key.data = names[i].key.data + dot_len;

 101:             next_name->key_hash = 0;

 102:             next_name->value = names[i].value;

 103:  

 104:         }

 105:  

 106:         //如果next_name非空

 107:         if (next_names.nelts)

 108:         {

 109:             h = *hinit;

 110:             h.hash = NULL;

 111:  

 112:             //递归，创建一个新的哈西表

 113:             if (ngx_hash_wildcard_init(&h, (ngx_hash_key_t *) next_names.elts,next_names.nelts) != NGX_OK)

 114:             {

 115:                 return NGX_ERROR;

 116:             }

 117:  

 118:             wdc = (ngx_hash_wildcard_t *) h.hash;

 119:             

 120:             //如上图，将用户value值放入新的hash表

 121:             if (names[n].key.len == len)

 122:             {

 123:                 wdc->value = names[n].value;

 124:             }

 125:             

 126:             //并将当前value值指向新的hash表

 127:             name->value = (void *) ((uintptr_t) wdc | (dot ? 3 : 2));

 128:  

 129:         } else if (dot)

 130:         {

 131:             name->value = (void *) ((uintptr_t) name->value | 1);

 132:         }

 133:     }

 134:  

 135:     //将最外层hash初始化

 136:     if (ngx_hash_init(hinit, (ngx_hash_key_t *) curr_names.elts,curr_names.nelts) != NGX_OK)

 137:     {

 138:         return NGX_ERROR;

 139:     }

 140:  

 141:     return NGX_OK;

 142: }

 

6. 哈希键数组初始化 ngx_hash_keys_array_init

 

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

   1: ngx_int_t ngx_hash_keys_array_init(ngx_hash_keys_arrays_t *ha, ngx_uint_t type)

   2: {

   3:     ngx_uint_t  asize;

   4:  

   5:     if (type == NGX_HASH_SMALL)

   6:     {

   7:         asize = 4;

   8:         ha->hsize = 107;

   9:     }

  10:     else

  11:     {

  12:         asize = NGX_HASH_LARGE_ASIZE;

  13:         ha->hsize = NGX_HASH_LARGE_HSIZE;

  14:     }

  15:  

  16:     //初始化 存放非通配符关键字的数组

  17:     if (ngx_array_init(&ha->keys, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)

  18:     {

  19:         return NGX_ERROR;

  20:     }

  21:  

  22:     //初始化 存放前置通配符处理好的关键字 数组

  23:     if (ngx_array_init(&ha->dns_wc_head, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)

  24:     {

  25:         return NGX_ERROR;

  26:     }

  27:  

  28:     //初始化 存放后置通配符处理好的关键字 数组

  29:     if (ngx_array_init(&ha->dns_wc_tail, ha->temp_pool, asize, sizeof(ngx_hash_key_t))!= NGX_OK)

  30:     {

  31:         return NGX_ERROR;

  32:     }

  33:  

  34:     /*初始化 二位数组 ，这个数组存放的第一个维度代表的是bucket的编号，

  35:       那么keys_hash[i]中存放的是所有的key算出来的hash值对hsize取模以后的值为i的key。

  36:       假设有3个key,分别是key1,key2和key3假设hash值算出来以后对hsize取模的值都是i，

  37:       那么这三个key的值就顺序存放在keys_hash[i][0],keys_hash[i][1], keys_hash[i][2]。

  38:       该值在调用的过程中用来保存和检测是否有冲突的key值，也就是是否有重复。*/

  39:     ha->keys_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);

  40:     if (ha->keys_hash == NULL)

  41:     {

  42:         return NGX_ERROR;

  43:     }

  44:  

  45:     // 该数组在调用的过程中用来保存和检测是否有冲突的前向通配符的key值，也就是是否有重复。

  46:     ha->dns_wc_head_hash = ngx_pcalloc(ha->temp_pool,sizeof(ngx_array_t) * ha->hsize);

  47:  

  48:     if (ha->dns_wc_head_hash == NULL)

  49:     {

  50:         return NGX_ERROR;

  51:     }

  52:  

  53:     // 该数组在调用的过程中用来保存和检测是否有冲突的后向通配符的key值，也就是是否有重复。

  54:     ha->dns_wc_tail_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);

  55:     if (ha->dns_wc_tail_hash == NULL)

  56:     {

  57:         return NGX_ERROR;

  58:     }

  59:  

  60:     return NGX_OK;

  61: }

 

7. 向ngx_hash_keys_array中添加关键字

 

   1: ngx_int_t ngx_hash_keys_array_init(ngx_hash_keys_arrays_t *ha, ngx_uint_t type)

   2: {

   3:     ngx_uint_t  asize;

   4:  

   5:     if (type == NGX_HASH_SMALL)

   6:     {

   7:         asize = 4;

   8:         ha->hsize = 107;

   9:     }

  10:     else

  11:     {

  12:         asize = NGX_HASH_LARGE_ASIZE;

  13:         ha->hsize = NGX_HASH_LARGE_HSIZE;

  14:     }

  15:  

  16:     //初始化 存放非通配符关键字的数组

  17:     if (ngx_array_init(&ha->keys, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)

  18:     {

  19:         return NGX_ERROR;

  20:     }

  21:  

  22:     //初始化 存放前置通配符处理好的关键字 数组

  23:     if (ngx_array_init(&ha->dns_wc_head, ha->temp_pool, asize, sizeof(ngx_hash_key_t)) != NGX_OK)

  24:     {

  25:         return NGX_ERROR;

  26:     }

  27:  

  28:     //初始化 存放后置通配符处理好的关键字 数组

  29:     if (ngx_array_init(&ha->dns_wc_tail, ha->temp_pool, asize, sizeof(ngx_hash_key_t))!= NGX_OK)

  30:     {

  31:         return NGX_ERROR;

  32:     }

  33:  

  34:     /*初始化 二位数组 ，这个数组存放的第一个维度代表的是bucket的编号，

  35:       那么keys_hash[i]中存放的是所有的key算出来的hash值对hsize取模以后的值为i的key。

  36:       假设有3个key,分别是key1,key2和key3假设hash值算出来以后对hsize取模的值都是i，

  37:       那么这三个key的值就顺序存放在keys_hash[i][0],keys_hash[i][1], keys_hash[i][2]。

  38:       该值在调用的过程中用来保存和检测是否有冲突的key值，也就是是否有重复。*/

  39:     ha->keys_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);

  40:     if (ha->keys_hash == NULL)

  41:     {

  42:         return NGX_ERROR;

  43:     }

  44:  

  45:     // 该数组在调用的过程中用来保存和检测是否有冲突的前向通配符的key值，也就是是否有重复。

  46:     ha->dns_wc_head_hash = ngx_pcalloc(ha->temp_pool,sizeof(ngx_array_t) * ha->hsize);

  47:  

  48:     if (ha->dns_wc_head_hash == NULL)

  49:     {

  50:         return NGX_ERROR;

  51:     }

  52:  

  53:     // 该数组在调用的过程中用来保存和检测是否有冲突的后向通配符的key值，也就是是否有重复。

  54:     ha->dns_wc_tail_hash = ngx_pcalloc(ha->temp_pool, sizeof(ngx_array_t) * ha->hsize);

  55:     if (ha->dns_wc_tail_hash == NULL)

  56:     {

  57:         return NGX_ERROR;

  58:     }

  59:  

  60:     return NGX_OK;

  61: }

-

Echo Chen：Blog.csdn.net/chen19870707

-