libevent简单分析

一看名字就知道是围绕eventloop转的。
那首先肯定是eventloop是个什么？一般都是IO事件，timer事件的管理器。

那首先看如何new出来一个eventloop：

1、因为libevent是跨平台的，在不同平台上会有不同的配置，首先读配置：

struct event_config {

TAILQ_HEAD(event_configq, event_config_entry) entries;

int n_cpus_hint;

enum event_method_feature require_features;

enum event_base_config_flag flags;

};

有一个event_config 的结构，目的就是为了描述将要创建的event_base的配置。

#define TAILQ_HEAD(name, type) \

struct name { \

struct type *tqh_first; \

struct type **tqh_last; \

}

TAILQ_HEAD是一个结构体的宏。

好吧，为了方便阅读我把宏给干掉了：

struct event_config_entry {

struct {

event_config_entry* tqe_next;

event_config_entry** tqe_prev;

} next;

const char *avoid_method;

};

struct event_config {

struct event_configq{

struct event_config_entry *tqh_first;

struct event_config_entry **tqh_last;

} entries;

int n_cpus_hint;

enum event_method_feature require_features;

enum event_base_config_flag flags;

};

现在清楚了event_config_new就是分配了这个结构体（链表）的内存，并对链表做了初始化。

下一步要开始初始化配置了：

event_base_new_with_config在做这个工作：

哇塞，这个函数里就开始new eventBase了：

而且在对base做初始化

1,、初始化base的时间：

gettime(base, &base->event_tv);

看下实现就清楚了：

static int gettime(struct event_base *base, struct timeval *tp)

{

EVENT_BASE_ASSERT_LOCKED(base);

if (base->tv_cache.tv_sec) {

*tp = base->tv_cache;

return (0);

}

return (evutil_gettimeofday(tp, NULL));

}

如果base的tv_cache保存的有时间就直接用这个时间，以避免调用函数获取时间太频繁；

否则调用evutil_gettimeofday 是会调用各个系统获取当前时间的函数。

之后设置这个几个参数：

base->sig.ev_signal_pair[0] = -1;

base->sig.ev_signal_pair[1] = -1;

base->th_notify_fd[0] = -1;

base->th_notify_fd[1] = -1;

sig是与信号相关的，linux下的，windows下的貌似没什么用；重点看th_notify_fd的作用：

evutil_socket_t th_notify_fd[2];

意思是用来由一些线程通知函数唤醒主线程的。

event_deferred_cb_queue_init(&base->defer_queue);

初始化defer_queue队列，这个队列的作用是：

这个队列内部结构如下：

struct deferred_cb_queue {

void *lock;

int active_count;

void (*notify_fn)(struct deferred_cb_queue *, void *);

void *notify_arg;

TAILQ_HEAD (deferred_cb_list, deferred_cb) deferred_cb_list;

};

里面还有个链表：

struct deferred_cb {

TAILQ_ENTRY (deferred_cb) cb_next;

unsigned queued : 1;

deferred_cb_fn cb;

void *arg;

};

之后设置根据配置backend；

在windows下可以设置为select或者iocp；如果是select代码会在win32select.c里：

struct eventop win32ops = {

"win32",

win32_init,

win32_add,

win32_del,

win32_dispatch,

win32_dealloc,

0,

0,

sizeof(struct idx_info),

}

初始化时：

void *

win32_init(struct event_base *_base)

{

struct win32op *winop;

size_t size;

if (!(winop = mm_calloc(1, sizeof(struct win32op))))

return NULL;

winop->num_fds_in_fd_sets = NEVENT;

size = FD_SET_ALLOC_SIZE(NEVENT);

if (!(winop->readset_in = mm_malloc(size)))

goto err;

if (!(winop->writeset_in = mm_malloc(size)))

goto err;

if (!(winop->readset_out = mm_malloc(size)))

goto err;

if (!(winop->writeset_out = mm_malloc(size)))

goto err;

if (!(winop->exset_out = mm_malloc(size)))

goto err;

winop->readset_in->fd_count = winop->writeset_in->fd_count = 0;

winop->readset_out->fd_count = winop->writeset_out->fd_count

= winop->exset_out->fd_count = 0;

if (evsig_init(_base) < 0)

winop->signals_are_broken = 1;

return (winop);

 err:

XFREE(winop->readset_in);

XFREE(winop->writeset_in);

XFREE(winop->readset_out);

XFREE(winop->writeset_out);

XFREE(winop->exset_out);

XFREE(winop);

return (NULL);

}

里面分配了32个fd；

好吧Eventbase的事情终于搞完了。好辛苦！！！！

关键是看event_base_dispatch如何进行mainloop的：

int

event_base_loop(struct event_base *base, int flags)

{

const struct eventop *evsel = base->evsel;

struct timeval tv;

struct timeval *tv_p;

int res, done, retval = 0;

EVBASE_ACQUIRE_LOCK(base, th_base_lock);

if (base->running_loop) {

event_warnx("%s: reentrant invocation.  Only one event_base_loop"

   " can run on each event_base at once.", __func__);

EVBASE_RELEASE_LOCK(base, th_base_lock);

return -1;

}

base->running_loop = 1;

clear_time_cache(base);

if (base->sig.ev_signal_added && base->sig.ev_n_signals_added)

evsig_set_base(base);

done = 0;

#ifndef _EVENT_DISABLE_THREAD_SUPPORT

base->th_owner_id = EVTHREAD_GET_ID();

#endif

base->event_gotterm = base->event_break = 0;

while (!done) {

base->event_continue = 0;

if (base->event_gotterm) {

break;

}

if (base->event_break) {

break;

}

timeout_correct(base, &tv);

tv_p = &tv;

if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) {

timeout_next(base, &tv_p);

} else {

evutil_timerclear(&tv);

}

if (!event_haveevents(base) && !N_ACTIVE_CALLBACKS(base)) {

event_debug(("%s: no events registered.", __func__));

retval = 1;

goto done;

}

gettime(base, &base->event_tv);

clear_time_cache(base);

res = evsel->dispatch(base, tv_p);

if (res == -1) {

event_debug(("%s: dispatch returned unsuccessfully.",

__func__));

retval = -1;

goto done;

}

update_time_cache(base);

timeout_process(base);

if (N_ACTIVE_CALLBACKS(base)) {

int n = event_process_active(base);

if ((flags & EVLOOP_ONCE)

   && N_ACTIVE_CALLBACKS(base) == 0

   && n != 0)

done = 1;

} else if (flags & EVLOOP_NONBLOCK)

done = 1;

}

event_debug(("%s: asked to terminate loop.", __func__));

done:

clear_time_cache(base);

base->running_loop = 0;

EVBASE_RELEASE_LOCK(base, th_base_lock);

return (retval);

}

跟之前看过的libev是一个模子出来的，都是先检测有木有可读、可写的马上去处理，然后调用backend->dispatch检测事件，处理timer事件。一直转，除非外部要停止或者木有fd了。

下面看下select事件的检测吧：

int

win32_dispatch(struct event_base *base, struct timeval *tv)

{

struct win32op *win32op = base->evbase;

int res = 0;

unsigned j, i;

int fd_count;

SOCKET s;

if (win32op->resize_out_sets) {

size_t size = FD_SET_ALLOC_SIZE(win32op->num_fds_in_fd_sets);

if (!(win32op->readset_out = mm_realloc(win32op->readset_out, size)))

return (-1);

if (!(win32op->exset_out = mm_realloc(win32op->exset_out, size)))

return (-1);

if (!(win32op->writeset_out = mm_realloc(win32op->writeset_out, size)))

return (-1);

win32op->resize_out_sets = 0;

}

fd_set_copy(win32op->readset_out, win32op->readset_in);

fd_set_copy(win32op->exset_out, win32op->writeset_in);

fd_set_copy(win32op->writeset_out, win32op->writeset_in);

fd_count =

   (win32op->readset_out->fd_count > win32op->writeset_out->fd_count) ?

   win32op->readset_out->fd_count : win32op->writeset_out->fd_count;

if (!fd_count) {

long msec = tv ? evutil_tv_to_msec(tv) : LONG_MAX;

if (msec < 0)

msec = LONG_MAX;

Sleep(msec);

return (0);

}

EVBASE_RELEASE_LOCK(base, th_base_lock);

res = select(fd_count,

    (struct fd_set*)win32op->readset_out,

    (struct fd_set*)win32op->writeset_out,

    (struct fd_set*)win32op->exset_out, tv);

EVBASE_ACQUIRE_LOCK(base, th_base_lock);

event_debug(("%s: select returned %d", __func__, res));

if (res <= 0) {

return res;

}

if (win32op->readset_out->fd_count) {

i = rand() % win32op->readset_out->fd_count;

for (j=0; jreadset_out->fd_count; ++j) {

if (++i >= win32op->readset_out->fd_count)

i = 0;

s = win32op->readset_out->fd_array[i];

evmap_io_active(base, s, EV_READ);

}

}

if (win32op->exset_out->fd_count) {

i = rand() % win32op->exset_out->fd_count;

for (j=0; jexset_out->fd_count; ++j) {

if (++i >= win32op->exset_out->fd_count)

i = 0;

s = win32op->exset_out->fd_array[i];

evmap_io_active(base, s, EV_WRITE);

}

}

if (win32op->writeset_out->fd_count) {

SOCKET s;

i = rand() % win32op->writeset_out->fd_count;

for (j=0; jwriteset_out->fd_count; ++j) {

if (++i >= win32op->writeset_out->fd_count)

i = 0;

s = win32op->writeset_out->fd_array[i];

evmap_io_active(base, s, EV_WRITE);

}

}

return (0);

}

考虑的很周到，select之前会释放lock，因为select这里是阻塞的，但不希望阻塞主线程，select会继续加锁。把可读，可写fd进行copy，里面还用了一个简单的随机 保证公平。

之后就更新timecache为当前时间，然后检测timer时间，到点就执行timer事件：

static void

timeout_process(struct event_base *base)

{

struct timeval now;

struct event *ev;

if (min_heap_empty(&base->timeheap)) {

return;

}

gettime(base, &now);

while ((ev = min_heap_top(&base->timeheap))) {

if (evutil_timercmp(&ev->ev_timeout, &now, >))

break;

event_del_internal(ev);

event_debug(("timeout_process: call %p",

ev->ev_callback));

event_active_nolock(ev, EV_TIMEOUT, 1);

}

}

一看代码就明白了使用最小堆管理时间的，当然时间间隔最小的要先执行，处理流程是这样的：

检测时间堆里的事件，如果时间已经超过当前时间，那么先把这个事件从堆里删除，然后再active这个event，就是调用注册进来的timer函数。

好了，暂时写到这里吧。