libevent_事件处理框架event_base

目录

1.event_base 结构体

2.创建和初始化

3.主要的接口函数

4.事件的统一

---

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 一起处理。