在nginx中使用的hash中一个非常核心的函数就是ngx_hash_init,由于nginx这个hash表是静态只读的,即不能在运行时动态添加新元素的,一切的结构和数据都在配置初始化的时候就已经规划完毕,所以“init”过程的优劣,对运行时查找的性能影响非常大。在正式分析之前,下面的这个连接给出了一个非常详细的hash结构的整体布局,对理解代码帮助会很大,一定要仔细看一下。
先思考这样一个问题,假设让你来设计一个静态的hash表,对于一批确定数量的关键字,如何建立一个合理并且高效的hash表,让运行时的查找足够高效呢?你的hash表槽位多少合适?key冲突问题如何解决,用链式?链表长度该如何确定,太长效率低,那么多长合适?想想这些问题,然后我们看看nginx是如何去做的。
- ngx_int_t
- ngx_hash_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names, ngx_uint_t nelts)
- {
- u_char *elts;
- size_t len;
- u_short *test;
- ngx_uint_t i, n, key, size, start, bucket_size;
- ngx_hash_elt_t *elt, **buckets;
- /* nelts是关键字的数量,bucket_size为一个bucket的大小,这里注意的就是一个bucket至少可以容得下一个关键字,
- * 而下面的NGX_HASH_ELT_SIZE(&name[n] + sizeof(void *))正好就是一个关键字所占的空间。
- * 通过判断条件来看,如果我们设定的bucket大小,必须保证能容得下任何一个关键字,否则,就报错,提示bucket指定的太小。
- * 关于NGX_HASH_ELT_SIZE这个宏,这里提一下,nginx把所以定位到某个bucket的关键字,即冲突的,封装成ngx_hash_elt_t结构
- * 挨在一起放置,这样组成了一个ngx_hash_elt_t数组,这个数组空间的地址,由ngx_hash_t中的buckets保存。对于某个关键字来说,
- * 它有一个ngx_hash_elt_t的头结构和紧跟在后面的内容组成,从这个角度看一个关键字所占用的空间正好等于NGX_HASH_ELT_SIZE宏的值
- * 只是里面多了一个对齐的动作。
- */
- for (n = 0; n < nelts; n++) {
- /*
- * 这里考虑放置每个bucket最后的null指针所需要的空间,即代码中的sizeof(void *),这个NULL在find过程中作为一个bucket
- * 的结束标记来使用。
- */
- if (hinit->bucket_size < NGX_HASH_ELT_SIZE(&names[n]) + sizeof(void *))
- {
- return NGX_ERROR;
- }
- }
- /* max_size是bucket的最大数量, 这里的test是用来做探测用的,探测的目标是在当前bucket的数量下,冲突发生的是否频繁。
- * 过于频繁则说明当前的bucket数量过少,需要调整。那么如何判定冲突过于频繁呢?就是利用这个test数组,它总共有max_size个
- * 元素,即最大的bucket。每个元素会累计落到该位置关键字长度,当大于256个字节,即u_short所表示的最大大小时,则判定
- * bucket过少,引起了严重的冲突。后面会看到具体的处理。
- */
- test = ngx_alloc(hinit->max_size * sizeof(u_short), hinit->pool->log);
- if (test == NULL) {
- return NGX_ERROR;
- }
- /* 每个bucket的末尾一个null指针作为bucket的结束标志, 这里bucket_size是容纳实际数据大小,故减去一个指针大小 */
- bucket_size = hinit->bucket_size - sizeof(void *);
- /*
- * 这里考虑NGX_HASH_ELT_SIZE中,由于对齐的缘故,一个关键字最少需要占用两个指针的大小。
- * 在这个前提下,来估计所需要的bucket最小数量,即考虑元素越小,从而一个bucket容纳的数量就越多,
- * 自然使用的bucket的数量就越少,但最少也得有一个。
- */
- start = nelts / (bucket_size / (2 * sizeof(void *)));
- start = start ? start : 1;
- /*
- * 调整max_size,即bucket数量的最大值,依据是:bucket超过10000,且总的bucket数量与元素个数比值小于100
- * 那么bucket最大值减少1000,至于这几个判断值的由来,尚不清楚,经验值或者理论值。
- */
- if (hinit->max_size > 10000 && nelts && hinit->max_size / nelts < 100) {
- start = hinit->max_size - 1000;
- }
- /* 在之前确定的最小bucket个数的基础上,开始探测(通过test数组)并根据需要适当扩充,前面有分析其原理 */
- for (size = start; size < hinit->max_size; size++) {
- ngx_memzero(test, size * sizeof(u_short));
- for (n = 0; n < nelts; n++) {
- if (names[n].key.data == NULL) {
- continue;
- }
- key = names[n].key_hash % size;
- test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
- if (test[key] > (u_short) bucket_size) {
- goto next;
- }
- }
- goto found;
- next:
- /* 到next这里,就是实际处理bucket扩充的情况了,即递增表示bucket数量的size变量 */
- continue;
- }
- ngx_free(test);
- return NGX_ERROR;
- found:
- /* 确定了合适的bucket数量,即size。 重新初始化test数组,初始值为一个指针大小。*/
- for (i = 0; i < size; i++) {
- test[i] = sizeof(void *);
- }
- /* 统计各个bucket中的关键字所占的空间,这里要提示一点,test[i]中除了基本的数据大小外,还有一个指针的大小
- * 如上面的那个for循环所示。
- */
- for (n = 0; n < nelts; n++) {
- if (names[n].key.data == NULL) {
- continue;
- }
- key = names[n].key_hash % size;
- test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
- }
- len = 0;
- /* 调整成对齐到cacheline的大小,并记录所有元素的总长度 */
- for (i = 0; i < size; i++) {
- if (test[i] == sizeof(void *)) {
- continue;
- }
- test[i] = (u_short) (ngx_align(test[i], ngx_cacheline_size));
- len += test[i];
- }
- /*
- * 申请bucket元素所占的空间,这里注意的一点就是,如果之前hash表头结构没有申请,
- * 那么在申请时将ngx_hash_wildcard_t结构也一起申请了。
- */
- if (hinit->hash == NULL) {
- hinit->hash = ngx_pcalloc(hinit->pool, sizeof(ngx_hash_wildcard_t)
- + size * sizeof(ngx_hash_elt_t *));
- if (hinit->hash == NULL) {
- ngx_free(test);
- return NGX_ERROR;
- }
- buckets = (ngx_hash_elt_t **)
- ((u_char *) hinit->hash + sizeof(ngx_hash_wildcard_t));
- } else {
- buckets = ngx_pcalloc(hinit->pool, size * sizeof(ngx_hash_elt_t *));
- if (buckets == NULL) {
- ngx_free(test);
- return NGX_ERROR;
- }
- }
- elts = ngx_palloc(hinit->pool, len + ngx_cacheline_size);
- if (elts == NULL) {
- ngx_free(test);
- return NGX_ERROR;
- }
- elts = ngx_align_ptr(elts, ngx_cacheline_size);
- /* 设置各个bucket中包含实际数据的空间的地址(或者说位置) */
- for (i = 0; i < size; i++) {
- if (test[i] == sizeof(void *)) {
- continue;
- }
- buckets[i] = (ngx_hash_elt_t *) elts;
- elts += test[i];
- }
- /* 用来累计真实数据的长度,不计结尾指针的长度 */
- for (i = 0; i < size; i++) {
- test[i] = 0;
- }
- /* 依次向各个bucket中填充实际的内容,代码没什么好分析的。*/
- for (n = 0; n < nelts; n++) {
- if (names[n].key.data == NULL) {
- continue;
- }
- key = names[n].key_hash % size;
- elt = (ngx_hash_elt_t *) ((u_char *) buckets[key] + test[key]);
- elt->value = names[n].value;
- elt->len = (u_short) names[n].key.len;
- ngx_strlow(elt->name, names[n].key.data, names[n].key.len);
- /* test[key]记录当前bucket内容的填充位置,即下次填充的开始位置 */
- test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
- }
- /* 设置bucket结束位置的null指针,*/
- for (i = 0; i < size; i++) {
- if (buckets[i] == NULL) {
- continue;
- }
- /*
- * 由于前面bucket的处理中多留出了一个指针的空间,而此时的test[i]是bucket中实际数据的共长度,
- * 所以bucket[i] + test[i]正好指向了末尾null指针所在的位置。处理的时候,把它当成一个ngx_hash_elt_t结构看,
- * 在该结构中的第一个元素,正好是一个void指针,我们只处理它,别的都不去碰,所以没有越界的问题。
- */
- elt = (ngx_hash_elt_t *) ((u_char *) buckets[i] + test[i]);
- elt->value = NULL;
- }
- ngx_free(test);
- hinit->hash->buckets = buckets;
- hinit->hash->size = size;
- return NGX_OK;
- }