目录
1.event_base 结构体
Reactor 框架组件在 libevent中,表现为 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; //一个二级指针,用于支持事件优先级,其中的元素 activequeues[priority]是一个链表,链表的每个节点指向一个优先级为priority的就绪事件event。
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; //事件管理变量
};
先从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;
};
libevent将系统提供的I/O demultiplex机制统一封装成了eventop结构;因此eventops[]包含了select、poll、kequeue和epoll等等其中的若干个全局实例对象。evbase实际上是一个eventop实例对象,也就是说,在 libevent 中,每种 I/O demultiplex 机制的实现都必须提供这五个函数接口,来完成自身的初始化、销毁释放、对事件的注册、注销和分发。比如对于 epoll,libevent 实现了 5 个对应的接口函数,并在初始化时并将 eventop 的 5个函数指针指向这 5 个函数,那么程序就可以使用 epoll 作为 I/O demultiplex 机制了。
2.创建和初始化
1)创建一个 event_base 对象也既是创建了一个新的 libevent 实例,
2)程序需要通过调用event_init()(内部调用 event_base_new 函数执行具体操作)函数来创建,该函数同时还对新生成的 libevent 实例进行了初始化。
3)该函数首先为 event_base 实例申请空间,然后初始化 timer mini-heap,选择并初始化合适的系统 I/O 的 demultiplexer 机制,初始化各事件链表;函数还检测了系统的时间设置。
3.主要的接口函数
对于定时事件,这些函数将调用 timer heap 管理接口执行插入和删除操作;对于 I/O 和Signal 事件将调用 eventopadd 和 delete 接口函数执行插入和删除操作(eventop 会对 Signal事件调用 Signal 处理接口执行操作)
- int event_add(struct event *ev, const struct timeval *timeout);
参数: ev:指向要注册的事件; tv:超时时间;
函数将 ev 注册到 ev->ev_base 上,事件类型由 ev->ev_events 指明,如果注册成功,ev将被插入到已注册链表中;如果 tv 不是 NULL,则会同时注册定时事件,将 ev 添加到 time堆上;如果其中有一步操作失败,那么函数保证没有事件会被注册,
参考源码:
int event_add(struct event *ev, const struct timeval *tv)
{
struct event_base *base = ev->ev_base; // 要注册到的event_base
const struct eventop *evsel = base->evsel;
void *evbase = base->evbase; // base使用的系统I/O策略
// 新的timer事件,调用timer heap接口在堆上预留一个位置
// 注:这样能保证该操作的原子性:
// 向系统I/O机制注册可能会失败,而当在堆上预留成功后,
// 定时事件的添加将肯定不会失败;
// 而预留位置的可能结果是堆扩充,但是内部元素并不会改变
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 */
}
// 如果事件ev不在已注册或者激活链表中,则调用evbase注册事件
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到已注册链表中
event_queue_insert(base, ev, EVLIST_INSERTED); //将事件插入到对应的链表中
}
// 准备添加定时事件
if (res != -1 && tv != NULL) {
struct timeval now;
// EVLIST_TIMEOUT表明event已经在定时器堆中了,删除旧的
if (ev->ev_flags & EVLIST_TIMEOUT)
event_queue_remove(base, ev, EVLIST_TIMEOUT);//将事件从对应的链表中删除
// 如果事件已经是就绪状态则从激活链表中删除
if ((ev->ev_flags & EVLIST_ACTIVE) && (ev->ev_res & EV_TIMEOUT)) {
// 将ev_callback调用次数设置为0
if (ev->ev_ncalls && ev->ev_pncalls) {
*ev->ev_pncalls = 0;
}
event_queue_remove(base, ev, EVLIST_ACTIVE);
}
// 计算时间,并插入到timer小根堆中
gettime(base, &now);
evutil_timeradd(&now, tv, &ev->ev_timeout);
event_queue_insert(base, ev, EVLIST_TIMEOUT);
}
return (res);
}
- int event_del(struct event *ev);
删除事件 ev,对于 I/O 事件,从 I/O 的 demultiplexer 上将事件注销;对于 Signal事件,将从 Signal 事件链表中删除;对于定时事件,将从堆上删除;同样删除事件的操作则不一定是原子的,比如删除时间事件之后,有可能从系统 I/O 机
制中注销会失败。
参考源码:
int event_del(struct event *ev)
{
struct event_base *base;
const struct eventop *evsel;
void *evbase;
// ev_base为NULL,表明ev没有被注册
if (ev->ev_base == NULL)
return (-1);
// 取得ev注册的event_base和eventop指针
base = ev->ev_base;
evsel = base->evsel;
evbase = base->evbase;
// 将ev_callback调用次数设置为
if (ev->ev_ncalls && ev->ev_pncalls) {
*ev->ev_pncalls = 0;
}
// 从对应的链表中删除
if (ev->ev_flags & EVLIST_TIMEOUT)
event_queue_remove(base, ev, EVLIST_TIMEOUT);
if (ev->ev_flags & EVLIST_ACTIVE)
event_queue_remove(base, ev, EVLIST_ACTIVE);
if (ev->ev_flags & EVLIST_INSERTED) {
event_queue_remove(base, ev, EVLIST_INSERTED);
// EVLIST_INSERTED表明是I/O或者Signal事件,
// 需要调用I/O demultiplexer注销事件
return (evsel->del(evbase, ev));
}
return (0);
}
- int event_base_loop(struct event_base *base, int loops); 该函数完成事件处理主循环
参考源码:
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;
// 清空时间缓存
base->tv_cache.tv_sec = 0;
// evsignal_base是全局变量,在处理signal时,用于指名signal所属的event_base实例
if (base->sig.ev_signal_added)
evsignal_base = base;
done = 0;
while (!done) {
// 事件主循环
// 查看是否需要跳出循环,程序可以调用event_loopexit_cb()设置 event_gotterm标记
// 调用event_base_loopbreak()设置event_break标记
if (base->event_gotterm) {
base->event_gotterm = 0;
break;
}
if (base->event_break) {
base->event_break = 0;
break;
}
// 校正系统时间,如果系统使用的是非MONOTONIC时间,用户可能会向后调整了系统时间
// 在timeout_correct函数里,比较last wait time和当前时间,如果当前时间< last wait time
// 表明时间有问题,这是需要更新timer_heap中所有定时事件的超时时间。
timeout_correct(base, &tv);
// 根据timer heap中事件的最小超时时间,计算系统I/O demultiplexer的最大等待时间
tv_p = &tv;
if (!base->event_count_active && !(flags & EVLOOP_NONBLOCK)) {
timeout_next(base, &tv_p);
} else {
// 依然有未处理的就绪时间,就让I/O demultiplexer立即返回,不必等待。
// 下面会提到,在libevent中,低优先级的就绪事件可能不能立即被处理
evutil_timerclear(&tv);
}
// 如果当前没有注册事件,就退出
if(!event_haveevents(base)) {
event_debug(("%s: no events registered.", __func__));
return (1);
}
// 更新last wait time,并清空time cache
gettime(base, &base->event_tv);
base->tv_cache.tv_sec = 0;
// 调用系统I/O demultiplexer等待就绪I/O events,可能是epoll_wait,或者select等;
// 在evsel->dispatch()中,会把就绪signal event、I/O event插入到激活链表中
res = evsel->dispatch(base, evbase, tv_p);
if (res == -1)
return (-1);
// 将time cache赋值为当前系统时间
gettime(base, &base->tv_cache);
// 检查heap中的timer events,将就绪的timer event从heap上删除,并插入到激活链表中
timeout_process(base);
// 调用event_process_active()处理激活链表中的就绪event,调用其回调函数执行事件处理
// 该函数会寻找最高优先级(priority值越小优先级越高)的激活事件链表,
// 然后处理链表中的所有就绪事件;
// 因此低优先级的就绪事件可能得不到及时处理;
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;
}
// 循环结束,清空时间缓存
base->tv_cache.tv_sec = 0;
event_debug(("%s: asked to terminate loop.", __func__));
return (0);
}
- void event_active(struct event *event, int res, short events);
- void event_process_active(struct event_base *base);
4.事件的统一
1)I/O 和 Timer 事件的统一
- Libevent 将 Timer 和 Signal 事件都统一到了系统的 I/O 的 demultiplex 机制中了。
- 首先将 Timer 事件融合到系统 I/O 多路复用机制中,因为系统的 I/O机制像 select()和 epoll_wait()都允许程序制定一个最大等待时间(也称为最大超时时间)timeout,即使没有 I/O 事件发生,它们也保证能在 timeout 时间内返回。
- 根据所有 Timer 事件的最小超时时间来设置系统 I/O 的 timeout 时间;当系统 I/O返回时,再激活所有就绪的 Timer 事件就可以了。
- 堆是一种经典的数据结构,向堆中插入、删除元素时间复杂度都是 O(lgN),N 为堆中元素的个数,而小根堆获取最小 key 值(小根堆)的复杂度为 O(1);
2)I/O 和 Signal 事件的统一
- Signal 是异步事件的经典事例,Signal 事件的出现对于进程来讲是完全随机的,对于信号的处理纪既要告诉内核发生在何处同时需要执行什么操作;
- libevent 中使用的方法:当 Signal 发生时,并不立即调用 event 的 callback 函数处理信号,而是设法通知系统的 I/O 机制,让其返回,然后再统一和 I/O 事件以及 Timer 一起处理。