libevent: 源代码分析-事件分发

libevent事件分发由event_dispatch函数负责处理。

首先是要调用struct event_base实例的evsel成员的dispatch函数，这个dispatch函数根据选择的不同事件处理机制，调用对应的dispatch函数，比如epoll, dispatch函数对应应该是epoll_dispatch，poll对应应该是poll_dispatch，select对应应该是select_dispatch，/dev/poll对应应该是devpoll_dispatch，kqueue对应应该是kq_dispatch，端口对应应该是evport_dispatch。虽然名字理解起来为“分发”，它们其实主要就是轮训触发的“事件”。这里的“事件”应该理解为IO事件更准确，这个IO事件是个比较抽象的概念，且不同的事件处理机制中，有些是“名副其实”的事件驱动的，如epoll，poll，有些并不那么“名副其实”，如select，我们轮训的其实是fd_set。

 

调用struct event_base实例的evsel成员的dispatch函数的时候，通常会轮训到多个事件，libevent将这些事件加入到一个活动队列中，这个活动队列是个优先级队列，根据事件的优先级将事件加入到对应优先级的队列中。这个队列是个尾队列。然后libevent去消费处理这些活动事件，对应事件处理函数去分发处理。

 

如果活动队列没有要处理的事件，event_dispatch函数将退出。

 

event_dispatch

函数原型

int event_dispatch(void);

 

int
event_dispatch(void)
{
	return (event_loop(0));
}

这里直接调用的event_loop函数。

event_loop函数将调用struct event_base实例的evsel成员的dispatch函数去分发事件。这个struct event_base实例通常是内部全局的struct event_base实例，如果是通过event_base_new初始化libevent的话，则是通过调用event_base_set设置的事件的ev_base，指向初始化的struct event_base实例。

 

 

event_loop

函数原型

int event_loop(int);

int
event_loop(int flags)
{
	return event_base_loop(current_base, flags);
}

函数event_loop又直接调用了event_base_loop函数。

 

event_base_loop

函数原型

int event_base_loop(struct event_base *, int);

int
event_base_loop(struct event_base *base, int flags)
{
	const struct eventop *evsel = base->evsel;
	void *evbase = base->evbase;
	struct timeval tv;
	struct timeval *tv_p;
	int res, done;

	/* clear time cache */
	base->tv_cache.tv_sec = 0;

	if (base->sig.ev_signal_added)
		evsignal_base = base;
	done = 0;
	while (!done) {
		/* Terminate the loop if we have been asked to */
		if (base->event_gotterm) {
			base->event_gotterm = 0;
			break;
		}

		if (base->event_break) {
			base->event_break = 0;
			break;
		}

		/* You cannot use this interface for multi-threaded apps */
		while (event_gotsig) {
			event_gotsig = 0;
			if (event_sigcb) {
				res = (*event_sigcb)();
				if (res == -1) {
					errno = EINTR;
					return (-1);
				}
			}
		}

		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);
		}
		
		/* If we have no events, we just exit */
		if (!event_haveevents(base)) {
			event_debug(("%s: no events registered.", __func__));
			return (1);
		}

		/* update last old time */
		gettime(base, &base->event_tv);

		/* clear time cache */
		base->tv_cache.tv_sec = 0;

		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);
}

激活事件

event_active

函数原型

void event_active(struct event *, int, short);

void
event_active(struct event *ev, int res, short ncalls)
{
	/* We get different kinds of events, add them together */
	if (ev->ev_flags & EVLIST_ACTIVE) {
		ev->ev_res |= res;
		return;
	}

	ev->ev_res = res;
	ev->ev_ncalls = ncalls;
	ev->ev_pncalls = NULL;
	event_queue_insert(ev->ev_base, ev, EVLIST_ACTIVE);
}

event_active直接将激活的事件放入对应活动队列中。尾队列。

 

处理活动事件

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 < base->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)
			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) {
			  	ev->ev_pncalls = NULL;
				return;
			}
		}
		ev->ev_pncalls = NULL;
	}
}