libevent: 源代码分析-libevent初始化

libevent初始化

event_init

函数原型

struct event_base *event_init(void);

 

最后需要通过event_base_free释放event_base：

event_base_free

函数原型

void event_base_free(struct event_base *);

 

libevent的一个最简单的例子

#include <stdio.h>
#include <event.h>

int main()
{
  struct event_base *event_base;

  event_base = event_init();
  printf("libevent: version=%s\n", event_get_version());
  printf("libevent: method=%s\n", event_get_method());
  event_base_free(event_base);
  return 0;
}

 

初始化代码

 

struct event_base *
event_init(void)
{
	struct event_base *base = event_base_new();

	if (base != NULL)
		current_base = base;

	return (base);
}

在使用libevent之前，需要对libevent进行初始化。libevent通过event_init对libevent进行初始化。它直接调用event_base_new进行初始化，所以也可以通过event_base_new对libevent进行初始化。

 

 

不过这两种初始化方式在后面的使用上有些不同。libevent的初始化主要在event_base_new，它负责创建并初始化一个struct event_base实例。libevent的设计在初始化时还维护了一个内部全局的struct event_base实例，通过event_base_new的方式不会为这个内部全局实例赋值初始化，event_init会对这个内部全局实例赋值初始化。

 

下面将讲event_base_new是怎么初始化的

 

event_base_new初始化

 

struct event_base *
event_base_new(void)
{
	int i;
	struct event_base *base;

	if ((base = calloc(1, sizeof(struct event_base))) == NULL)
		event_err(1, "%s: calloc", __func__);

	event_sigcb = NULL;
	event_gotsig = 0;

	detect_monotonic();
	gettime(base, &base->event_tv);
	
	min_heap_ctor(&base->timeheap);
	TAILQ_INIT(&base->eventqueue);
	base->sig.ev_signal_pair[0] = -1;
	base->sig.ev_signal_pair[1] = -1;
	
	base->evbase = NULL;
	for (i = 0; eventops[i] && !base->evbase; i++) {
		base->evsel = eventops[i];

		base->evbase = base->evsel->init(base);
	}

	if (base->evbase == NULL)
		event_errx(1, "%s: no event mechanism available", __func__);

	if (evutil_getenv("EVENT_SHOW_METHOD")) 
		event_msgx("libevent using: %s\n",
			   base->evsel->name);

	/* allocate a single active event queue */
	event_base_priority_init(base, 1);

	return (base);
}

这里首先为struct event_base实例分配相应的内存，初始化内部全局变量event_sigcb，event_gotsig，检查是否支持MONOTONIC时间，如果支持，内部全局变量use_monotonic设置为1。

调用gettime获取当前时间，先从tv_cache缓冲中获取，不过初始化的时候tv_cache的tv_sec通常为0，不会从缓存中取，如果支持支持MONOTONIC时间，则获取的是MONOTONIC时间，否则调用evutil_gettimeofday通过gettimeofday或者_ftime获取。

调用min_heap_ctor创建一个min_heap，初始化timeheap

初始化尾队列eventqueue

初始化sig的ev_signal_pair成员

遍历eventops，选择一个事件机制。初始化evsel，将第一个遍历到的struct eventop结构体类型的事件机制的操作对它进行初始化。同时调用evsel的init成员函数初始化evbase。这是一个void *类型。如果没有找到，返回错误。

 

对于epoll, init成员函数应该是epoll_init，初始化的时候返回一个struct epollop结构体类型的指针给evbase。

对于poll, init成员函数应该是poll_init，初始化的时候返回一个struct pollop结构体类型的指针给evbase。

对于select, init成员函数应该是select_init，初始化的时候返回一个struct selectop结构体类型的指针给evbase。

对于/dev/poll, init成员函数应该是devpoll_init，初始化的时候返回一个struct devpollop结构体类型的指针给evbase。

对于kqueue, init成员函数应该是kq_init，初始化的时候返回一个struct kqop结构体类型的指针给evbase。

对于端口, init成员函数应该是evport_init，初始化的时候返回一个struct evport_data结构体类型的指针给evbase。

 

初始化一组尾队列activequeues，nactivequeues表示队列个数，默认为1个。通过TAILQ_INIT对每个尾队列进行初始化，队头元素指针tqh_first指向NULL，队尾元素指针tqh_last指向队头元素指针tqh_first。

 

这组尾队列activequeues实际代表了不同优先级的事件队列。

 

 

初始化事件结构代码

event_set

函数原型

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

 

 

void
event_set(struct event *ev, int fd, short events,
	  void (*callback)(int, short, void *), void *arg)
{
	/* Take the current base - caller needs to set the real base later */
	ev->ev_base = current_base;

	ev->ev_callback = callback;
	ev->ev_arg = arg;
	ev->ev_fd = fd;
	ev->ev_events = events;
	ev->ev_res = 0;
	ev->ev_flags = EVLIST_INIT;
	ev->ev_ncalls = 0;
	ev->ev_pncalls = NULL;

	min_heap_elem_init(ev);

	/* by default, we put new events into the middle priority */
	if(current_base)
		ev->ev_pri = current_base->nactivequeues/2;
}

这里主要初始化事件，以及触发事件的fd, 触发事件后的回调函数，以及传入的参数。另外就是，初始化事件的优先级，对应优先级的事件放在libevent初始化时的那组优先级队列（尾队列）对应的那个队列。默认情况下，优先级初始化为中间优先级。

事件的ev_base指向内部全局的struct event_base实例。

如果是通过event_base_new初始化libevent的话，需要通过调用event_base_set将设置事件的ev_base，指向初始化的struct event_base实例。

event_base_set

函数原型

int event_base_set(struct event_base *, struct event *);

int
event_base_set(struct event_base *base, struct event *ev)
{
	/* Only innocent events may be assigned to a different base */
	if (ev->ev_flags != EVLIST_INIT)
		return (-1);

	ev->ev_base = base;
	ev->ev_pri = base->nactivequeues/2;

	return (0);
}

函数event_base_set除了设置事件的ev_base，也初始化事件的优先级，对应优先级的事件放在libevent初始化时的那组优先级队列（尾队列）对应的那个队列。默认情况下，优先级初始化为中间优先级。

 

 

添加事件

event_add

函数原型

int event_add(struct event *ev, const struct timeval *timeout);

 

int
event_add(struct event *ev, const struct timeval *tv)
{
	struct event_base *base = ev->ev_base;
	const struct eventop *evsel = base->evsel;
	void *evbase = base->evbase;
	int res = 0;

	event_debug((
		 "event_add: event: %p, %s%s%scall %p",
		 ev,
		 ev->ev_events & EV_READ ? "EV_READ " : " ",
		 ev->ev_events & EV_WRITE ? "EV_WRITE " : " ",
		 tv ? "EV_TIMEOUT " : " ",
		 ev->ev_callback));

	assert(!(ev->ev_flags & ~EVLIST_ALL));

	/*
	 * prepare for timeout insertion further below, if we get a
	 * failure on any step, we should not change any state.
	 */
	if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
		if (min_heap_reserve(&base->timeheap,
			1 + min_heap_size(&base->timeheap)) == -1)
			return (-1);  /* ENOMEM == errno */
	}

	if ((ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL)) &&
	    !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE))) {
		res = evsel->add(evbase, ev);
		if (res != -1)
			event_queue_insert(base, ev, EVLIST_INSERTED);
	}

	/* 
	 * we should change the timout state only if the previous event
	 * addition succeeded.
	 */
	if (res != -1 && tv != NULL) {
		struct timeval now;

		/* 
		 * we already reserved memory above for the case where we
		 * are not replacing an exisiting timeout.
		 */
		if (ev->ev_flags & EVLIST_TIMEOUT)
			event_queue_remove(base, ev, EVLIST_TIMEOUT);

		/* Check if it is active due to a timeout.  Rescheduling
		 * this timeout before the callback can be executed
		 * removes it from the active list. */
		if ((ev->ev_flags & EVLIST_ACTIVE) &&
		    (ev->ev_res & EV_TIMEOUT)) {
			/* See if we are just active executing this
			 * event in a loop
			 */
			if (ev->ev_ncalls && ev->ev_pncalls) {
				/* Abort loop */
				*ev->ev_pncalls = 0;
			}
			
			event_queue_remove(base, ev, EVLIST_ACTIVE);
		}

		gettime(base, &now);
		evutil_timeradd(&now, tv, &ev->ev_timeout);

		event_debug((
			 "event_add: timeout in %ld seconds, call %p",
			 tv->tv_sec, ev->ev_callback));

		event_queue_insert(base, ev, EVLIST_TIMEOUT);
	}

	return (res);
}

如果初始化事件指定了EV_READ，EV_WRITE，EV_SIGNAL，并且事件标识不是EVLIST_INSERTED，EVLIST_ACTIVE，调用struct event_base实例的evsel成员的add函数添加事件。这个struct event_base实例是事件的ev_base成员，在初始化事件（event_set）的时候会设置，通常是内部全局的struct event_base实例，如果是通过event_base_new初始化libevent的话，则是通过调用event_base_set设置的事件的ev_base，指向初始化的struct event_base实例。

 

对于epoll, add成员函数应该是epoll_add。

对于poll, add成员函数应该是poll_add。

对于select, add成员函数应该是select_add。

对于/dev/poll, add成员函数应该是devpoll_add。

对于kqueue, add成员函数应该是kq_add。

对于端口, add成员函数应该是evport_add。

 

如果调用add函数添加事件成功，同时调用event_queue_insert函数将事件添加到队列中，也就是struct event_base实例的eventqueue成员，这是一个尾队列。

 

如果调用add函数添加事件成功，并且指定了超时时间tv的话：

如果事件标识EVLIST_TIMEOUT，将事件从堆timeheap上删除。

如果事件标识EVLIST_ACTIVE，表示事件被激活触发，且事件回调函数调用后返回超时EV_TIMEOUT，如果事件的ev_ncalls不为0，且ev_pncalls不为NULL，则将ev_pncalls指向的变量置为0。然后调用event_queue_remove函数从activequeues队列（尾队列）中删除事件。

 

设置事件的timeout。

 

将事件加入到堆timeheap中。

 

 

 

static void
detect_monotonic(void)
{
#if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
	struct timespec	ts;

	if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
		use_monotonic = 1;
#endif
}

这里就是检查是否可以正常获取MONOTONIC时间。

 

HAVE_CLOCK_GETTIME

执行./autogen.sh后，会生成一个config.h.in配置文件。

cat config.h.in

/* Define to 1 if you have the `clock_gettime' function. */

#undef HAVE_CLOCK_GETTIME

 

再执行./configure后，会生成一个config.h头文件。

cat config.h

/* Define to 1 if you have the `clock_gettime' function. */

#define HAVE_CLOCK_GETTIME 1

 

执行./configure的时候，会检查clock_gettime

checking for clock_gettime... yes

 

CLOCK_MONOTONIC

这个在bits/time.h头文件中有定义

/* Monotonic system-wide clock.  */

#   define CLOCK_MONOTONIC              1

表示从某个起始点开始的单调时间

 

epoll

初始化

 

poll

初始化

 

select

初始化

 

/dev/poll

初始化

 

kqueue

初始化

 

 

端口

初始化