libevent源码浅析(四)

最近刚刚一个项目自己用libevent，因此这几天又把libevent的代码拿出来翻了下，当初看的时候有些似是而非的东西，这次是基本没有了。这篇也算是前面几篇libevent的blog的补充了。
struct　event_base　{
　const　struct　eventop　*evsel;
　void　*evbase;
　int　event_count;　/*　counts　number　of　total　events　*/
　int　event_count_active;　/*　counts　number　of　active　events　*/
　int　event_gotterm;　/*　Set　to　terminate　loop　*/
　int　event_break;　/*　Set　to　terminate　loop　immediately　*/
　/*　active　event　management　*/
　struct　event_list　**activequeues;
　int　nactivequeues;
　/*　signal　handling　info　*/
　struct　evsignal_info　sig;
　struct　event_list　eventqueue;
　struct　timeval　event_tv;
　struct　min_heap　timeheap;
　struct　timeval　tv_cache;
};
我们这里用select来讲，其他的事件驱动器都相似。
我们来看，其中activequeues我们知道是表示激活的事件队列.这里libevent的处理是，select被唤醒后，调用 event_active方法，将此事件插入到activequeues队列中，这里这个队列的实现是用tail queue。然后libevent会执行event_process_active方法，从而从激活队列中，依次执行所激活的事件。这里这个队列之所以是一个指针的指针，是因为，libevent中事件还分为优先级，这样每个优先级都有一个activequeues队列。
记下来我们再来看定时器的实现，libevent会在每次执行循环时，从优先级队列中取出来最小的那个时间，然后将它加入到select中，从而实现定时器。而在每次select超时退出后，libevent会从小到大取出超时时间(直到大于当前时间)，每次和当前时间比较，如果已超时，则会从优先级队列中删除此节点，然后将此超时事件加入到激活队列中。
接下来我们来看相关代码。
int
event_base_loop(struct　event_base　*base,　int　flags)
{
..................................................
　timeout_correct(base,　&tv);
　tv_p　=　&tv;
///判断是否有激活事件，如果没有的话我们则会从优先级队列中取出最小的那个时间。也就是离现在最近的那个超时时间。
　if　(!base->event_count_active　&&　!(flags　&　EVLOOP_NONBLOCK))　{
///下面会介绍这个函数
　　timeout_next(base,　&tv_p);
　}　else　{
　　/*
　　*　if　we　have　active　events,　we　just　poll　new　events
　　*　without　waiting.
　　*/
　　evutil_timerclear(&tv);
　}
.........................................................
　/*　clear　time　cache　*/
　base->tv_cache.tv_sec　=　0;
///调用相关事件驱动引擎的dispatch方法，这个方法中会将已激活的事件加入到激活队列,这里看到tv_p也就是上面取到的超时时间被传入到dispatch。
　res　=　evsel->dispatch(base,　evbase,　tv_p);
　if　(res　==　-1)
　　return　(-1);
　gettime(base,　&base->tv_cache);
///处理超时事件，将所有已超时的事件加入到激活队列。下面我们会介绍这个函数
　timeout_process(base);
　if　(base->event_count_active)　{
　///执行激活事件队列
　　event_process_active(base);
　　if　(!base->event_count_active　&&　(flags　&　EVLOOP_ONCE))
///判断是否退出。
　　done　=　1;
　}　else　if　(flags　&　EVLOOP_NONBLOCK)
　　done　=　1;
　}
　/*　clear　time　cache　*/
　base->tv_cache.tv_sec　=　0;
　event_debug(("%s:　asked　to　terminate　loop.",　__func__));
　return　(0);
}
               
来看timeout_next方法
static　int
timeout_next(struct　event_base　*base,　struct　timeval　**tv_p)
{
　struct　timeval　now;
　struct　event　*ev;
　struct　timeval　*tv　=　*tv_p;
///取出最小的那个时间。
　if　((ev　=　min_heap_top(&base->timeheap))　==　NULL)　{
　/*　if　no　time-based　events　are　active　wait　for　I/O　*/
　*tv_p　=　NULL;
　return　(0);
　}
///得到当前的时间。
　if　(gettime(base,　&now)　==　-1)
　return　(-1);
///已超时则直接退出
　if　(evutil_timercmp(&ev->ev_timeout,　&now,　ev_timeout,　&now,　tv);
　assert(tv->tv_sec　>=　0);
　assert(tv->tv_usec　>=　0);
　event_debug(("timeout_next:　in　%ld　seconds",　tv->tv_sec));
　return　(0);
}
void
timeout_process(struct　event_base　*base)
{
..............................................
　gettime(base,　&now);
///开始遍历此优先级队列
　while　((ev　=　min_heap_top(&base->timeheap)))　{
///如果比当前时间大，则说明还没到超时时间因此直接退出。
　if　(evutil_timercmp(&ev->ev_timeout,　&now,　>))
　　break;
///删除此超时事件，因此我们在使用定时器时，需要我们每次进入定时器后，再次add此事件。
　/*　delete　this　event　from　the　I/O　queues　*/
　event_del(ev);
　event_debug(("timeout_process:　call　%p",
　　ev->ev_callback));
///加入激活队列。
　event_active(ev,　EV_TIMEOUT,　1);
　}
}
               
其中event_active是通过event_queue_insert来插入到激活队列的，因此我们来看这个函数：
void
event_queue_insert(struct　event_base　*base,　struct　event　*ev,　int　queue)
{
..............................................
　ev->ev_flags　|=　queue;
　switch　(queue)　{
///这个主要用来保存所有的激活以及非激活队列，也就是eventqueue.
　case　EVLIST_INSERTED:　
　TAILQ_INSERT_TAIL(&base->eventqueue,　ev,　ev_next);
　break;
　case　EVLIST_ACTIVE:　
///激活队列数加一，并将此事件插入到相应的优先级的激活队列中。
　base->event_count_active++;
　TAILQ_INSERT_TAIL(base->activequeues[ev->ev_pri],
　　　ev,ev_active_next);
　break;
　case　EVLIST_TIMEOUT:　{
///处理超时事件。
　min_heap_push(&base->timeheap,　ev);
　break;
　}
　default:　
　event_errx(1,　"%s:　unknown　queue　%x",　__func__,　queue);
　}
}
最后来看执行激活队列
static　void
event_process_active(struct　event_base　*base)
{
　struct　event　*ev;
　struct　event_list　*activeq　=　NULL;
　int　i;
　short　ncalls;
///取出相应的激活队列
　for　(i　=　0;　i　nactivequeues;　++i)　{
　if　(TAILQ_FIRST(base->activequeues[i])　!=　NULL)　{
　　activeq　=　base->activequeues[i];
　　break;
　}
　}
　assert(activeq　!=　NULL);
///开始遍历上面取出的队列
　for　(ev　=　TAILQ_FIRST(activeq);　ev;　ev　=　TAILQ_FIRST(activeq))　{
　if　(ev->ev_events　&　EV_PERSIST)
///如果有persist标志，则只从激活队列中移除此事件，否则则从全局事件列表中删除此事件。
　　event_queue_remove(base,　ev,　EVLIST_ACTIVE);
　else
　　event_del(ev);
　/*　Allows　deletes　to　work　*/
　ncalls　=　ev->ev_ncalls;
　ev->ev_pncalls　=　&ncalls;
///每个事件的回调函数的调用次数
　while　(ncalls)　{
　　ncalls--;
　　ev->ev_ncalls　=　ncalls;
///调用回调函数
　　(*ev->ev_callback)((int)ev->ev_fd,　ev->ev_res,　ev->ev_arg);
　　if　(event_gotsig　||　base->event_break)
　　return;
　}
　}
}