zoukankan      html  css  js  c++  java

  • libevent源码学习（7）：event_io_map

    event_io_map

    哈希表操作函数

    hashcode与equals函数

    哈希表初始化

    哈希表元素查找

    哈希表扩容

    哈希表元素插入

    哈希表元素替换

    哈希表元素删除

    自定义条件删除元素

    哈希表第一个非空元素

    哈希表下一个元素

    释放哈希表

    向event_io_map中添加event

    激活event_io_map中的event

    删除event_io_map中的event

    以下源码均基于libevent-2.0.21-stable。

           在libevent中，自定义了一个哈希表结构用于实现event_io_map，该哈希表相关代码在ht-internal.h中，从该头文件的名称也可以看出来，libevent中的哈希表是一个并不对用户开放的内部使用结构。哈希表用于实现event_io_map，因此先来看看event_io_map的定义。

    event_io_map

           在event_internal.h文件中，有如下定义：

    1. #ifdef WIN32
    2. /* If we're on win32, then file descriptors are not nice low densely packed
    3. integers. Instead, they are pointer-like windows handles, and we want to
    4. use a hashtable instead of an array to map fds to events.
    5. */
    6. #define EVMAP_USE_HT
    7. #endif
    8.  
    9. /* #define HT_CACHE_HASH_VALS */
    10.  
    11. #ifdef EVMAP_USE_HT //在windows下就是用哈希结构，否则直接使用event_signal_map
    12. #include "ht-internal.h"
    13. struct event_map_entry;
    14. HT_HEAD(event_io_map, event_map_entry); //定义一个结构体名为event_io_map,其中的哈希表元素类型为event_map_entry
    15. #else
    16. #define event_io_map event_signal_map
    17. #endif

            根据上述定义可知，仅在Windows环境下，event_io_map会使用哈希结构，否则event_io_map直接按event_signal_map使用。

           这里涉及到了一个宏定义HT_HEAD以及一个结构体event_map_entry，先来看看event_map_entry结构体的定义。

    1. #ifdef EVMAP_USE_HT
    2. struct event_map_entry {
    3. HT_ENTRY(event_map_entry) map_node; //构成哈希表中同一个桶下的链表
    4. evutil_socket_t fd; //文件描述符
    5. union { /* This is a union in case we need to make more things that can
    6. be in the hashtable. */
    7. struct evmap_io evmap_io; //存放同一个文件描述符/信号值下的所有event
    8. } ent;
    9. };

           可以看到，在event_map_entry这一结构体中，还涉及到了一个HT_ENTRY宏定义，除此之外，其中包含了一个文件描述符/信号值成员fd，以及一个联合体中定义了一个evmap_io类型的结构体。对于这里的HT_ENTRY以及前面的HT_HEAD，各自的宏定义如下所示：

    1. #define HT_HEAD(name, type)
    2. struct name {
    3. /* The hash table itself. */
    4. struct type **hth_table; /* 哈希表 可以当做数组 hth_table[i]就是该数组中第i个struct type * 类型元素*/
    5. /* How long is the hash table? */
    6. unsigned hth_table_length; /*哈希表的容量*/
    7. /* How many elements does the table contain? */
    8. unsigned hth_n_entries; /*哈希表中的元素数量*/
    9. /* How many elements will we allow in the table before resizing it? */
    10. unsigned hth_load_limit; /*哈希表扩容阈值*/
    11. /* Position of hth_table_length in the primes table. */
    12. int hth_prime_idx; /*哈希表长度在素数数组中的索引*/
    13. }
    14.  
    15. #ifdef HT_CACHE_HASH_VALUES
    16. #define HT_ENTRY(type)
    17. struct {
    18. struct type *hte_next;
    19. unsigned hte_hash;
    20. }
    21. #else
    22. #define HT_ENTRY(type)
    23. struct {
    24. struct type *hte_next;
    25. }
    26. #endif

           对于HT_HEAD宏定义，其中包含5个成员，各自的含义可参照注释。需要注意的是第一个成员struct type **hth_table，从成员名来看就是哈希表，这是一个二级指针，在C语言中规定，p[i]等价于*(p+i)，换到这里来看，hth_table是一个指向type *类型的指针，因此(p+i)就是从首地址偏移了i个type *类型大小的地址，而*(p+i)自然也就是从首地址算起，第i个type *类型的元素了，因此，hth_table作为一个二级指针，那么hth_table[i]也就是第i个type*类型的元素，hth_table也就相当于一个type *类型的数组了。

           再来看 HT_ENTRY这一宏定义，它定义了一个匿名结构体，该结构体的接个头由宏定义HT_CACHE_HASH_VALUES控制，在libevent中，我目前尚未找到HT_CACHE_HASH_VALUES的定义，也就是说，该宏定义默认为未定义的，可由用户自行选择是否定义。

           接下来，替换以上两个宏定义，再回到event_map_entry和event_io_map中，得到各自定义如下：

    1. struct event_map_entry
    2. {
    3. struct
    4. {
    5. struct event_map_entry *hte_next; //构成链表
    6. #ifdef HT_CACHE_HASH_VALUES
    7. unsigned hte_hash;
    8. #endif
    9. }map_node;
    10.  
    11. evutil_socket_t fd;
    12. union
    13. {
    14. struct evmap_io evmap_io;
    15. }ent;
    16. };
    17.  
    18.  
    19. struct event_io_map
    20. {
    21. //哈希表，连续地址分配
    22. struct event_map_entry **hth_table;
    23. //哈希表的长度
    24. unsigned hth_table_length;
    25. //哈希的元素个数
    26. unsigned hth_n_entries;
    27. //哈希表扩容阈值，当哈希表中元素数目达到这个值就需要进行扩容
    28. unsigned hth_load_limit;
    29. //哈希表的长度所对应素数数组中的索引
    30. int hth_prime_idx;
    31. };

           在event_io_map中，二级指针hth_table刚刚说了，可以看做是一个数组，这个数组的各个元素类型为event_map_entry *类型，而在event_map_entry结构体的定义中，一个hte_next很明显表明了这里会存在一个event_map_entry的链表。在来看后面的evmap_io结构体定义，如下所示：

    1. struct evmap_io
    2. {
    3. struct event_list events; //event双向链表
    4. ev_uint16_t nread; //链表中读事件的个数
    5. ev_uint16_t nwrite; //链表中写事件的个数
    6. };

            关于event_list类型，可以在event_struct.h中找到其相关语句：（关于TAILQ）

    TAILQ_HEAD (event_list, event);  //名为event_list的头结点，链表结点为event类型

            也就是说，在evmap_io中，定义了一个event的双向链表，以及一个nread变量和nwrite变量，而一个event_map_entry对应一个evmap_io，也就对应一个event的双向链表。

            因此总结得出event_io_map的结构，如下所示：

           这样，我们就大概知道了libevent中哈希表的结构：

           hth_table就是哈希表中的“桶数组”，它的每一个元素都是一个“桶”，这里将哈希表分为主链和冲突链，哈希表主链上的各个结点放置的是地址连续的event_map_entry指针，通过下标如hth_table[i]就可以直接访问第i个结点，它的底层就是*(hth_table+i)，这是一个寻址的过程，时间复杂度为O(1)。主链上每一个这样的event_map_entry指针都指向一个event_map_entry实体。如果有多个event_map_entry实体对应同一个桶，这就引起了哈希冲突，从图中也可得知，libevent是采用拉链法来解决哈希冲突的，如图中褐色框中的内容所示。

           每个event_map_entry都对应了一个fd，对于event这是一个文件描述符，对于signal这是一个信号值，也就对应了一个监听事件。如果多个事件对应同一个fd，那么这些事件就会被放到evmap_io所对应的event事件双向链表中，evmap_io中的nread和nwrite则分别记录了这个双向链表中读类型和写类型的event数量。

           总之，event_io_map中会保存所有通过event_add添加的io event。

    哈希表操作函数

          在ht-internal.h中，哈希表相关的函数主要都是以宏函数来实现的，找到这些函数的宏定义如下所示：

    1. #define HT_EMPTY(head)
    2. ((head)->hth_n_entries == 0)
    3.  
    4. /* How many elements in 'head'? */
    5. #define HT_SIZE(head)
    6. ((head)->hth_n_entries)
    7.  
    8. #define HT_FIND(name, head, elm) name##_HT_FIND((head), (elm))
    9. #define HT_INSERT(name, head, elm) name##_HT_INSERT((head), (elm))
    10. #define HT_REPLACE(name, head, elm) name##_HT_REPLACE((head), (elm))
    11. #define HT_REMOVE(name, head, elm) name##_HT_REMOVE((head), (elm))
    12. #define HT_START(name, head) name##_HT_START(head)
    13. #define HT_NEXT(name, head, elm) name##_HT_NEXT((head), (elm))
    14. #define HT_NEXT_RMV(name, head, elm) name##_HT_NEXT_RMV((head), (elm))
    15. #define HT_CLEAR(name, head) name##_HT_CLEAR(head)
    16. #define HT_INIT(name, head) name##_HT_INIT(head)

           这里只有两个函数直接给出了实现，而其他函数都是宏定义为name##_HT_XXX的宏函数上面，可以发现，这些宏函数对应了三个参数：name、head以及elm。宏定义中的“##”起的是连接作用。从函数名上大概能推断出函数的功能，不过如果直接去看这些宏函数的定义会非常懵的，在event_io_map中，这些宏定义中的name参数直接替换为"event_io_map"即可。

           将这些宏定义全部替换（用gcc -E编译），然后就可以看到event_io_map中的这些函数的实现。

           在分析函数实现之前，有必要先回过头再看一下event_io_map结构体：

    1. struct event_io_map
    2. {
    3. //哈希表，连续地址分配
    4. struct event_map_entry **hth_table;
    5. //哈希表的长度
    6. unsigned hth_table_length;
    7. //哈希的元素个数
    8. unsigned hth_n_entries;
    9. //哈希表扩容阈值，当哈希表中元素数目达到这个值就需要进行扩容
    10. unsigned hth_load_limit;
    11. //哈希表的长度所对应素数数组中的索引
    12. int hth_prime_idx;
    13. };

            hth_table:哈希表，hth_table[i]就是哈希表中的第i个桶；

            hth_table_length:哈希表的长度。为了让元素散列更加均匀，哈希表的长度最好选为素数，libevent中提供了一个素数数组，哈希表的长度都是以该数组中的元素为准，即使是哈希表扩容，也是一样的，该素数数组定义如下：

    1. static unsigned name##_PRIMES[] = {
    2. 53, 97, 193, 389,
    3. 769, 1543, 3079, 6151,
    4. 12289, 24593, 49157, 98317,
    5. 196613, 393241, 786433, 1572869,
    6. 3145739, 6291469, 12582917, 25165843,
    7. 50331653, 100663319, 201326611, 402653189,
    8. 805306457, 1610612741
    9. };

           可以发现，素数数组中的每个元素都是素数，并且后一个元素近似为前一个元素两倍。而hth_table_length也只能取该数组中的某个值；

           hth_n_entries:哈希表中的元素个数；

           hth_load_limit:哈希表的扩容阈值。扩容阈值的含义是：当哈希表中的元素个数达到这个值后，哈希表就需要进行扩容；

           hth_prime_idx:哈希表的长度对应素数数组中该元素的索引。比如说哈希表的长度为193，那么hth_prime_idx就为2。

    hashcode与equals函数

           在java的HashMap中，提供了一个hashcode方法以及equals方法，前者可以将不同类型参数转换为一个int型的散列值，而后再通过哈希算法找到对应的桶位置，而后者则是用于判断哈希表中两个元素是否相等。

           在libevent中，也定义了这两个函数。

           event_io_map中为event_map_entry类型的参数提供了一个取相应hashcode的函数hashsocket，根据英文注释可知，由于windows中socket的低2~3位是没有多大影响的，也就是可能会存在很多socket的低2~3位是相同的情况。如果两个socket只有低2~3位不同，那么说明这两个socket的值是非常接近的，而在哈希表中，对于非常接近的元素也希望把他们尽量的散列开，因此这里并没有直接使用event_map_entry的fd作为hashcode，而是先将fd的二进制位进行旋转，将其低2位放到高2位去，然后再与原来的fd进行求和，这样，即使值相近的两个socket的hashcode也会有很大的差别，更有利于散列。如下所示：(evmap.c)

    1. static inline unsigned
    2. hashsocket(struct event_map_entry *e)
    3. {
    4. /* On win32, in practice, the low 2-3 bits of a SOCKET seem not to
    5. * matter. Our hashtable implementation really likes low-order bits,
    6. * though, so let's do the rotate-and-add trick. */
    7. unsigned h = (unsigned) e->fd;
    8. h += (h >> 2) | (h << 30); // h>>2后只剩前面30位，h<<30后只有最后2位，相当于把最后2位放到了最前面，然后再与原数相加
    9. return h;
    10. }

           当取得元素相应的hashcode值之后，就需要通过这个hashcode来找到它在哈希表中相应的桶的位置。这里采用的方法是直接让hashcode对哈希表长度取模%，得到的结果就是该元素在哈希表中桶的位置。 如果找到了桶的位置，并且桶是空的，那么直接将该元素放到桶中，如果桶中已经有元素了，说明此时产生了哈希冲突，如前所述，这里解决哈希冲突的方法是将冲突的元素组合成一个链表。举个例子，java中的HashMap或者是C++中的Map，存储的都是一个key-value键值对，当你通过key去寻找对应的value时，就会对value相应的hashcode先通过哈希算法（比如这里是hashcode取哈希表长度的模）求得key对应的桶的位置，然后再在桶中去看是否有元素与传入的元素"equals"，如果没有那么就是查找失败，否则就返回equals成功的那个元素。

           libevent中通过eqsocket函数来判断哈希表中的两个元素是否相同，判断的方法很简单，就是看二者的fd是否相等即可。

    1. static inline int
    2. eqsocket(struct event_map_entry *e1, struct event_map_entry *e2)
    3. {
    4. return e1->fd == e2->fd;
    5. }

    哈希表初始化

           event_io_map哈希表初始化函数为event_io_map_HT_INIT，需要注意的是，这里只是让hth_table初始化为NULL，并没有为其分配实际的内存，哈希表此时也并不存在。如下所示：

    1. static inline void event_io_map_HT_INIT(struct event_io_map *head) //哈希表初始化
    2. {
    3. head->hth_table_length = 0;
    4. head->hth_table = NULL;
    5. head->hth_n_entries = 0;
    6. head->hth_load_limit = 0;
    7. head->hth_prime_idx = -1;
    8. }

    哈希表元素查找

           这里定义了两个哈希表元素查找函数，一个是_event_io_map_HT_FIND_P，一个则是_event_io_map_HT_FIND。二者都是在哈希表中去寻找与传入参数elm的fd相等的元素，不同的是前者返回的是哈希表中fd与elm相同的元素地址的指针，而后者则是返回该元素的地址。

    1. static inline struct event_map_entry **
    2. _event_io_map_HT_FIND_P(struct event_io_map *head,
    3. struct event_map_entry *elm) //返回哈希表中，fd与elm相等的元素地址，如果哈希表不存在就返回NULL，如果哈希表中不存在该元素*p=NULL
    4. {
    5. struct event_map_entry **p;
    6. if (!head->hth_table) //哈希表未分配
    7. return NULL;
    8.  
    9. #ifdef HT_CACHE_HASH_VALUES
    10. p = &((head)->hth_table[((elm)->map_node.hte_hash) //先将传入的elm进行哈希后取模，找到该元素在哈希表中的位置，然后找到哈希表中该位置上的元素，p为该元素地址
    11. % head->hth_table_length]);
    12. #else
    13. p = &((head)->hth_table[(hashsocket(*elm))%head->hth_table_length]);
    14. #endif
    15.  
    16. while (*p) //从该位置开始遍历整个冲突链，查找冲突链上是否有与elm的fd相等的元素，如果有就返回该元素地址
    17. {
    18. //判断是否相等。在实现上，只是简单地根据fd来判断是否相等
    19. if (eqsocket(*p, elm))
    20. return p;
    21.  
    22. //p存放的是hte_next成员变量的地址
    23. p = &(*p)->map_node.hte_next;
    24. }
    25.  
    26. return p; //如果没找到，那么*p = NULL
    27. }
    1. static inline struct event_map_entry *
    2. event_io_map_HT_FIND(const struct event_io_map *head,
    3. struct event_map_entry *elm) //返回的是哈希表中该结点元素
    4. {
    5. struct event_map_entry **p;
    6. struct event_io_map *h = (struct event_io_map *) head;
    7.  
    8. #ifdef HT_CACHE_HASH_VALUES
    9. do
    10. { //计算哈希值
    11. (elm)->map_node.hte_hash = hashsocket(elm);
    12. } while(0);
    13. #endif
    14.  
    15. p = _event_io_map_HT_FIND_P(h, elm); //p为NULL说明哈希表未分配，如果已分配，但是没找到，那么*p为NULL
    16. return p ? *p : NULL; //返回NULL可能是哈希表本身未分配，也可能是哈希表中没有该元素
    17. }

    哈希表扩容

           哈希表中每次扩容都是接近加倍，加倍扩容可以一次取得较大的容量，也就不用经常扩容了。不过对于哈希表扩容来说，它的作用不单单是为了增大空间，它也能降低哈希冲突发生的概率。

           哈希表中通过HT_GENERATE宏设置了扩容因子，默认为0.5，而哈希表的扩容阈值，就是哈希表的长度乘以这个扩容因子得到的值，当哈希表中元素的个数超过扩容阈值，那么就说明需要进行扩容了。实际上扩容因子的设置并不固定，这里之所以将其设置为0.5，是为了降低哈希冲突概率的同时也避免频繁的扩容。

            event_io_map的扩容函数为event_io_map_HT_GROW，其定义如下：

    1. int event_io_map_HT_GROW(struct event_io_map *head, unsigned size) //哈希表扩容
    2. {
    3. unsigned new_len, new_load_limit;
    4. int prime_idx;
    5.  
    6. struct event_map_entry **new_table;
    7. //哈希表当前长度对应素数表中最后一个元素，此时不能再扩容了
    8. if (head->hth_prime_idx == (int)event_io_map_N_PRIMES - 1)
    9. return 0;
    10.  
    11. //还未达到哈希表扩充阈值，无需扩容
    12. if (head->hth_load_limit > size)
    13. return 0;
    14. //执行到这里说明哈希表需要进行扩容了，下面开始扩容
    15. prime_idx = head->hth_prime_idx; //保存当前哈希表长度对应的素数数组索引
    16.  
    17. do {
    18. new_len = event_io_map_PRIMES[++prime_idx]; //从素数数组中得到扩容后的长度
    19.  
    20. new_load_limit = (unsigned)(0.5*new_len); //更新扩容阈值
    21. } while (new_load_limit <= size
    22. && prime_idx < (int)event_io_map_N_PRIMES); //如果当前扩容后size依然超过了阈值，那么继续选取素数数组中下一个元素作为扩容大小
    23.  
    24. //执行到这里说明哈希表的扩容大小已经确定，现在分配实际空间
    25. if ((new_table = mm_malloc(new_len*sizeof(struct event_map_entry*)))) //malloc分配扩容大小的空间 注意此时原来的哈希表依然存在
    26. {
    27. unsigned b;
    28. memset(new_table, 0, new_len*sizeof(struct event_map_entry*)); //清空哈希表
    29.  
    30. //这里不能直接用realloc来扩容，因此哈希表长度变化后各个元素在哈希表中的位置也会改变，因此需要hash，将原哈希表上的每个元素重新放置到新的哈希表上，包括未冲突的
    31. //实际上分配的只是一个新的哈希表的主链，新的哈希表和原来的哈希表对应同样的冲突链表
    32. for (b = 0; b < head->hth_table_length; ++b) //遍历原来的哈希表
    33. {
    34. struct event_map_entry *elm, *next;
    35. unsigned b2;
    36.  
    37. elm = head->hth_table[b]; //遍历哈希表上的主链的结点，然后再遍历主链结点所在的冲突链
    38. while (elm) //从该元素开始，检查它的map_node链表，看是否有冲突
    39. {
    40. next = elm->map_node.hte_next; //取得所属链表的下一个元素
    41.  
    42. #ifdef HT_CACHE_HASH_VALUES //如果使用缓存的哈希值
    43. b2 = (elm)->map_node.hte_hash % new_len; //直接用缓存的哈希值取模得到元素在哈希表上的索引
    44. #else //如果不使用缓存值就调用hashsocket获取哈希值 再取模
    45. b2 = (hashsocket(*elm)) % new_len;
    46. #endif
    47. //用头插法插入数据
    48. //将该元素放到重新hash后的位置，这里相当于是头插法
    49. elm->map_node.hte_next = new_table[b2]; //更新该元素所在的冲突链表位置
    50. new_table[b2] = elm; //将该元素放到重新hash后的位置
    51.  
    52. elm = next; //冲突链下一个元素
    53. }
    54. }
    55.  
    56. if (head->hth_table) //释放原来的哈希表
    57. mm_free(head->hth_table);
    58.  
    59. head->hth_table = new_table; //更新event_io_map中的哈希表
    60. }
    61. else //新哈希表malloc扩容失败，前面可以看到，malloc分配后新老哈希表都同时存在，因此分配失败的原因可能是空间不够装下两个哈希表
    62. { //尝试用realloc分配尝试是否能节约空间。realloc内部也会调用malloc分配一个新空间，然后将原空间中的数据复制过去后再释放原空间，
    63. //因此在一般情况下即使使用realloc分配，在某一时刻内存中也会同时存在两个哈希表，内存不足的问题并不会得到解决
    64. //这里之所以使用realloc，是为了尝试realloc的特殊情况，如果原空间的后面刚好有一段空闲内存，并且与原空间加起来刚好可以放下新空间，那么就会直接在原空间上进行“增长”，这样就节省了内存
    65. //因此这里使用realloc并不一定就能改善空间状况，只是在malloc分配失败的情况下的一种尝试解决的办法，并不一定成功
    66. unsigned b, b2;
    67.  
    68.  
    69. new_table = mm_realloc(head->hth_table,
    70. new_len*sizeof(struct event_map_entry*)); //用realloc进行重新分配，分配后直接将原哈希表上的主节点复制到新哈希表上，冲突链表还是原来的不变
    71.  
    72. if (!new_table) //如果realloc还是分配失败，就退出
    73. return -1;
    74. //执行到这里说明realloc分配成功，新分配的哈希表与原来的哈希表在原有位置上的延伸，延伸部分还需要初始化
    75. memset(new_table + head->hth_table_length, 0,
    76. (new_len - head->hth_table_length)*sizeof(struct event_map_entry*) //初始化延伸部分的空间
    77. );
    78.  
    79. for (b=0; b < head->hth_table_length; ++b) //遍历哈希表上的主节点
    80. {
    81. struct event_map_entry *e, **pE;
    82.  
    83. for (pE = &new_table[b], e = *pE; e != NULL; e = *pE) //从主节点开始遍历冲突链表
    84. {
    85. //计算重新哈希后在新哈希表中的位置
    86. #ifdef HT_CACHE_HASH_VALUES
    87. b2 = (e)->map_node.hte_hash % new_len;
    88. #else
    89. b2 = (hashsocket(*elm)) % new_len;
    90. #endif
    91. //对于冲突链A->B->C.
    92. //pE是二级指针，存放的是A元素的hte_next指针的地址值
    93. //e指向B元素。
    94.  
    95. //如果重新哈希取模后还是原来的位置
    96. if (b2 == b)
    97. {
    98. //此时，无需修改。接着处理冲突链中的下一个元素即可
    99. //pE向前移动，存放B元素的hte_next指针的地址值
    100. pE = &e->map_node.hte_next; //就不用更改当前结点，直接到冲突链下一个结点
    101. }
    102. else//重新哈希取模后需要改变位置
    103. {
    104. *pE = e->map_node.hte_next; //直接把当前结点的下一个结点放到当前结点的位置上，相当于从冲突链表中删除当前结点
    105.  
    106. e->map_node.hte_next = new_table[b2]; //再将当前结点以头插形式放到新的位置上去
    107. new_table[b2] = e;
    108. }
    109.  
    110. //这种再次哈希的方式，很有可能会对某些元素操作两次。
    111. //当某个元素第一次在else中处理，那么它就会被哈希到正确的节点
    112. //的冲突链上。随着外循环的进行，处理到正确的节点时。在遍历该节点
    113. //的冲突链时，又会再次处理该元素。此时，就会在if中处理。而不会
    114. //进入到else中。
    115. }
    116. }
    117.  
    118. head->hth_table = new_table; //更新哈希表
    119. }
    120. //更新event_io_map中的相关信息
    121. head->hth_table_length = new_len;
    122. head->hth_prime_idx = prime_idx;
    123. head->hth_load_limit = new_load_limit;
    124.  
    125. return 0;
    126. }

    哈希表元素插入

           向哈希表中插入一个元素，就是先求得插入元素elm在哈希表中的位置，不管这个位置是否有元素，都直接以头插法的形式将新元素插在最前面。之所以采用头插法，是按照“最近新插入的元素可能在未来会被经常使用”的原则，插在链表头部这样即使发生了冲突，访问起来效率也更高。

    1. static inline void
    2. event_io_map_HT_INSERT(struct event_io_map *head,
    3. struct event_map_entry *elm) //哈希表插入一个元素
    4. {
    5. struct event_map_entry **p;
    6. if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit)
    7. event_io_map_HT_GROW(head, head->hth_n_entries+1); //如果哈希表未分配，或者哈希表超到或者达到扩容阈值（表明不能再插入新元素），就需要扩容
    8.  
    9. ++head->hth_n_entries; //哈希表元素加1
    10.  
    11. #ifdef HT_CACHE_HASH_VALUES
    12. do
    13. { //计算哈希值并进行缓存，后面获取哈希值时就不需要再调用哈希函数了
    14. (elm)->map_node.hte_hash = hashsocket(elm);
    15. } while (0);
    16.  
    17. p = &((head)->hth_table[((elm)->map_node.hte_hash)
    18. % head->hth_table_length]); //找到哈希表上该哈希值取模后的位置
    19. #else
    20. p = &((head)->hth_table[(hashsocket(*elm))%head->hth_table_length]);
    21. #endif
    22.  
    23.  
    24. //使用头插法，即后面才插入的链表，反而会在冲突链表头。
    25. elm->map_node.hte_next = *p;
    26. *p = elm;
    27. }

    哈希表元素替换

           哈希表元素替换，实际上是替换元素的地址，先传入一个元素elm，然后寻找哈希表中与该元素fd相同的元素，然后将该元素的地址替换为新元素的地址，并将该元素的冲突链接在新元素的后面，从而完成替换。

    1. static inline struct event_map_entry *
    2. event_io_map_HT_REPLACE(struct event_io_map *head,
    3. struct event_map_entry *elm) //替换哈希表中的结点元素
    4. {
    5. struct event_map_entry **p, *r;
    6.  
    7. if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit) //如果哈希表未分配或者元素个数达到扩容阈值，那么就进行扩容
    8. event_io_map_HT_GROW(head, head->hth_n_entries+1);
    9.  
    10. #ifdef HT_CACHE_HASH_VALUES
    11. do
    12. {
    13. (elm)->map_node.hte_hash = hashsocket(elm); //缓存哈希值
    14. } while(0);
    15. #endif
    16.  
    17. p = _event_io_map_HT_FIND_P(head, elm); //p为哈希表中fd与elm相同的结点元素的地址
    18.  
    19. r = *p; //保存原结点元素地址
    20. *p = elm; //给结点元素赋新值，这里是让哈希表上原来元素的地址换成了新元素的地址，完成了替换
    21.  
    22. if (r && (r!=elm)) //如果原结点元素与新元素不同
    23. {
    24. elm->map_node.hte_next = r->map_node.hte_next; //把原结点元素后面的冲突链接上去
    25.  
    26. r->map_node.hte_next = NULL;
    27. return r; //返回被替换掉的元素
    28. }
    29. else //到这里说明哈希表在新元素对应的地方没有元素，或者原结点元素与新结点元素就是同一个
    30. {
    31. ++head->hth_n_entries; //为什么元素个数加1？ 不明白
    32. return NULL; //返回NULL，表示哈希表中对应位置没有元素，无法完成替换，或者新老元素本身就相同，无需替换
    33. }
    34. }

    哈希表元素删除

           哈希表元素删除就是找到哈希表中某一个元素fd与传入参数elm的fd相同的元素并删除该元素。不过需要注意的是，这里并没有对被删除的元素进行释放，因此调用该函数后应当对返回值指针进行释放。

    1. static inline struct event_map_entry *
    2. event_io_map_HT_REMOVE(struct event_io_map *head,
    3. struct event_map_entry *elm) //哈希表元素删除
    4. {
    5. struct event_map_entry **p, *r;
    6.  
    7. #ifdef HT_CACHE_HASH_VALUES
    8. do
    9. {
    10. (elm)->map_node.hte_hash = hashsocket(elm);
    11. } while (0);
    12. #endif
    13.  
    14. p = _event_io_map_HT_FIND_P(head,elm); //p是找到的哈希表上元素的地址
    15.  
    16. if (!p || !*p)//没有找到 //p为NULL说明哈希表未分配，*p为NULL说明没有找到elm
    17. return NULL;
    18.  
    19. r = *p; //r指向要被删除的元素
    20. *p = r->map_node.hte_next; //把该元素的地址换为它在冲突链上下一个元素的地址 实现删除
    21. r->map_node.hte_next = NULL;
    22.  
    23. --head->hth_n_entries; //元素数目减1
    24.  
    25. return r;
    26. }

    自定义条件删除元素

           如前面的删除元素函数，是删除fd相同的那个元素，删除的依据就是fd相同。这里还提供了一种自己定义删除依据的删除方式：先自定义一个函数fn，在遍历哈希表元素的时候，将各个元素与传入的elm作为参数调用fn，如果fn返回true，那么就将哈希表中该元素删除，如下所示：（可以看到，在该函数中对于删除的元素并没有进行释放，并且也没有返回被删除元素的地址，这样也无法从外部对删除的元素进行释放）

    1. static inline void
    2. event_io_map_HT_FOREACH_FN(struct event_io_map *head,
    3. int (*fn)(struct event_map_entry *, void *),
    4. void *data) //遍历哈希表上所有元素，以各个元素去调用fn，如果fn返回true则删除该元素
    5. {
    6. unsigned idx;
    7. struct event_map_entry **p, **nextp, *next;
    8.  
    9. if (!head->hth_table)
    10. return;
    11.  
    12. for (idx=0; idx < head->hth_table_length; ++idx) //遍历哈希表主链
    13. {
    14. p = &head->hth_table[idx]; //取哈希表主链上元素的地址
    15.  
    16. while (*p) //如果在该处有元素
    17. {
    18. nextp = &(*p)->map_node.hte_next; //nextp保存哈希表上该元素在冲突链上下一个元素的地址
    19. next = *nextp; //next保存该元素在冲突链上的下一个元素
    20.  
    21. //对B元素进行检查
    22. if (fn(*p, data))
    23. {
    24. --head->hth_n_entries;
    25.  
    26. *p = next; //直接将该元素的地址替换为下一个元素的地址，相当于删除该元素
    27. }
    28. else
    29. {
    30. p = nextp; //冲突链上下一个元素地址
    31. }
    32. }
    33. }
    34. }

    哈希表第一个非空元素

            哈希表第一个非空元素一定是在主链上，因此直接遍历哈希表的主链，不用去管冲突链，找到主链上第一个非空的元素返回其地址即可。由于主链上的元素都是event_map_entry *类型，因此这里返回的地址是event_map_entry **类型。

    1. static inline struct event_map_entry **
    2. event_io_map_HT_START(struct event_io_map *head) //返回哈希表主链上第一个非空元素的地址
    3. {
    4. unsigned b = 0;
    5.  
    6. while (b < head->hth_table_length)
    7. {
    8. if (head->hth_table[b])
    9. return &head->hth_table[b];
    10.  
    11. ++b;
    12. }
    13.  
    14. return NULL;
    15. }

    哈希表下一个元素

             这里提供了两个取下一个元素地址的函数event_io_map_HT_NEXT和event_io_map_HT_NEXT_RMV。前者是直接查找传入的elm所在冲突链上的下一个元素并返回其地址的指针，如果该元素是冲突链上最后一个元素，那么就从主链上找到下一个非空的元素，返回其地址的指针；后者则是返回下一个元素地址的指针，并且将elm从哈希表中删除。

    1. static inline struct event_map_entry **
    2. event_io_map_HT_NEXT(struct event_io_map *head,
    3. struct event_map_entry **elm) //返回elm在哈希表中下一个元素的地址的指针，先从elm所在冲突链中找到下一个元素，如果没有就从主链上下一个位置开始找
    4. {
    5. if ((*elm)->map_node.hte_next) //返回elm的下一个结点的地址
    6. {
    7. return &(*elm)->map_node.hte_next;
    8. }
    9. else //如果elm是其所在冲突链的最后一个结点，那么就找到下一条冲突链的第一个结点
    10. {
    11. #ifdef HT_CACHE_HASH_VALUES
    12. unsigned b = (((*elm)->map_node.hte_hash)
    13. % head->hth_table_length) + 1; //从elm所在冲突链在主链上位置的后一个开始
    14. #else
    15. unsigned b = ( (hashsocket(*elm)) % head->hth_table_length) + 1;
    16. #endif
    17.  
    18. while (b < head->hth_table_length)
    19. {
    20. //找到了第一个非空的结点，就返回该结点地址
    21. if (head->hth_table[b])
    22. return &head->hth_table[b];
    23. ++b;
    24. }
    25.  
    26. return NULL; //返回NULL说明elm所在冲突链包括主链后面都没有非空结点了
    27. }
    28. }
    1. static inline struct event_map_entry **
    2. event_io_map_HT_NEXT_RMV(struct event_io_map *head,
    3. struct event_map_entry **elm) //返回哈希表上elm的下一个元素的地址，如果是在elm的冲突链上，那么就把elm删除
    4. {
    5. #ifdef HT_CACHE_HASH_VALUES
    6. unsigned h = ((*elm)->map_node.hte_hash);
    7. #else
    8. unsigned h = (hashsocket(*elm));
    9. #endif
    10. //h中保存elm对应的哈希值
    11.  
    12. *elm = (*elm)->map_node.hte_next; //elm冲突链上下一个元素的地址，这里也相当于直接用elm下一个元素的地址替换elm的地址，删除了哈希表上elm的地址
    13.  
    14. --head->hth_n_entries; //哈希表元素个数减1
    15.  
    16. if (*elm) //返回elm所在冲突链上下一个元素的地址
    17. {
    18. return elm;
    19. }
    20. else //如果elm在其冲突链上是最后一个元素，那么就从后面的主链上找第一个非空的元素
    21. {
    22. unsigned b = (h % head->hth_table_length)+1;
    23.  
    24. while (b < head->hth_table_length)
    25. {
    26. if (head->hth_table[b])
    27. return &head->hth_table[b];
    28.  
    29. ++b;
    30. }
    31.  
    32. return NULL;
    33. }
    34. }

    释放哈希表

    1. void event_io_map_HT_CLEAR(struct event_io_map *head)
    2. {
    3. if (head->hth_table) //释放哈希表
    4. mm_free(head->hth_table);
    5.  
    6. head->hth_table_length = 0;
    7.  
    8. event_io_map_HT_INIT(head); //重新初始化event_io_map
    9. }

    向event_io_map中添加event

          如前所述，当对一个io event调用event_add时，Libevent就会把这个io event添加到event_io_map中，添加到event_io_map所调用的函数是evmap_io_add，其定义如下所示：

    1. int
    2. evmap_io_add(struct event_base *base, evutil_socket_t fd, struct event *ev)
    3. {
    4. const struct eventop *evsel = base->evsel; //得到event所绑定的base对应的后端方法
    5. struct event_io_map *io = &base->io; //得到base对应的iomap
    6. struct evmap_io *ctx = NULL; //指向fd所对应的那个evmap_io，evmap_io中又含有一个event双向链表
    7. int nread, nwrite, retval = 0;
    8. short res = 0, old = 0; //old用于记录下fd所对应的事件链表中在ev未插入前的所有事件对应了哪几种类型（write/read）
    9. struct event *old_ev;
    10.  
    11. EVUTIL_ASSERT(fd == ev->ev_fd); //确保传入的fd等于event的fd
    12.  
    13. if (fd < 0)
    14. return 0;
    15.  
    16. #ifndef EVMAP_USE_HT //如果不使用哈希，那么用的就是signal_map
    17. if (fd >= io->nentries) { //如果fd大于当前哈希表中的元素数目就重新分配
    18. if (evmap_make_space(io, fd, sizeof(struct evmap_io *)) == -1)
    19. return (-1);
    20. }
    21. #endif
    22. GET_IO_SLOT_AND_CTOR(ctx, io, fd, evmap_io, evmap_io_init,
    23. evsel->fdinfo_len);
    24. //ctx就成为了fd对应的那个evmap_io的指针
    25. nread = ctx->nread; //记录下fd所有event中读事件实木
    26. nwrite = ctx->nwrite;//记录下fd所有event中写事件数目
    27.  
    28. if (nread) //如果fd对应的事件链表中有读类型事件
    29. old |= EV_READ; //表明在ev插入之前fd对应的event链表中就已经存在读类型事件了
    30. if (nwrite) //如果fd对应的事件链表中有写类型事件
    31. old |= EV_WRITE; //表明在ev插入之前fd对应的event链表中就已经存在写类型事件了
    32.  
    33. if (ev->ev_events & EV_READ) { //如果添加的ev为读类型
    34. if (++nread == 1) //读事件数目加1
    35. res |= EV_READ;
    36. }
    37. if (ev->ev_events & EV_WRITE) { //如果添加的ev为写类型
    38. if (++nwrite == 1) //写事件数目加1
    39. res |= EV_WRITE;
    40. }
    41. if (EVUTIL_UNLIKELY(nread > 0xffff || nwrite > 0xffff)) {
    42. event_warnx("Too many events reading or writing on fd %d",
    43. (int)fd);
    44. return -1;
    45. }
    46. //此时还没有将ev插入到fd下的那个链表中，遍历整个链表，需要保证fd下的链表中所有event要么都是ET要么都不是ET，不能混合使用
    47. if (EVENT_DEBUG_MODE_IS_ON() &&
    48. (old_ev = TAILQ_FIRST(&ctx->events)) &&
    49. (old_ev->ev_events&EV_ET) != (ev->ev_events&EV_ET)) {
    50. event_warnx("Tried to mix edge-triggered and non-edge-triggered"
    51. " events on fd %d", (int)fd);
    52. return -1;
    53. }
    54.  
    55. if (res) {//如果有读或写事件，就将event添加到base中
    56. void *extra = ((char*)ctx) + sizeof(struct evmap_io);
    57. /* XXX(niels): we cannot mix edge-triggered and
    58. * level-triggered, we should probably assert on
    59. * this. */
    60. if (evsel->add(base, ev->ev_fd,
    61. old, (ev->ev_events & EV_ET) | res, extra) == -1) //调用对应后端的add函数进行添加
    62. return (-1);
    63. retval = 1;
    64. }
    65. //记录fd下的读写event数量
    66. ctx->nread = (ev_uint16_t) nread;
    67. ctx->nwrite = (ev_uint16_t) nwrite;
    68. TAILQ_INSERT_TAIL(&ctx->events, ev, ev_io_next); //将event插入到fd对应的事件链表中
    69.  
    70. return (retval);
    71. }

           这里如果不是使用哈希结构的话，event_io_map实际上就相当于一个数组，数组的元素索引就对应了一个fd值，因此当fd大于或等于该数组的元素个数，说明此时该数组就需要扩容了，就调用evmap_make_space函数进行扩容，可以参考非windows下的event_io_map实现。

           需要注意的是，这里的evmap_add函数只是将event添加到Libevent自定义的数据结构evmap_io中，而真正添加到内核事件监听集合中的操作实际上是通过event_base所绑定的后端方法的add函数来实现的。可以参考libevent对epoll的封装。

    激活event_io_map中的event

           激活event_io_map中的event使用的是evmap_io_active函数，不过这并不是一个对用户开放的接口。实现原理就是将fd对应的双向链表中发生了感兴趣事件的event通过event_active_nolock函数添加到激活队列中。其定义如下：

    1. void
    2. evmap_io_active(struct event_base *base, evutil_socket_t fd, short events)//将event_io_map中fd对应的event双向链表中关注事件类型与events有共同部分的事件添加到激活队列中
    3. {
    4. struct event_io_map *io = &base->io;
    5. struct evmap_io *ctx;
    6. struct event *ev;
    7.  
    8. #ifndef EVMAP_USE_HT
    9. EVUTIL_ASSERT(fd < io->nentries);
    10. #endif
    11. GET_IO_SLOT(ctx, io, fd, evmap_io); //找到fd对应的event_io_map中的event双向链表
    12.  
    13. EVUTIL_ASSERT(ctx);
    14. TAILQ_FOREACH(ev, &ctx->events, ev_io_next) { //遍历该链表
    15. if (ev->ev_events & events) //如果event的关注事件类型与发生的事件类型有共同部分
    16. event_active_nolock(ev, ev->ev_events & events, 1); //插入到激活队列中
    17. }
    18. }

              event_active_nolock函数可以参考事件的激活。

    删除event_io_map中的event

             evmap_io_del函数实际上就是evmap_io_add的逆操作，即是将event从event_io_map中删除，定义如下所示：

    1. int
    2. evmap_io_del(struct event_base *base, evutil_socket_t fd, struct event *ev)
    3. {
    4. const struct eventop *evsel = base->evsel;
    5. struct event_io_map *io = &base->io;
    6. struct evmap_io *ctx;
    7. int nread, nwrite, retval = 0;
    8. short res = 0, old = 0;
    9.  
    10. if (fd < 0)
    11. return 0;
    12.  
    13. EVUTIL_ASSERT(fd == ev->ev_fd);
    14.  
    15. #ifndef EVMAP_USE_HT
    16. if (fd >= io->nentries)
    17. return (-1);
    18. #endif
    19.  
    20. GET_IO_SLOT(ctx, io, fd, evmap_io); //ctx指向fd对应的那个evmap_io
    21.  
    22. nread = ctx->nread; //evmap_io中读事件数目
    23. nwrite = ctx->nwrite;//evmap_io中写事件数目
    24. //old保存删除前evmap_io中所有event的事件类型有哪些种类（读或写）
    25. if (nread)
    26. old |= EV_READ;
    27. if (nwrite)
    28. old |= EV_WRITE;
    29.  
    30. if (ev->ev_events & EV_READ) {//如果需要被删除的事件对读事件感兴趣
    31. if (--nread == 0) //读事件数目减1
    32. res |= EV_READ;
    33. EVUTIL_ASSERT(nread >= 0);
    34. }
    35. if (ev->ev_events & EV_WRITE) {//如果需要被删除的时间对写事件感兴趣
    36. if (--nwrite == 0) //写事件数目减1
    37. res |= EV_WRITE;
    38. EVUTIL_ASSERT(nwrite >= 0);
    39. }
    40.  
    41. if (res) {
    42. void *extra = ((char*)ctx) + sizeof(struct evmap_io);
    43. if (evsel->del(base, ev->ev_fd, old, res, extra) == -1) //调用后端的del函数
    44. return (-1);
    45. retval = 1;
    46. }
    47.  
    48. ctx->nread = nread;
    49. ctx->nwrite = nwrite;
    50. TAILQ_REMOVE(&ctx->events, ev, ev_io_next); //从evmap_io的双向链表中删除event
    51.  
    52. return (retval);
    53. }

           对于evmap_io_event函数本身来说，只是将这个event从Libevent自定义数据结构event_io_map中删除，而实际上将该事件从内核监听事件集合中删除的函数还是通过event_base所绑定的后端方法中的del函数实现的。可以参考libevent对epoll的封装

    转载自：https://blog.csdn.net/qq_28114615/article/details/95887231
  • 相关阅读:
    Linux之硬件资源管理
    Linux之vi 文本编辑命令
    [2]窗口程序的创建
    [1]cs辅助项目分解
    1.3 Windows操作系统
    （PYG）学习去除软件自效验
    CSUST 4006-你真的会树套树套树吗？（贪心|dp）
    CSUST 4003-你真的会泡面吗？（优先队列模拟）
    2020牛客暑期多校第八场I-Interesting Computer Game（离散化+并查集）
    2020牛客暑期多校K-Kabaleo Lite（贪心）
  • 原文地址：https://www.cnblogs.com/cnhk19/p/14410996.html
Copyright © 2011-2022 走看看