libevent 事件loop分析

 

event_init初 始化libevent事件全局对象current_base

初始化全局current_base是一个进程的个全局的变量

 

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

 

 if (base != NULL)
  current_base = base;   <-----------

 

 return (base);
}

 

 

对libevent全局控制事件结构分析
struct event_base {
 const struct eventop *evsel ;       对libevent操作函数集合结构ops
 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 ;
};

 

main函数事件循环函数

 

 400x /*
 401x  * Wait continously for events.  We exit only if no events are left.
 402x  */
 403x
 404x int
 405x event_dispatch (void)
 406x {
 407t>        return (event_loop (0));
 408x }

 

 

事件循环包裹函数，将全局的变量current_base 传入事件循环函数

int
event_loop (int flags)
{
 return event_base_loop(current_base , flags);     <-----------
}

 

 

current_base参数传入了

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;

 

 if (&base->sig.ev_signal_added)  如果加了信号处理
  evsignal_base = base;

 done = 0;
 while (!done) {
  /* Terminate the loop if we have been asked to */
  if (base->event_gotterm) { 如果循环退出标记，退出
   base->event_gotterm = 0;
   break;
  }

 

  if (base->event_break) {  如果事件中断，退出
   base->event_break = 0;
   break;
  }

 

  /* You cannot use this interface for multi-threaded apps */
  while (event_gotsig) {
   event_gotsig = 0;
   if (event_sigcb) {
    res = (*event_sigcb)();
    if (res == -1) {
     errno = EINTR;
     return (-1);
    }
   }
  }

  获取时间----比较当前事件时间和缓存累计时间

  timeout_correct (base, &tv );

 

  tv_p = &tv ;   获取时间epoll_wait的timeout时间  < -------------------------

 

    如果没有活动事件,指的是时间堆计数
  if (!base->event_count_active && !(flags & EVLOOP_NONBLOCK)) {
    timeout_next(base, &tv_p);
  }

  else

  {
   /*  有活动事件，轮询新事件
    * if we have active events, we just poll new events
    * without waiting.
    */
   evutil_timerclear(&tv); tv值设置为0
  }
  
  /* If we have no events, we just exit */
  if (!event_haveevents(base)) { 没有epoll事件则退出loop  (base->event_count >  0) 
   event_debug(("%s: no events registered.", __func__));
   return (1);
  }

 

  /* update last old time */ 系统使用了tv_cache缓存累计时间，超过一秒更新到当前系统时间
  gettime(base, &base->event_tv);

 

  /* clear time cache */
  base->tv_cache.tv_sec = 0;

 开始进入epoll_wait函数，这里要注意到   tv_p 是上面  < -------------------------

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

 

  if (res == -1) 有错误则退出
   return (-1);

  gettime(base, &base->tv_cache);

 

  timeout_process(base);

 

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

 

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

 

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

 

static int
epoll_dispatch (struct event_base *base, void *arg, struct timeval *tv)
{
 struct epollop *epollop = arg;
 struct epoll_event *events = epollop->events;
 struct evepoll *evep ;
 int i, res, timeout = -1;

 

 if (tv != NULL) 有超时时间，则换算成epoll_wait的时间
  timeout = tv->tv_sec * 1000 + (tv->tv_usec + 999) / 1000;

 

 if (timeout > MAX_EPOLL_TIMEOUT_MSEC) {
  /* Linux kernels can wait forever if the timeout is too big;
   * see comment on MAX_EPOLL_TIMEOUT_MSEC. */
  timeout = MAX_EPOLL_TIMEOUT_MSEC;
 }

 

 res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout ); < -------------------------

 

 if (res == -1) {
  if (errno != EINTR) {
   event_warn("epoll_wait");
   return (-1);
  }

 

  evsignal_process (base);   信号处理函数
  return (0);
 }

 else if (base->sig.evsignal_caught) {
   evsignal_process(base);
 }

 

 event_debug(("%s: epoll_wait reports %d", __func__, res));

 

 for (i = 0; i < res; i++) {
  int what = events[i].events;
  struct event *evread = NULL, *evwrite = NULL;

 

  evep = (struct evepoll *)events[i].data.ptr; --------> struct evepoll* ----->  struct event* rw

 

  if (what & (EPOLLHUP|EPOLLERR)) {
   evread = evep->evread;
   evwrite = evep->evwrite;
  } else {
   if (what & EPOLLIN) {
    evread = evep ->evread;
   }

 

   if (what & EPOLLOUT) {
    evwrite = evep ->evwrite;
   }
  }

 

  if (!(evread||evwrite))
   continue;

 

  if (evread != NULL)
    event_active (evread, EV_READ, 1);
  if (evwrite != NULL)
   event_active (evwrite, EV_WRITE, 1);
 }

 

 return (0);
}