nginx源码分析之hash的实现

  nginx实现了自己的hash数据结构,正如数据结构中讲述的那样,nginx用开放链表法解决冲突,不过不同的是一旦一个hash表被初始化后就不会被修改,即插入和删除,只进行查询操作,所以nginx通过计算初始化时key的个数来确定hash表中桶的个数和每个桶的容量,这样能最大限度的利用内存资源。虽然用开放链表法,实际上每个桶都是一块连续的内存空间。nginx实现了两类hash结构,一类是key中包含通配符的ngx_hash_wildcard_t,另一类则是key中不包含通配符的ngx_hash_t,这里的通配符指*号。之所以会有这两类hash,是因为nginx主要用hash来存放url与ip的对应关系,目的是为了通过url来查找ip,而url是可以用通配符表示的,如*.baidu.com。接下来先通过深入到nginx源码中看看hash中定义的数据结构,然后看看两类hash是怎样实现的,最后通过一个例子来使用这两类hash。

1 相关的数据结构

1.1 ngx_hash_t结构

  这类hash的数据结构定义如下:

 1 typedef struct {
 2     void             *value;  //ip,也就是<key,value>中的key
 3     u_short           len;  //url长度
 4     u_char            name[1];  //url,也就是<key,value>中的value
 5 } ngx_hash_elt_t;
 6 
 7 
 8 typedef struct {
 9     ngx_hash_elt_t  **buckets;  //每个桶的起始地址
10     ngx_uint_t        size;  //桶的个数
11 } ngx_hash_t;

  ngx_hash_t结构管理这个hash,ngx_hash_elt_t是hash桶中一个元素的表示。ngx_hash_elt_t字段中的value既可以指向实际的ip,也可以指向另一个hash表(这种情况只能出现在包含通配符的hash中),name字段既可以指向完整的url,也可以指向url的一部分(这种情况也只能出现在包含通配符的hash中)。

1.2 ngx_hash_wildcard_t

  这个结构主要用于包含通配符的hash的,具体如下:

1 typedef struct {
2     ngx_hash_t        hash;
3     void             *value;
4 } ngx_hash_wildcard_t;

  这个结构相比ngx_hash_t结构就是多了一个value指针,value这个字段是用来存放某个已经达到末尾的通配符url对应的value值,如果通配符url没有达到末尾,这个字段为NULL。

1.3 ngx_hash_init_t

  ngx_hash_init_t结构主要用于提供创建一个hash所需要的一些信息,定义如下:

 1 typedef struct {
 2     ngx_hash_t       *hash;  //指向待新建的hash表
 3     ngx_hash_key_pt   key;  //hash函数指针
 4 
 5     ngx_uint_t        max_size;  //hash表中桶的最大值,实际桶的个数存放在前面ngx_hash_t中的size字段中
 6     ngx_uint_t        bucket_size;  //每个桶的最大尺寸
 7 
 8     char             *name;  //hash表的名字,其实没啥用(在log中用)
 9     ngx_pool_t       *pool;  //构建hash所用的内存池
10     ngx_pool_t       *temp_pool;  //构建hash所用的临时内存池
11 } ngx_hash_init_t;

  hash字段如果为NULL的话,会动态创建管理hash的结构ngx_hash_t,这种情况通常在包含通配符的情况下使用;如果不为NULL,则使用这个字段指向的ngx_hash_t结构,这种情况通常在不包含通配符的情况下使用。

1.4 ngx_hash_key_t

  ngx_hash_key_t结构主要用于初始化hash表的,正如前面说的,nginx只能一次性的初始化,初始化之后就不能插入和修改了,所以用一个ngx_table_elt_t结构的数组来存放要插入到hash中的所有<key,value>对,所有初始化hash的函数都需要根据这样一个数组来初始化hash,这个在后面初始化hash函数的时候可以看到。

1 typedef struct {
2     ngx_str_t         key;  //<key,value>中的key
3     ngx_uint_t        key_hash;  //key通过hash函数算出的hash值
4     void             *value;  //<key,value>中的value
5 } ngx_hash_key_t;

1.5 ngx_hash_combined_t

1 typedef struct {
2     ngx_hash_t            hash;
3     ngx_hash_wildcard_t  *wc_head;
4     ngx_hash_wildcard_t  *wc_tail;
5 } ngx_hash_combined_t;

  这个结构包含了三类hash,hash字段表示不保护通配符的hash,wc_head字段表示包含前缀通配符的hash,wc_tail表示包含后缀通配符的hash。由于用户配置的url通常会是是不包含通配符的url,包含前缀通配符的url和包含后缀通配符的rul中的一种或多种,所以一般使用这个结构来完全表示用户配置的url。

1.6 ngx_hash_keys_arrays_t

 1 typedef struct {
 2     ngx_uint_t        hsize;
 3     ngx_pool_t       *pool;
 4     ngx_pool_t       *temp_pool;  
 5 
 6     ngx_array_t       keys;  //存放不包含通配符的<key,value>键值对
 7     ngx_array_t      *keys_hash;  //用来检测冲突的
 8 
 9     ngx_array_t       dns_wc_head;  //存放包含前缀通配符的<key,value>键值对
10     ngx_array_t      *dns_wc_head_hash;  //用来检测冲突的
11 
12     ngx_array_t       dns_wc_tail;  //存放包含后缀通配符的<key,value>键值对
13     ngx_array_t      *dns_wc_tail_hash; //用来检测冲突的
14 } ngx_hash_keys_arrays_t;

  这个结构存放了初始化hash需要的所有键值对,keys数组用来初始化不包含通配符的hash,dns_wc_head数组用来初始化包含前缀通配符的hash,dns_wc_tail数组用来初始化包含后缀通配符的hash,并且dns_wc_head和dns_wc_tail数组包含的<key,value>键值对中的key都是已经去掉通配符的key,具体情况在后面ngx_hash_add_key函数的介绍中会详细说明。

2 相关函数

2.1 ngx_hash_init

  这个函数用来初始化不包含通配符的hash,函数原型如下:

1 ngx_int_t
2 ngx_hash_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names, ngx_uint_t nelts)

  hinit参数是初始化hash的相关信息,names存放了所有需要插入到hash中的<key,value>对,nelts是<key,value>对的个数。这个函数主要做了4部分的工作:

  (1)检查bucket_size是否合法,也就是它的值必须保证一个桶至少能存放一个<key,value>键值对,具体如下:

 1 #define NGX_HASH_ELT_SIZE(name)                                               \
 2     (sizeof(void *) + ngx_align((name)->key.len + 2, sizeof(void *)))
 3 
 4 for (n = 0; n < nelts; n++) {
 5         if (hinit->bucket_size < NGX_HASH_ELT_SIZE(&names[n]) + sizeof(void *))
 6         {
 7             ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,
 8                           "could not build the %s, you should "
 9                           "increase %s_bucket_size: %i",
10                           hinit->name, hinit->name, hinit->bucket_size);
11             return NGX_ERROR;
12         }
13     }

  上面的for循环保证hash的桶至少能装一个<key,value>键值对,宏NGX_HASH_ELT_SIZE用来计算一个ngx_hash_key_t表示一个实际的<key,value>键值对占用内存的大小,之所以NGX_HASH_ELT_SIZE(&names[n]) 后面需要加上sizeof(void *),主要是每个桶都用一个值位NULL的void*指针来标记结束。

  (2)计算hash中桶的个数

 1     bucket_size = hinit->bucket_size - sizeof(void *);  //除去桶标记后桶的大小
 2     start = nelts / (bucket_size / (2 * sizeof(void *)));  //桶的最小个数
 3     start = start ? start : 1;
 4     if (hinit->max_size > 10000 && nelts && hinit->max_size / nelts < 100) {
 5         start = hinit->max_size - 1000;
 6     }
 7     //更新size来满足bucket_size
 8     for (size = start; size < hinit->max_size; size++) {
 9         ngx_memzero(test, size * sizeof(u_short));
10         for (n = 0; n < nelts; n++) {
11             if (names[n].key.data == NULL) {
12                 continue;
13             }
14             key = names[n].key_hash % size;  //计算当前<key,value>在哪个桶
15             test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));  //计算当前<key,value>插入到桶之后桶的大小
16 
17             if (test[key] > (u_short) bucket_size) {  //检查桶是否溢出了
18                 goto next;
19             }
20         }
21         goto found;
22     next:
23         continue;
24     

  从最小桶的个数开始递增,直到所有的<key,value>键值对都能存放在对应的桶中不溢出,那当前的桶个数就是需要的桶个数。

   (3)计算新创建的hash所占用的空间,并调用内存分配函数分配这些空间

 1     for (i = 0; i < size; i++) {
 2         test[i] = sizeof(void *);
 3     }
 4   //计算每个桶的实际大小
 5     for (n = 0; n < nelts; n++) {
 6         if (names[n].key.data == NULL) {
 7             continue;
 8         }
 9 
10         key = names[n].key_hash % size;
11         test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
12     }
13   //计算所有桶的大小
14     len = 0;
15 
16     for (i = 0; i < size; i++) {
17         if (test[i] == sizeof(void *)) {
18             continue;
19         }
20 
21         test[i] = (u_short) (ngx_align(test[i], ngx_cacheline_size));  //每个桶大小满足cache行对齐
22 
23         len += test[i];
24     }

  上面根据实际的<key,value>键值对来实际计算每个桶的大小,而不是所有桶的大小的设置成一样的,这样能很有效的节约内存空间,当然由于每个桶的大小是不固定的,所有每个桶的末尾需要一个额外空间(大小为sizeof(void*))来标记桶的结束。并且每个桶大小满足cache行对齐,这样能加快访问速度,从这里也可以看出nginx无处不在优化程序的性能和资源的使用效率。

 1     if (hinit->hash == NULL) {  //hash为NULL,则动态生成管理hash的结构
 2         //calloc会把获取的内存初始化为0
 3         hinit->hash = ngx_pcalloc(hinit->pool, sizeof(ngx_hash_wildcard_t)
 4                                              + size * sizeof(ngx_hash_elt_t *));
 5         if (hinit->hash == NULL) {
 6             ngx_free(test);
 7             return NGX_ERROR;
 8         }
 9 
10         buckets = (ngx_hash_elt_t **)
11                       ((u_char *) hinit->hash + sizeof(ngx_hash_wildcard_t));
12 
13     } else {
14         buckets = ngx_pcalloc(hinit->pool, size * sizeof(ngx_hash_elt_t *));
15         if (buckets == NULL) {
16             ngx_free(test);
17             return NGX_ERROR;
18         }
19     }
20 
21     elts = ngx_palloc(hinit->pool, len + ngx_cacheline_size);  //将所有桶占用的空间分配在连续的内存空间中
22     if (elts == NULL) {
23         ngx_free(test);
24         return NGX_ERROR;
25     }
26 
27     elts = ngx_align_ptr(elts, ngx_cacheline_size);
28 
29     for (i = 0; i < size; i++) {
30         if (test[i] == sizeof(void *)) {
31             continue;
32         }
33 
34         buckets[i] = (ngx_hash_elt_t *) elts;  //初始化每个桶的起始位置
35         elts += test[i];
36 
37     }

  上面代码先动态分配每个桶的起始指针,然后动态分配所有桶的空间,然后根据每个桶的大小,将每个桶的起始指针初始化指向对应桶的起始地址。

  (4)将每个<key,value>键值对复制到所在的桶中

 1     for (i = 0; i < size; i++) {
 2         test[i] = 0;
 3     }
 4 
 5     for (n = 0; n < nelts; n++) {
 6         if (names[n].key.data == NULL) {
 7             continue;
 8         }
 9 
10         key = names[n].key_hash % size;  //计算当前<key,value>所在的桶
11         elt = (ngx_hash_elt_t *) ((u_char *) buckets[key] + test[key]);  //计算当前<key,value>所在桶中的位置
12         //将当前<key,value>的值复制到桶中
13         elt->value = names[n].value;
14         elt->len = (u_short) names[n].key.len;
15 
16         ngx_strlow(elt->name, names[n].key.data, names[n].key.len);
17         test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));  //更新当前桶的大小
18     }
19     //为了标记每个桶的结束
20     for (i = 0; i < size; i++) {
21         if (buckets[i] == NULL) {
22             continue;
23         }
24 
25         elt = (ngx_hash_elt_t *) ((u_char *) buckets[i] + test[i]);
26 
27         elt->value = NULL;  //前面每个test加上sizeof(void *)就是为了这个value指针
28     }

   通过调用ngx_hash_init函数,一个hash就建立起来了,该hash大概的情况如下图所示:

2.2 ngx_hash_add_key

1 ngx_int_t
2 ngx_hash_add_key(ngx_hash_keys_arrays_t *ha, ngx_str_t *key, void *value,
3     ngx_uint_t flags)

  ha中包含了三类ngx_hash_key_t类型的数组,分别用来初始化三类hash(介绍ngx_hash_keys_arrays_t时已说明),那么新的<key,value>应该加入到哪个数组中就是ngx_hash_add_key这个函数的主要任务。参数中的flags用来标记是否key中可能包含通配符,一般这个参数设置为NGX_HASH_WILDCARD_KEY,即可能包含通配符。需要注意的是这个函数会改变包含通配符的key,将通配符去掉,如*.baidu.com会改变为com.baidu.,.baidu.com会改变为com.baidu,www.baidu.*会改变为www.baidu,www.baidu.这种通配是不允许出现的。

2.3 ngx_hash_find

1 void *
2 ngx_hash_find(ngx_hash_t *hash, ngx_uint_t key, u_char *name, size_t len)

  这个函数通过给定的key和name在hash表中查找对应的<name,value>键值对,并将查找到的value值返回,参数中的key是name通过hash计算出来的。这个函数的实现很简单,就是通过key找到要查找的键值对在哪个桶中,然后遍历这个桶中的每个元素找key等于name的元素。

2.4 ngx_hash_wildcard_init

1 ngx_int_t
2 ngx_hash_wildcard_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names,
3     ngx_uint_t nelts)

  这个函数是nginx实现通配hash的关键所在,该函数通过对通配键值对建立多级hash来实现通配hash。实现的hash表大致如下图所示:

 

  上面的图只显示了二级hash,实际上可以由多级hash。下面我们举个实际的例子来加深理解,假设有下面这些键值对:

  <*.com, "220.181.111.147">,<*.baidu.com, "220.181.111.147">,<*.baidu.com.cn, "220.181.111.147">,<*.google.com,"58.63.236.35">

  (1)通过函数ngx_hash_add_key将上面的键值对加入到ngx_hash_keys_arrays_t结构中的dns_wc_head数组中,该数组的值如下图所示:

  {key = ("com." , 4 ), key_hash = 0 , value = "220.181.111.147"}
  {key = ("cn.com.baidu." , 13), key_hash = 0 , value = "220.181.111.147"}
  {key = ("com.baidu." , 10), key_hash = 0 , value = "220.181.111.147"}
    {key = ("com.google." , 11), key_hash = 0 , value = "58.63.236.35"}

  (2)将上面的dns_wc_head数组传递给ngx_hash_wildcard_init,生成的hash如下图所示:

   现在来看下ngx_hash_wildcard_init是怎样实现上面图所示的多级hash结构的。

 1     for (n = 0; n < nelts; n = i) {
 2 
 3         dot = 0;
 4         //以.作为字段的分隔符
 5         for (len = 0; len < names[n].key.len; len++) {
 6             if (names[n].key.data[len] == '.') {
 7                 dot = 1;
 8                 break;
 9             }
10         }
11      
12         name = ngx_array_push(&curr_names);
13         if (name == NULL) {
14             return NGX_ERROR;
15         }
16         //将上面获取的字段作为当前hash的key
17         name->key.len = len;
18         name->key.data = names[n].key.data;
19         name->key_hash = hinit->key(name->key.data, name->key.len);
20         name->value = names[n].value;
21 
22         dot_len = len + 1;
23 
24         if (dot) {
25             len++;
26         }
27       //收集同一前缀的所有后缀
28         next_names.nelts = 0;
29 
30         if (names[n].key.len != len) {
31             next_name = ngx_array_push(&next_names);
32             if (next_name == NULL) {
33                 return NGX_ERROR;
34             }
35             
36             next_name->key.len = names[n].key.len - len;
37             next_name->key.data = names[n].key.data + len;
38             next_name->key_hash = 0;
39             next_name->value = names[n].value;
40         }
41 
42         for (i = n + 1; i < nelts; i++) {
43             if (ngx_strncmp(names[n].key.data, names[i].key.data, len) != 0) {
44                 break;
45             }
46 
47             if (!dot
48                 && names[i].key.len > len
49                 && names[i].key.data[len] != '.')
50             {
51                 break;
52             }
53 
54             next_name = ngx_array_push(&next_names);
55             if (next_name == NULL) {
56                 return NGX_ERROR;
57             }
58 
59             next_name->key.len = names[i].key.len - dot_len;
60             next_name->key.data = names[i].key.data + dot_len;
61             next_name->key_hash = 0;
62             next_name->value = names[i].value;
63         }
64 
65         if (next_names.nelts) {  //next_names中有元素
66 
67             h = *hinit;
68             h.hash = NULL;  
69             //递归建立当前字段的所有后缀字段组成的hash
70             if (ngx_hash_wildcard_init(&h, (ngx_hash_key_t *) next_names.elts,
71                                        next_names.nelts)
72                 != NGX_OK)
73             {
74                 return NGX_ERROR;
75             }
76 
77             wdc = (ngx_hash_wildcard_t *) h.hash;
78 
79             if (names[n].key.len == len) {  //当前字段已经达到末尾
80                 wdc->value = names[n].value;
81             }
82             //将后缀组成的下一级hash地址作为当前字段的value保存下来
83             name->value = (void *) ((uintptr_t) wdc | (dot ? 3 : 2));   //2只有在后缀通配符的情况下才会出现
84 
85         } else if (dot) {  //只有一个,而且不是后缀通配符
86             name->value = (void *) ((uintptr_t) name->value | 1);
87         }
88     }
89      //根据<当前字段,value>键值对建立hash
90     if (ngx_hash_init(hinit, (ngx_hash_key_t *) curr_names.elts,
91                       curr_names.nelts)
92         != NGX_OK)
93     {
94         return NGX_ERROR;
95     }
96 
97     return NGX_OK;
98 }

  怎样标记一个键值对<key,value>中的value是指向实际的value,还是指向下一级的hash地址,这是上面代码实现的一个巧妙的地方。由于每个hash表的地址或者实际value的地址都是以4字节对齐的,所以这些地址的低2位都是0,这样通过这两位的标记可以很好地解决这个问题。

2.5 ngx_hash_find_wc_head

1 void *
2 ngx_hash_find_wc_head(ngx_hash_wildcard_t *hwc, u_char *name, size_t len)

  这个函数根据name在前缀通配符hash中查找对应的value值。有了hash表后,查找是件相对更容易的事,从后往前的获取name的每个字段(根据.分割),用每个字段查hash表,如果获取的value值的标记存在下一级hash,则用同样的方法查下一个字段对应的hash表,就这样直到查到的value为真实的值为止。另一个通配符查找函数ngx_hash_find_wc_tail这是同样的原理,不同的是对name从前往后处理每个字段而已。

3 测试

  测试的程序主要是使用nginx实现的数据结构和函数,先通过下列url和ip建立hash,然后对给定的url查找ip。

  (1)测试的数据如下:

 1 static ngx_str_t urls[Max_Num] = {
 2     ngx_string("*.com"),  //220.181.111.147
 3     ngx_string("*.baidu.com.cn"),
 4     ngx_string("*.baidu.com"),
 5     ngx_string(".baidu.com"),
 6     ngx_string("*.google.com"),
 7     ngx_string("www.sina.com.cn"),  //58.63.236.35
 8     ngx_string("www.google.com"),  //74.125.71.105
 9     ngx_string("www.qq.com"),  //60.28.14.190
10     ngx_string("www.163.com"),  //123.103.14.237
11     ngx_string("www.sohu.com"),  //219.234.82.50
12     ngx_string("abo321.org"),  //117.40.196.26
13     ngx_string(".abo321.org"),  //117.40.196.26
14     ngx_string("www.abo321.*")  //117.40.196.26
15 };
16 
17 static ngx_str_t values[Max_Num] = {
18     ngx_string("220.181.111.147"),
19     ngx_string("220.181.111.147"),
20     ngx_string("220.181.111.147"),
21     ngx_string("220.181.111.147"),
22     ngx_string("220.181.111.147"),
23     ngx_string("58.63.236.35"),
24     ngx_string("74.125.71.105"),
25     ngx_string("60.28.14.190"),
26     ngx_string("123.103.14.237"),
27     ngx_string("219.234.82.50"),
28     ngx_string("117.40.196.26"),
29     ngx_string("117.40.196.26"),
30     ngx_string("117.40.196.26")
31 };

  (2)测试代码为:https://github.com/cc1989/nginx_report/tree/master/nginx_test/hash

  (3)测试结果

 

  1 --------------------------------
  2 create a new pool:
  3 --------------------------------
  4 pool = 0x810d020
  5   .d
  6     .last = 0x810d048
  7     .end = 0x810d420
  8     .next = (nil)
  9     .failed = 0
 10   .max = 984
 11   .current = 0x810d020
 12   .chain = (nil)
 13   .large = (nil)
 14   .cleanup = (nil)
 15   .log = 0x8051518
 16 available pool memory = 984
 17 
 18 --------------------------------
 19 create and add urls to it:
 20 --------------------------------
 21 array = 0xbfed53b4
 22   .elts = 0xb7542008
 23   .nelts = 6
 24   .size = 16
 25   .nalloc = 16384
 26   .pool = 0x810d450
 27   elements:
 28     0xb7542008: {key = ("www.sina.com.cn", 15), key_hash = 1528635686 , value = "58.63.236.35"   }
 29     0xb7542018: {key = ("www.google.com" , 14), key_hash = -702889725 , value = "74.125.71.105"  }
 30     0xb7542028: {key = ("www.qq.com"     , 10), key_hash = 203430122  , value = "60.28.14.190"   }
 31     0xb7542038: {key = ("www.163.com"    , 11), key_hash = -640386838 , value = "123.103.14.237" }
 32     0xb7542048: {key = ("www.sohu.com"   , 12), key_hash = 1313636595 , value = "219.234.82.50"  }
 33     0xb7542058: {key = ("abo321.org"     , 10), key_hash = 1050805370 , value = "117.40.196.26"  }
 34 
 35 array = 0xbfed53cc
 36   .elts = 0xb7501008
 37   .nelts = 4
 38   .size = 16
 39   .nalloc = 16384
 40   .pool = 0x810d450
 41   elements:
 42     0xb7501008: {key = ("com."           , 4 ), key_hash = 0          , value = "220.181.111.147"}
 43     0xb7501018: {key = ("cn.com.baidu."  , 13), key_hash = 0          , value = "220.181.111.147"}
 44     0xb7501028: {key = ("com.baidu."     , 10), key_hash = 0          , value = "220.181.111.147"}
 45     0xb7501038: {key = ("com.google."    , 11), key_hash = 0          , value = "220.181.111.147"}
 46 
 47 array = 0xbfed53e4
 48   .elts = 0xb74c0008
 49   .nelts = 1
 50   .size = 16
 51   .nalloc = 16384
 52   .pool = 0x810d450
 53   elements:
 54     0xb74c0008: {key = ("www.abo321"     , 10), key_hash = 0          , value = "117.40.196.26"  }
 55 
 56 --------------------------------
 57 the pool:
 58 --------------------------------
 59 pool = 0x810d020
 60   .d
 61     .last = 0x810d2a9
 62     .end = 0x810d420
 63     .next = (nil)
 64     .failed = 0
 65   .max = 984
 66   .current = 0x810d020
 67   .chain = (nil)
 68   .large = (nil)
 69   .cleanup = (nil)
 70   .log = 0x8051518
 71 available pool memory = 375
 72 
 73 array = 0xbfed53cc
 74   .elts = 0xb7501008
 75   .nelts = 4
 76   .size = 16
 77   .nalloc = 16384
 78   .pool = 0x810d450
 79   elements:
 80     0xb7501008: {key = ("cn.com.baidu."  , 13), key_hash = 0          , value = "220.181.111.147"}
 81     0xb7501018: {key = ("com."           , 4 ), key_hash = 0          , value = "220.181.111.147"}
 82     0xb7501028: {key = ("com.baidu."     , 10), key_hash = 0          , value = "220.181.111.147"}
 83     0xb7501038: {key = ("com.google."    , 11), key_hash = 0          , value = "220.181.111.147"}
 84 
 85 array = 0xbfed53e4
 86   .elts = 0xb74c0008
 87   .nelts = 1
 88   .size = 16
 89   .nalloc = 16384
 90   .pool = 0x810d450
 91   elements:
 92     0xb74c0008: {key = ("www.abo321"     , 10), key_hash = 0          , value = "117.40.196.26"  }
 93 
 94 --------------------------------
 95 the hash:
 96 --------------------------------
 97 hash = 0xbfed53fc: **buckets = 0x810d2ac, size = 3
 98   0x810d2ac: buckets[0] = 0x810d2c0
 99   0x810d2b0: buckets[1] = 0x810d300
100   0x810d2b4: buckets[2] = 0x810d320
101 
102   key 1528635686: buckets 2: 0x810d320: {value = "58.63.236.35"   , len = 15, name = "www.sina.com.cn"}
103   key -702889725: buckets 1: 0x810d300: {value = "74.125.71.105"  , len = 14, name = "www.google.com" }
104   key 203430122 : buckets 2: 0x810d338: {value = "60.28.14.190"   , len = 10, name = "www.qq.com"     }
105   key -640386838: buckets 0: 0x810d2c0: {value = "123.103.14.237" , len = 11, name = "www.163.com"    }
106   key 1313636595: buckets 0: 0x810d2d4: {value = "219.234.82.50"  , len = 12, name = "www.sohu.com"   }
107   key 1050805370: buckets 2: 0x810d348: {value = "117.40.196.26"  , len = 10, name = "abo321.org"     }
108 value = NULL
109 hash = 0x8111cd0: **buckets = 0x8111cdc, size = 1
110 0x8111cdc: buckets[0] = 0x8111ce0
111 buckets 0: 0x8111ce0: {value = "0x810d3c8       ", len = 2, name = "cn"             }
112     value = NULL
113     hash = 0x810d3c8: **buckets = 0x810d3d4, size = 1
114         0x810d3d4: buckets[0] = 0x810d3e0
115         buckets 0: 0x810d3e0: {value = "0x810d378       ", len = 3, name = "com"            }
116         value = NULL
117         hash = 0x810d378: **buckets = 0x810d384, size = 1
118                 0x810d384: buckets[0] = 0x810d3a0
119                 buckets 0: 0x810d3a0 {value = "220.181.111.147", len = 5, name = "baidu"          }
120 buckets 0: 0x8111ce8: {value = "0x8111c80       ", len = 3, name = "com"            }
121     value = "220.181.111.147"
122     hash = 0x8111c80: **buckets = 0x8111c8c, size = 1
123         0x8111c8c: buckets[0] = 0x8111ca0
124         buckets 0: 0x8111ca0 {value = "220.181.111.147", len = 5, name = "baidu"          }
125         buckets 0: 0x8111cac {value = "220.181.111.147", len = 6, name = "google"         }
126 value = NULL
127 hash = 0x8111d70: **buckets = 0x8111d7c, size = 1
128 0x8111d7c: buckets[0] = 0x8111d80
129 buckets 0: 0x8111d80: {value = "0x8111d20       ", len = 3, name = "www"            }
130     value = NULL
131     hash = 0x8111d20: **buckets = 0x8111d2c, size = 1
132         0x8111d2c: buckets[0] = 0x8111d40
133         buckets 0: 0x8111d40 {value = "117.40.196.26"  , len = 6, name = "abo321"         }
134 
135 --------------------------------
136 the pool:
137 --------------------------------
138 pool = 0x810d020
139   .d
140     .last = 0x810d418
141     .end = 0x810d420
142     .next = 0x8111c70
143     .failed = 0
144   .max = 984
145   .current = 0x810d020
146   .chain = (nil)
147   .large = (nil)
148   .cleanup = (nil)
149   .log = 0x8051518
150 available pool memory = 8
151 
152 pool = 0x8111c70
153   .d
154     .last = 0x8111dc0
155     .end = 0x8112070
156     .next = (nil)
157     .failed = 0
158   .max = 135339148
159   .current = 0x1
160   .chain = 0x810d0d8
161   .large = 0x8111ca0
162   .cleanup = (nil)
163   .log = (nil)
164 available pool memory = 688
165 
166 --------------------------------
167 find test:
168 --------------------------------
169 (url = "*.com"          , key = 40256957   ) found, (ip = "220.181.111.147")
170 (url = "*.baidu.com.cn" , key = 234385007  ) found, (ip = "220.181.111.147")
171 (url = "*.baidu.com"    , key = -724157846 ) found, (ip = "220.181.111.147")
172 (url = ".baidu.com"     , key = 1733355200 ) found, (ip = "220.181.111.147")
173 (url = "*.google.com"   , key = -1465170800) found, (ip = "220.181.111.147")
174 (url = "www.sina.com.cn", key = 1528635686 ) found, (ip = "58.63.236.35   ")
175 (url = "www.google.com" , key = -702889725 ) found, (ip = "74.125.71.105  ")
176 (url = "www.qq.com"     , key = 203430122  ) found, (ip = "60.28.14.190   ")
177 (url = "www.163.com"    , key = -640386838 ) found, (ip = "123.103.14.237 ")
178 (url = "www.sohu.com"   , key = 1313636595 ) found, (ip = "219.234.82.50  ")
179 (url = "abo321.org"     , key = 1050805370 ) found, (ip = "117.40.196.26  ")
180 (url = ".abo321.org"    , key = -4578520   ) not found!
181 (url = "www.abo321.*"   , key = 1494696375 ) found, (ip = "117.40.196.26  ")
182 
183 (url = "*.xx.xx"        , key = 51835370   ) not found!
184 (url = "www.baidu.com"  , key = 270263191  ) found, (ip = "220.181.111.147")
185 (url = "www.baidu."     , key = -239024726 ) not found!
View Code

 

posted @ 2014-06-14 17:00  在于思考  阅读(7550)  评论(0编辑  收藏  举报