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