• libevent: 安装 https://www.iteye.com/blog/lobin-2517421

• libevent: 源代码分析-libevent初始化 https://www.iteye.com/blog/lobin-2337381

• libevent: 源代码分析-事件分发 https://www.iteye.com/blog/lobin-2384742

• libevent: event https://www.iteye.com/blog/lobin-2517895

• libevent: bufferevent https://www.iteye.com/blog/lobin-2517893

• libevent: http https://www.iteye.com/blog/lobin-2517422

 

libevent

在讲之前，先介绍struct event_base结构，以及几个内部全局变量，包括内部全局的struct event_base实例。

 

在介绍struct event_base结构之前，还得先介绍几个结构和定义

 

尾队列

尾队列定义

尾队列包括一个next指向下一个元素，这通过是通过一个指针来实现，还有一个prev指向前一个元素的next成员，因为next是通过指针来实现，所以prev通过一个双指针（指针的指针）来实现。如上，tqe_next是一个struct type结构体的指针，它指向下一个truct type结构体元素，tqe_prev是一个struct type结构体的指针的指针，它指向前一个truct type结构体元素的next成员，因为next是一个指针，tqe_prev指向它就应该是一个双指针（指针的指针）。

 

下面定义了尾队列的主要结构以及next，prev的指向是怎么定义的。

 

#define TAILQ_ENTRY(type)						\
struct {								\
	struct type *tqe_next;	/* next element */			\
	struct type **tqe_prev;	/* address of previous next element */	\
}

宏TAILQ_ENTRY定义了一个模板，包括尾队列的主要结构以及next，prev的指向是怎么定义的。

 

 

/*
 * Tail queue definitions.
 */
#define TAILQ_HEAD(name, type)						\
struct name {								\
	struct type *tqh_first;	/* first element */			\
	struct type **tqh_last;	/* addr of last next element */		\
}

宏TAILQ_HEAD定义了一个结构体模板，包括尾队列的第一个元素和最后一个元素的前一个元素的next成员。通过TAILQ_ENTRY，TAILQ_HEAD这两个宏可以定义自己的尾队列结构。

 

如我们想定义一个尾队列：

struct el 

{

  TAILQ_ENTRY(el) el_next;

  // members of struct el

  ...

  ...

}

 

TAILQ_HEAD(tq, el);

 

实际完整结构是这样的：

struct el 

{

  struct

  {

    struct el *tqe_next; /* next element */

    struct el **tqe_prev; /* address of previous next element */

  } el_next;

  // members of struct el

  ...

  ...

}

 

struct tq 

{

  struct el *tqh_first; /* first element */

  struct el **tqh_last; /* addr of last next element */

}

 

 

尾队列初始化

 

/*
 * Tail queue functions.
 */
#define	TAILQ_INIT(head) do {						\
	(head)->tqh_first = NULL;					\
	(head)->tqh_last = &(head)->tqh_first;				\
} while (0)

 

 

 

#define TAILQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).tqh_first }

 

 

 

struct eventop

struct eventop {
	const char *name;
	void *(*init)(struct event_base *);
	int (*add)(void *, struct event *);
	int (*del)(void *, struct event *);
	int (*dispatch)(struct event_base *, void *, struct timeval *);
	void (*dealloc)(struct event_base *, void *);
	/* set if we need to reinitialize the event base */
	int need_reinit;
};

 

ev_sighandler_t

这是个指针函数定义

 

typedef void (*ev_sighandler_t)(int);

 

struct evsignal_info

 

struct evsignal_info {
	struct event ev_signal;
	int ev_signal_pair[2];
	int ev_signal_added;
	volatile sig_atomic_t evsignal_caught;
	struct event_list evsigevents[NSIG];
	sig_atomic_t evsigcaught[NSIG];
#ifdef HAVE_SIGACTION
	struct sigaction **sh_old;
#else
	ev_sighandler_t **sh_old;
#endif
	int sh_old_max;
};

 

 

 

struct event_list

这个是一个尾队列，结构定义如下：

TAILQ_HEAD (event_list, event);

struct event_list {
	struct event *tqh_first;	/* first element */
	struct event **tqh_last;	/* addr of last next element */
}

 

struct evkeyvalq

这个是一个尾队列，结构定义如下：

TAILQ_HEAD (evkeyvalq, evkeyval);

 

struct evkeyvalq {
	struct evkeyval *tqh_first;	/* first element */
	struct evkeyval **tqh_last;	/* addr of last next element */
}

 

struct min_heap

typedef struct min_heap
{
    struct event** p;
    unsigned n, a;
} min_heap_t;

这是个heap结构

p

堆顶

n

堆中元素的个数

a

堆的容量

 

struct event_base

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

struct event_base设计为内部结构，在外面是不能直接访问到struct event_base。包括libevent内部维护的全局的struct event_base实例，在外面也不能直接访问到这个实例。

 

evsel

 

evbase

 

event_count

 

event_count_active

 

event_gotterm

 

event_break

 

activequeues

 

nactivequeues

 

sig

 

eventqueue

 

event_tv

 

timeheap

这是个struct min_heap类型的成员变量，

 

tv_cache

 

 

 

几个内部全局变量，包括内部全局的struct event_base实例

/* Global state */
struct event_base *current_base = NULL;
extern struct event_base *evsignal_base;
static int use_monotonic;

/* Handle signals - This is a deprecated interface */
int (*event_sigcb)(void);		/* Signal callback when gotsig is set */
volatile sig_atomic_t event_gotsig;	/* Set in signal handler */

 

内部全局的struct event_base实例

struct event_base *current_base = NULL;

 

用于信号的内部全局的struct event_base实例

extern struct event_base *evsignal_base;

 

是否支持MONOTONIC时间

static int use_monotonic;

 

信号处理回调

int (*event_sigcb)(void);

 

volatile sig_atomic_t event_gotsig;

另一个比较重要的内部全局变量就是

static const struct eventop *eventops[]

其初始化是这样的，它将所有可能提供的事件机制的操作都初始化进去了。

/* In order of preference */
static const struct eventop *eventops[] = {
#ifdef HAVE_EVENT_PORTS
	&evportops,
#endif
#ifdef HAVE_WORKING_KQUEUE
	&kqops,
#endif
#ifdef HAVE_EPOLL
	&epollops,
#endif
#ifdef HAVE_DEVPOLL
	&devpollops,
#endif
#ifdef HAVE_POLL
	&pollops,
#endif
#ifdef HAVE_SELECT
	&selectops,
#endif
#ifdef WIN32
	&win32ops,
#endif
	NULL
};

所有可能提供的事件机制的操作都是一个struct eventop结构体类型的变量。

 

#ifdef HAVE_EVENT_PORTS
extern const struct eventop evportops;
#endif
#ifdef HAVE_SELECT
extern const struct eventop selectops;
#endif
#ifdef HAVE_POLL
extern const struct eventop pollops;
#endif
#ifdef HAVE_EPOLL
extern const struct eventop epollops;
#endif
#ifdef HAVE_WORKING_KQUEUE
extern const struct eventop kqops;
#endif
#ifdef HAVE_DEVPOLL
extern const struct eventop devpollops;
#endif
#ifdef WIN32
extern const struct eventop win32ops;
#endif

第1个是端口

第2个是select

第3个是poll

第4个是epoll

第5个是kqueue

第6个是/dev/poll

第7个是windows下提供的事件机制

 

 

针对端口提供的struct eventop结构体类型的变量

其初始化如下：

const struct eventop evportops = {
	"evport",
	evport_init,
	evport_add,
	evport_del,
	evport_dispatch,
	evport_dealloc,
	1 /* need reinit */
};

 

针对kqueue提供的struct eventop结构体类型的变量

其初始化如下：

const struct eventop kqops = {
	"kqueue",
	kq_init,
	kq_add,
	kq_del,
	kq_dispatch,
	kq_dealloc,
	1 /* need reinit */
};

 

针对epoll提供的struct eventop结构体类型的变量

其初始化如下：

const struct eventop epollops = {
	"epoll",
	epoll_init,
	epoll_add,
	epoll_del,
	epoll_dispatch,
	epoll_dealloc,
	1 /* need reinit */
};

 

针对/dev/poll提供的struct eventop结构体类型的变量

其初始化如下：

const struct eventop devpollops = {
	"devpoll",
	devpoll_init,
	devpoll_add,
	devpoll_del,
	devpoll_dispatch,
	devpoll_dealloc,
	1 /* need reinit */
};

 

针对poll提供的struct eventop结构体类型的变量

其初始化如下：

const struct eventop pollops = {
	"poll",
	poll_init,
	poll_add,
	poll_del,
	poll_dispatch,
	poll_dealloc,
    0
};

 

 

针对select提供的struct eventop结构体类型的变量

其初始化如下：

 

const struct eventop selectops = {
	"select",
	select_init,
	select_add,
	select_del,
	select_dispatch,
	select_dealloc,
	0
};

 

 

 

select

 

poll

 

epoll

 

/dev/poll

 

#include <sys/devpoll.h>

 

kqueue

写道

kqueue, kevent -- kernel event notification mechanism
https://www.freebsd.org/cgi/man.cgi?query=kqueue&sektion=2

 

 

port

写道

port_create (3C)
https://docs.oracle.com/cd/E36784_01/html/E36874/port-create-3c.html

 

 

libevent支持的这些事件机制并不是在任何平台上都支持，这些事件机制基本都是平台相关的。如kqueue是UNIX支持的事件机制，port是UNIX Solaris支持的事件机制，linux下通常支持select, poll, epoll这几种事件机制。libevent的优势是提供跨平台的事件机制编程模型。

 

禁用epoll

设置环境变量EVENT_NOEPOLL，只需要设置这个环境变量就行，随便设置什么值。

# export EVENT_NOEPOLL=0

 

禁用poll

设置环境变量EVENT_NOPOLL，只需要设置这个环境变量就行，随便设置什么值。

# export EVENT_NOPOLL=0

 

禁用select

设置环境变量EVENT_NOSELECT，只需要设置这个环境变量就行，随便设置什么值。

# export EVENT_NOSELECT=0

 

如果不支持任何事件机制，或者所有事件机制都被禁用，将报如下错误：

[err] event_base_new: no event mechanism available