libevent源码分析(三)

上一篇
本节不讲具体的代码分析，剖析一下libevent底层的链表结构。

一、重要性

struct event { /*...*/                  |       struct event_base {
	TAILQ_ENTRY (event) ev_next;        |           /*此处省好多...*/
	TAILQ_ENTRY (event) ev_active_next; |           /* active event management */
	TAILQ_ENTRY (event) ev_signal_next; |           struct event_list **activequeues;
};                                      |       };

双向链表struct event_list在struct event_base中扮演这重要的角色，它负责管理触发事件。由：

/*libevent-patches-1.4\compat\sys\queue.h*/
#define TAILQ_HEAD(name, type)						\
struct name {								\
	struct type *tqh_first;	/* first element */			\
	struct type **tqh_last;	/* addr of last next element */		\
}

将TAILQ_HEAD (event_list, event)宏借助于具体的宏定义展开得event_list定义：

/*libevent-patches-1.4\event.h*/
struct event_list {								\
	struct event *tqh_first;	/* first element */			\
	struct event **tqh_last;	/* addr of last next element */		\
};

当然对于struct event来说上面所示的几个成员展开后你将发现其和event_list具有相似结构，在以后的事件链接等方面它是将event事件顺利挂在event_base->activequeues上的关键，不信你看吧！

/*libevent-patches-1.4\event.h*/
#define TAILQ_ENTRY(type)						\
struct {								\
	struct type *tqe_next;	/* next element */			\
	struct type **tqe_prev;	/* address of previous next element */	\
}

显然将TAILQ_ENTRY (event)展开会得到一个匿名文件结构：

struct {								
	struct event *tqe_next;	/* next element */			
	struct event **tqe_prev;	/* address of previous next element */	
};

二、具体应用

1.链表的初始化：TAILQ_INIT

    /*libevent-patches-1.4\event.c*/
	base->activequeues = (struct event_list **)
	    calloc(base->nactivequeues, sizeof(struct event_list *)); ...
	for (i = 0; i < base->nactivequeues; ++i) {
		base->activequeues[i] = malloc(sizeof(struct event_list));
		...
		TAILQ_INIT(base->activequeues[i]);
	}
	/*libevent-patches-1.4\compat\sys\queue.h*/
	#define	TAILQ_INIT(head) do {						\
	(head)->tqh_first = NULL;					\
	(head)->tqh_last = &(head)->tqh_first;				\
    } while (0)

2.链表的尾部插入：TAILQ_INSERT_TAIL

示例：TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next);

//libevent-patches-1.4\compat\sys\queue.h
#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.tqe_next = NULL;					\
	(elm)->field.tqe_prev = (head)->tqh_last;			\
	*(head)->tqh_last = (elm);					\
	(head)->tqh_last = &(elm)->field.tqe_next;			\
} while (0)

宏展开得：

do{
   ev->ev_next.tqe_next = NULL; 
   ev->ev_next.tqe_prev = base->eventqueue->tqh_last;
   *(base->eventqueue)->tqh_last = ev;   //->优先级要大于*
   (base->eventqueue)->tqh_last = &(ev)->ev_next.tqe_next;
} while (0);

你会发现其构造及其巧妙，最好在纸上推一推…
这个宏可以将所有的监听事件都加入到base->eventqueue上，该结构是一个struct event_list结构，其第一个成员tqh_first是第一个event事件的地址，而tqh_last最终将指向链表最后一个事件的ev->ev_next.tqe_next成员，而ev->ev_next.tqe_prev成员则永远指向链表中的上一个event事件。

3.链表的头部插入：TAILQ_INSERT_HEAD

示例：TAILQ_INSERT_HEAD(&base->eventqueue, ev, ev_next);

#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
		(head)->tqh_first->field.tqe_prev =			\
		    &(elm)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm)->field.tqe_next;		\
	(head)->tqh_first = (elm);					\
	(elm)->field.tqe_prev = &(head)->tqh_first;			\
} while (0)

宏展开得：

do{
	if ((ev->ev_next.tqe_next = base->eventqueue->tqh_first) != NULL)	
		base->eventqueue->tqh_first->ev_next.tqe_prev =			
		    &ev->ev_next.tqe_next;				
	else								
		base->eventqueue->tqh_last = &ev->ev_next.tqe_next;		
	base->eventqueue->tqh_first = ev;					
	ev->ev_next.tqe_prev = &base->eventqueue->tqh_first;			
} while (0);

可以发现无非是初始化当前事件的ev->ev_next.tqe_next成员为下一个event事件地址，然后更新base->eventqueue->tqh_first值使其永远指向第一个事件，最后设置当前头部事件的ev->ev_next.tqe_prev成员值为自身event指针的指针。

4.链表的移除：TAILQ_REMOVE

示例：TAILQ_REMOVE(&base->eventqueue, ev, ev_next);

//libevent-patches-1.4\compat\sys\queue.h
#define TAILQ_REMOVE(head, elm, field) do {				\
	if (((elm)->field.tqe_next) != NULL)				\
		(elm)->field.tqe_next->field.tqe_prev =			\
		    (elm)->field.tqe_prev;				\
	else								\
		(head)->tqh_last = (elm)->field.tqe_prev;		\
	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
} while (0)

宏展开得：

do{
	if ((ev->ev_next.tqe_next) != NULL)				
		ev->ev_next.tqe_next->ev_next.tqe_prev =			
		    ev->ev_next.tqe_prev;				
	else								
		base->eventqueue->tqh_last = ev->ev_next.tqe_prev;		
	*ev->ev_next.tqe_prev = ev->ev_next.tqe_next;			
} while (0);

只要掌握了链表的插入操作，那么删除操作简单了。分两种情况操作，若其是最后一个事件则将base->eventqueue的tqh_last 成员向前移一位；否则将后一个事件ev->ev_next.tqe_next的前一个事件tqe_prev设置为当前事件的ev_next.tqe_prev事件。最后调整前一个事件*(ev->ev_next.tqe_pre)指向后一个事件ev->ev_next.tqe_next即可。

三、总结

一直以为这个中的链表为双向链表，想当然的以为ev->ev_next.tqe_prev成员指向前一个事件，读完源码才发现tqe_prev成员似乎仍旧保存的是自身event的指针的指针(因为它保存前一个事件的ev->ev_next.tqe_next的地址)，那么设置该成员的意义何在？总之他应该会在某处用到，待以后遇到再说。现在先来看一看某个源文件中关于链表的使用代码：
#define TAILQ_FIRST(head) ((head)->tqh_first)

    //libevent-patches-1.4\event.c
    struct event_list *activeq;
	for (ev = TAILQ_FIRST(activeq); ev; ev = TAILQ_FIRST(activeq)) {
		if (ev->ev_events & EV_PERSIST)
			event_queue_remove(base, ev, EVLIST_ACTIVE);
		else
			event_del(ev);
        ...
	}

此处是每次都将头部事件删去，故每次都可以直接取tqh_first即可，至于使用ev->ev_next.tqe_prev的场景目前尚未遇到。
下一篇