nginx源码分析2———基础数据结构四(ngx_hash_t)

最新推荐文章于 2022-07-15 17:19:35 发布
最新推荐文章于 2022-07-15 17:19:35 发布
阅读量439 收藏
点赞数
分类专栏： nginx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sina_yangyang/article/details/47426055
版权

相关介绍

nginx哈希表的实现是 ngx_hash_t。ngx_hash_t的实现也与数据结构教科书上所描述的hash表的实现是大同小异。
对于常用的解决冲突的方法有线性探测，二次探测和开链法等。ngx_hash_t使用的是开链法。

源码分析

哈希表的结构

ngx_hash_elt_t是hash表中每一个元素的结构，实际存储在hash表中的结构

typedef struct {
    void             *value;
    u_short           len;
    u_char            name[1];
} ngx_hash_elt_t;

ngx_hash_key_t这是用于初始化hash表的结构，并不会存储在hash表内部

typedef struct {
    ngx_str_t         key;
    ngx_uint_t        key_hash;
    void             *value;
} ngx_hash_key_t;

key表示元素对应的key
key_hash表示元素的key的hash值
value 表示对应元素的value

ngx_hash_t是实际的hash表的结构。二维数组buckets是hash表的桶，size是桶的数量。

typedef struct {
    ngx_hash_elt_t  **buckets;
    ngx_uint_t        size;
} ngx_hash_t;

ngx_hash_init_t结构体用于初始化函数初始化hash表

typedef struct {
    ngx_hash_t       *hash;
    ngx_hash_key_pt   key;
    ngx_uint_t        max_size;
    ngx_uint_t        bucket_size;
    char             *name;
    ngx_pool_t       *pool;
    ngx_pool_t       *temp_pool;
} ngx_hash_init_t;

hash 该字段如果为NULL，那么调用完初始化函数后，该字段指向新创建出来的hash表。如果该字段不为NULL，那么在初始的时候，所有的数据被插入了这个字段所指的hash表中
key指向从字符串生成hash值的hash函数
max_size是hash表中的桶的个数。该字段越大，元素存储时冲突的可能性越小，每个桶中存储的元素会更少，则查询起来的速度更快。
bucket_size每个桶的最大限制大小，单位是字节。如果在初始化一个hash表的时候，发现某个桶里面无法存的下所有属于该桶的元素，则hash表初始化失败
name这是这个hash表的名字
pool是hash表分配内存使用的pool
temp_pool是hash表使用的临时pool，在初始化完成以后，该pool可以被释放和销毁掉。

哈希表的初始化
ngx_int_t 
ngx_hash_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names,
ngx_uint_t nelts);

hinit是上面所述的初始化hash表的结构

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;
    //和每一个即将装进去的元素比较
    for (n = 0; n < nelts; n++) {
    /*bucket_size不可以小于一个（内存对齐的ngx_hash_elt_t的大小加上一个指针的大小）*/
        if (hinit->bucket_size < 
/*NGX_HASH_ELT_SIZE用于获取（单个内存对齐的ngx_hash_elt_t）的大小*/
             NGX_HASH_ELT_SIZE(&names[n]) + sizeof(void *))
        {
        //如果桶的大小还不足以装下一个元素，就给出创建失败
            ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,"could not build the %s, you shouldincrease%s_bucket_size: %i", hinit->name, hinit->name, hinit->bucket_size);
            return NGX_ERROR;
        }
    }   
    //直接分配内存，大小为无符号short乘以hash表中桶的个数
    test = ngx_alloc(hinit->max_size * sizeof(u_short), hinit->pool->log);
    if (test == NULL) {
        return NGX_ERROR;
    }

    //获取每一个桶实际存储元素的大小
    bucket_size = hinit->bucket_size - sizeof(void *);

    /*获取hash表包含桶的数量的初始尝试大小，小于该大小的桶的数量一定初始化不了hash表*/
    start = nelts / (bucket_size / (2 * sizeof(void *)));
    start = start ? start : 1;

    if (hinit->max_size > 10000 && nelts && hinit->max_size / nelts < 100) {
        start = hinit->max_size - 1000;
    }
    //试图寻找一个合适的包含桶的数量，数量小于包含桶的数量的最大值
    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;
            }
            //hash散列
            key = names[n].key_hash % size;
            /*计算散列后，每一个桶的总大小(实际只是计算，并无任何处理)*/
            test[key] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
            /*必须保证每一个桶都能装下所有的元素，不然总的桶的数量+1,然后进行下一次尝试*/
            if (test[key] > (u_short) bucket_size) {
                goto next;
            }
        }
        goto found;
    next:
        continue;
    }
    //如果实在没有找到，那么将给出警告，并且将包含桶的数量设置为最大
    size = hinit->max_size;
    ngx_log_error(NGX_LOG_WARN, hinit->pool->log, 0,
"could not build optimal %s, you should increase either %s_max_size: %i or %s_bucket_size: %i; ignoring %s_bucket_size",hinit->name, hinit->name, hinit->max_size,hinit->name, hinit->bucket_size, hinit->name);

//此处正式开始，前面都是打酱油。
found:
    //其实test里面都是存放的计算的需要的大小
    /*先初始化为一个指针所占的大小,多加一个指针，最后会发现
    该指针会放在一个桶的所有元素的后面，并赋值为空*/
    for (i = 0; i < size; i++) {
        test[i] = sizeof(void *);
    }

    //计算会散落在每一个桶上的，每一个桶需要的内存的大小
    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;
    //把每一个桶需要的内存（内存对齐后）加起来,放到len上面
    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];
    }
//现在才正式开始，前面都是计算。
    //如果初始化的hash没有分配，那么久在pool里面给它分配内存
    if (hinit->hash == NULL) {
        hinit->hash = ngx_pcalloc(hinit->pool, sizeof(ngx_hash_wildcard_t) + size * sizeof(ngx_hash_elt_t *));
        //分配失败就free test然后直接返回
        if (hinit->hash == NULL) {
            ngx_free(test);
            return NGX_ERROR;
        }
        /*(指向ngx_hash_elt_t 的指针）的一个指针，相当于忽略前面的ngx_hash_wildcard_t，从size * sizeof(ngx_hash_elt_t *)开始指向指针的指针给buckets*/
        buckets = (ngx_hash_elt_t **)((u_char *) hinit->hash + sizeof(ngx_hash_wildcard_t));
    } else {
    //如果已经给定了hash的内存
        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进行内存对齐修正
    elts = ngx_align_ptr(elts, ngx_cacheline_size);

    for (i = 0; i < size; i++) {
        //如果桶里面没有任何数据散列上去
        if (test[i] == sizeof(void *)) {
            continue;
        }
        //为散列后的每一个桶分配内存
        buckets[i] = (ngx_hash_elt_t *) elts;
        elts += test[i];
    }

    //memset test
    for (i = 0; i < size; i++) {
        test[i] = 0;
    }

    //将每一个key都放进去
    for (n = 0; n < nelts; n++) {
        if (names[n].key.data == NULL) {
            continue;
        }
        key = names[n].key_hash % size;
        //buckets[key]表示该元素在第几个桶
        //test[key]表示该桶，这个元素的起始地址
        /*第一个起始地址是桶的开始地址buckets[key],第二个肯定是第一个基础上加起始地址，一次类推，上次的地址绝对偏差保存在test数组里面，每一个桶对应test里面的一个元素*/
        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] = (u_short) (test[key] + NGX_HASH_ELT_SIZE(&names[n]));
    }

    for (i = 0; i < size; i++) {
        if (buckets[i] == NULL) {
            continue;
        }
        //桶里面最后一个元素的后一个位置
        elt = (ngx_hash_elt_t *) ((u_char *) buckets[i] + test[i]);
        追加一个NULL，分配的时候也多分配了一个指针。
        elt->value = NULL;
    }
    //释放test
    ngx_free(test);
    //返回数据
    hinit->hash->buckets = buckets;
    hinit->hash->size = size;
    return NGX_OK;
}
hash的查找

hash表的查找比较简单，和我们常见的一样，先hash取值，然后从查找。key是name对应的hash值

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;

    //取得桶的位置
    elt = hash->buckets[key % hash->size];

    //这个桶是NULL，那么久直接返回NULL。
    if (elt == NULL) {
        return NULL;
    }

    while (elt->value) {
        //如果key的长度不一样，肯定不同，直接next
        if (len != (size_t) elt->len) {
            goto next;
        }

        //比较key的大小，要是不一样，直接next
        for (i = 0; i < len; i++) {
            if (name[i] != elt->name[i]) {
                goto next;
            }
        }
        //如果一样，就直接return掉。
        return elt->value;
    next:
        //指针后移到下一个元素的位置，并进行内存对齐矫正
        elt = (ngx_hash_elt_t *) ngx_align_ptr(&elt->name[0] + elt->len,sizeof(void *));
        continue;
    }
    return NULL;
}

总结

hash表的实现结构比较简单，但是初始化的时候比较繁琐，会调节几个参数，然后再来根据初始化的key来计算每一个桶的大小，然后将所有的元素填充进去。hash表的查找比较简单，也比较传统，贴上来也是给各位压压惊，我们下一节再研究ngx_hash_wildcard_t(支持通配符的散列表)。

sina_yangyang
关注
专栏目录
Nginx 哈希表结构 ngx_hash_t
关注校招求职，微信号：job_campus
01-06 1929
哈希表结合了数组和链表的特点，使其寻址、插入以及删除操作更加方便。哈希表的过程是将关键字通过某种哈希函数映射到相应的哈希表位置，即对应的哈希值所在哈希表的位置。但是会出现多个关键字映射相同位置的情况导致冲突问题，为了解决这种情况，哈希表使用两个可选择的方法：拉链法和开放寻址法。 Nginx 的哈希表中使用开放寻址来解决冲突问题，为了处理字符串，Nginx 还实现了支持通配符操作的相关函数，
Nginx源码分析之ngx_hash_t
上善若水
12-23 1825
Nginx源码分析之ngx_hash_t
09Nginx源码分析之哈希结构(ngx_hash.c)
weixin_44517656的博客
03-30 591
一 哈希结构 关于哈希的相关概念，可以先参考以下文章。 https://blog.csdn.net/weixin_44517656/article/details/105215349 注意： 下面的词语桶和槽是一样的，有些人习惯将桶称之为槽。 在阅读Nginx的hash结构时，一定不能着急，否则会让自己怒火中烧，建议大家都使用3-4天去消化。 Nginx的hash表结构主要几个特点： 1）静态只读。当初始化生成hash表结构后，是不能动态修改这个hash表结构的内容。 2）将内存利用最大化。Nginx的
nginx源码分析—hash结构ngx_hash_t
有趣的人生 一半是山川湖海 一半是初心情怀
03-15 751
Content 0.序 1.hash结构 1.1ngx_hash_t结构 1.2ngx_hash_init_t结构 1.3ngx_hash_key_t结构 1.4hash的逻辑结构 2.hash操作 2.1NGX_HASH_ELT_SIZE宏 2.2hash函数 2.3hash初始化 2.4hash查找 3.一个例子 3.1代码 3.2如何编译 3.3运行结果 3....
NGINX源码之：ngx_hash
qq_22351805的博客
07-15 912
ngx_hash源码分析，与demo示例
nginx源码分析2———基础数据结构五(ngx_hash_wildcard_t)
yang的博客
08-12 550
相关介绍 所谓支持通配符的散列表，就是把基本的散列表(ngx_hash_t)中的元素的关键字，用去除通配符以后的字符作为关键字加入，原理其实没有那么神秘。当然得先熟悉ngx_hash_t，可以看上一节，对ngx_hash_t做深入的了解。 ngx_hash_wildcard_t类型的hash表包含通配符在前的key或者是通配符在后的key。例如，对于关键字为”www.test.*”这样带通配符
nginx源码分析--数据结构 哈希 ngx_hash_t
鱼思故渊的专栏
03-09 1554
Content 0.序 1.hash结构 1.1ngx_hash_t结构 1.2ngx_hash_init_t结构 1.3ngx_hash_key_t结构 1.4hash的逻辑结构 2.hash操作 2.1NGX_HASH_ELT_SIZE宏 2.2hash函数 2.3hash初始化 2.4hash查找 3.一个例子 3.1代码 3.2如何编译 3.3运行结果 3.
nginx源码分析2———基础数据结构六(ngx_hash_keys_arrays_t）
yang的博客
08-15 516
相关介绍 在构建一个ngx_hash_wildcard_t的时候，需要对通配符的哪些key进行预处理。这个处理起来比较麻烦。而当有一组key，这些里面既有无通配符的key，也有包含通配符的key的时候。我们就需要构建三个hash表，一个包含普通的key的hash表，一个包含前向通配符的hash表，一个包含后向通配符的hash表（或者也可以把这三个hash表组合成一个ngx_hash_combin
ngx_http_consistent_hash-master.zip
05-21
"ngx_http_consistent_hash-master.zip" 是一个与 Nginx Web服务器相关的压缩包文件，其中包含了一个名为 "ngx_http_consistent_hash" 的第三方模块的源代码。"master" 指示这可能是该模块的主分支或最新版本。 **...
ngx_http_upstream_ip_hash_module.c
06-02
nginx的iphash改成按照ip轮询
nginx源代码分析之内存池(ngx_pool_t)技术
nicomy2018的博客
07-10 1149
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 由于业务的需要经常用nginx作为反向代理服务器，提供http的web服务、rtmp和hls的流媒体服务，虽然对于nginx的配置和使用了然于胸，但是对于nginx的实现原理却知之甚少，知其然却不知其所以然，作为一个码龄超过20年的c++程序员显然是有些说不过去的，从本期开始将会不定期的更新对于ng...
nginx源码分析—hash结构ngx_hash_t(v1.0.4)
热门推荐
学习，思考，记录，分享。
07-26 1万+
本博客（http://blog.csdn.net/livelylittlefish ）贴出作者（阿波）相关研究、学习内容所做的笔记，欢迎广大朋友指正！Content0.序1.hash结构1.1ngx_hash_t结构1.2ngx_hash_init_t结构1.3ngx_hash_
nginx源码分析1———进程间的通信机制一（信号量）
yang的博客
07-22 2223
nginx源码分析1———进程间的通信机制一（信号量）nginx源码分析1进程间的通信机制一信号量相关介绍 相关系统调用 相关结构 初始化 加锁 解锁 销毁相关介绍nginx采用信号量辅助原子变量实现互斥锁，本章我们将讨论原子变量在nginx源码里面的应用。 信号量（semaphore）是一种用于提供不同进程间或者一个给定的进程的不同线程间同步手段的原语。nginx采用的信号量是Posix的基于内
nginx源码分析1———进程间的通信机制五（文件锁）
yang的博客
08-04 1128
相关介绍
nginx源码分析1———进程间的通信机制二（自旋锁）
yang的博客
07-23 922
自旋锁的相关介绍自旋锁的释义自旋锁与其他的锁最大的区别就是自旋锁不会引起调用者睡眠（非睡眠锁），也就是始终是可执行状态。如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里，看是否该自旋锁的保持者已经释放了锁。自旋锁的适用场景当锁的使用时间很短的时候，就可以采用自旋锁，这样开销很小。如果时间很长，锁一直自旋，又不能调度其他的程序，cpu资源将被大量占用，这样就不是很合适。对于长时间的锁，应该使用
nginx源码分析1———进程间的通信机制六（UNIX域协议）
yang的博客
08-06 749
相关介绍 Unix域协议并不是一个实际的协议族，而是在单机上客户端与服务器通信的一种方法。
nginx源码分析1———进程间的通信机制三（mmap）
yang的博客
07-27 700
相关介绍 mmap函数把一个文件或者一个Posix共享内存区对象映射到调用进程的地址空间。使用该函数，可以达到三个目的。 1.使用普通文件以提供内存映射I/O。 2.使用特殊文件以提供匿名内存映射。 3.使用shm_open以提供无亲缘关系进程间的Posix共享内存区 相关系统调用 #include //若成功则返回被映射区的起始地址，若出错则为MAP_FAILED void* m
nginx源码分析1———进程间的通信机制四（System V内存共享）
yang的博客
08-03 567
相关介绍 SystemV共享内存区在概念上类似于前面提到的mmap，我们将先使用shmget，然后再调用shmat，其中shmget类似于open，shmat类似于mmap。 相关系统调用 shmget函数创建一个新的共享内存区，或者访问一个已存在的内存共享区。 #include int shmget(key_t key, size_t size, int oflag); 1，
openresty ngx_upstream_module
最新发布
06-08
`ngx_upstream_module` 是 OpenResty 中的一个模块，它提供了对 upstream 的支持。Upstream 是一个概念，用于表示一组后端服务器。在使用 upstream 时，客户端的请求会被反向代理到一个或多个后端服务器上进行处理。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值