Libev事件库源码阅读笔记

select
poll
epoll
kqueue
solaris event port

ev_io                 // IO可读可写
ev_stat               // 文件属性变化
ev_signal             // 信号处理
ev_timer              // 相对定时器
ev_periodic           // 绝对定时器
ev_child              // 子进程状态变化
ev_fork               // fork事件
ev_cleanup            // event loop退出触发事件
ev_idle               // event loop空闲触发事件
ev_embed              // 嵌入另一个后台循环
ev_prepare            // event loop之前事件
ev_check              // event loop之后事件
ev_async              // 线程间异步事件

// a single header file is required
#include <ev.h>

#include <stdio.h> // for puts

// every watcher type has its own typedef'd struct
// with the name ev_TYPE
ev_io stdin_watcher;
ev_timer timeout_watcher;

// all watcher callbacks have a similar signature
// this callback is called when data is readable on stdin
static void
stdin_cb (EV_P_ ev_io *w, int revents)
{
    puts ("stdin ready");
    // for one-shot events, one must manually stop the watcher
    // with its corresponding stop function.
    ev_io_stop (EV_A_ w);

    // this causes all nested ev_run's to stop iterating
    ev_break (EV_A_ EVBREAK_ALL);
}

// another callback, this time for a time-out
static void
timeout_cb (EV_P_ ev_timer *w, int revents)
{
    puts ("timeout");
    // this causes the innermost ev_run to stop iterating
    ev_break (EV_A_ EVBREAK_ONE);
}

int
main (void)
{
    // use the default event loop unless you have special needs
    struct ev_loop *loop = EV_DEFAULT;

    // initialise an io watcher, then start it
    // this one will watch for stdin to become readable
    ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ);
    ev_io_start (loop, &stdin_watcher);

    // initialise a timer watcher, then start it
    // simple non-repeating 5.5 second timeout
    ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.);
    ev_timer_start (loop, &timeout_watcher);

    // now wait for events to arrive
    ev_run (loop, 0);

    // break was called, so exit
    return 0;
}

#if EV_MULTIPLICITY
struct ev_loop;
# define EV_P  struct ev_loop *loop               /* a loop as sole parameter in a declaration */
# define EV_P_ EV_P,                              /* a loop as first of multiple parameters */
# define EV_A  loop                               /* a loop as sole argument to a function call */
# define EV_A_ EV_A,                              /* a loop as first of multiple arguments */
#else
# define EV_P void
# define EV_P_
# define EV_A
# define EV_A_
#endif

//这个宏定义了所有ev_TYPE开头的部分
#define EV_WATCHER(type)            /
  int active; /* private */         /
  int pending; /* private */            /
  int priority; /* private */        /
  void *data; /* rw */                /
  void (*cb)(EV_P_ struct type *w, int revents); /* private */

//这个宏在EV_WATCHER的基础上加了一个时间戳，主要用来定义和定时器有关的ev
#define EV_WATCHER_TIME(type)     /
  EV_WATCHER (type)       /
  ev_tstamp at;     /* private */

//这个宏在EV_WATCHER的内容后加了一个next以构成事件链表
#define EV_WATCHER_LIST(type)           /
  EV_WATCHER (type)             /
  struct ev_watcher_list *next; /* private */

//内容就是EV_WATCHER宏的内容，可以理解为"基类"
typedef struct ev_watcher
{
  EV_WATCHER (ev_watcher)
} ev_watcher;

//内容就是EV_WATCHER_TIME宏的内容，也可以理解为"基类"
typedef struct ev_watcher_time
{
  EV_WATCHER_TIME (ev_watcher_time)
} ev_watcher_time;

//可以理解为一个带有next指针的基类
typedef struct ev_watcher_list
{
  EV_WATCHER_LIST (ev_watcher_list)
} ev_watcher_list;

//ev_io 封装io事件的"派生类"，结构体前部就是宏EV_WATCHER_LIST，fd和events是"派生类"变量
typedef struct ev_io
{
  EV_WATCHER_LIST (ev_io)

  int fd;     /* ro */
  int events; /* ro */
} ev_io;

//ev_signal 封装信号事件的"派生类"，同样也有signum是"派生类"变量
typedef struct ev_signal
{
  EV_WATCHER_LIST (ev_signal)

  int signum; /* ro */
} ev_signal;

//ev_timer 封装相对定时器事件的"派生类"，定时器用堆管理，不需要next指针
typedef struct ev_timer
{
  EV_WATCHER_TIME (ev_timer)

  ev_tstamp repeat; /* rw */
} ev_timer;
```  
从以上代码可以看出来，每个事件结构体中的共有字段表示了这个事件的状态，优先级，参数，以及回调函数，而私有字段则是该类型事件的特有信息，比如io事件有对应的fd、定时器事件有发生时间等。  
  
另外还有一个叫做ev_any_watcher的union可以容纳所有的事件类型。
```c
union ev_any_watcher
{
  struct ev_watcher w;
  struct ev_watcher_list wl;
  struct ev_io io;
  struct ev_timer timer;
  struct ev_periodic periodic;
  struct ev_signal signal;
  struct ev_child child;
  struct ev_stat stat;
  struct ev_idle idle;
  struct ev_prepare prepare;
  struct ev_check check;
  struct ev_fork fork;
  struct ev_cleanup cleanup;
  struct ev_embed embed;
  struct ev_async async;
};

#if EV_MULTIPLICITY
  struct ev_loop
  {
    ev_tstamp ev_rt_now;
    #define ev_rt_now ((loop)->ev_rt_now)
    #define VAR(name,decl) decl;
      #include "ev_vars.h"
    #undef VAR
  };
  #include "ev_wrap.h"

  static struct ev_loop default_loop_struct;
  EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */
#else
  EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */
  #define VAR(name,decl) static decl;
    #include "ev_vars.h"
  #undef VAR

  static int ev_default_loop_ptr;
#endif

typedef ev_watcher_list *WL;
/* file descriptor info structure */
typedef struct
{
  WL head;
  unsigned char events; /* the events watched for */
  unsigned char reify;  /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
  unsigned char emask;  /* the epoll backend stores the actual kernel mask in here */
  unsigned char unused;
#if EV_USE_EPOLL
  unsigned int egen;    /* generation counter to counter epoll bugs */
#endif
} ANFD;

ev_io stdin_watcher;
ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ);
ev_io_start (loop, &stdin_watcher);

#define ev_io_init(ev,cb,fd,events)          do { ev_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
#define ev_init(ev,cb_) do {      /
  ((ev_watcher *)(void *)(ev))->active  = /
  ((ev_watcher *)(void *)(ev))->pending = 0;  /
  ev_set_priority ((ev), 0);      /
  ev_set_cb ((ev), cb_);      /
} while (0)
#define ev_io_set(ev,fd_,events_)            do { (ev)->fd = (fd_); (ev)->events = (events_) | EV__IOFDSET; } while (0)

typedef ev_watcher *W;
typedef ev_watcher_list *WL;

void noinline
ev_io_start (EV_P_ ev_io *w) EV_THROW
{
  int fd = w->fd;
  //如果对一个ev_io已经调用过ev_io_start，不再重复调用
  if (expect_false (ev_is_active (w)))
    return;

  assert (("libev: ev_io_start called with negative fd", fd >= 0));
  assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));

  EV_FREQUENT_CHECK;
  
  //设置事件状态为启动
  ev_start (EV_A_ (W)w, 1);

  //判断当前分配的fd数组是否能放该fd，若不能，分配更多的空间给fd数组(realloc)。
  //这是一个宏，anfds实际上就是loop->anfds，存储了和该loop关联的ANFD数组。
  //anfdmax是当前数组能放的最大fd，array_init_zero也是个宏，对新分配的空间memeset成0。
  array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
  
  //将该io事件添加到该fd对应结构体的事件链表里，使用头插法
  wlist_add (&anfds[fd].head, (WL)w);

  /* common bug, apparently */
  assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));

  //将该fd加到fdchanges数组里，fdchanges保存了事件监听状态改变的fd
  //事件驱动器会在合适的时候遍历fdchanges数组，根据使用的后台IO复用机制应用更改，比如epoll_ctl
  fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);
  
  //start结束，取消该事件的IOFDSET标记（这个标记是在init时加的）
  w->events &= ~EV__IOFDSET;

  EV_FREQUENT_CHECK;
}

//设置事件状态为启动
inline_speed void
ev_start (EV_P_ W w, int active)
{
  //调整优先级到合法范围
  pri_adjust (EV_A_ w);
  //active==1表示已经启动
  w->active = active;
  //增加该ev_loop的reference
  ev_ref (EV_A);
}

//添加事件到对应的链表中
inline_size void
wlist_add (WL *head, WL elem)
{
  elem->next = *head;
  *head = elem;
}

//标记fd监听状态有所更改
inline_size void
fd_change (EV_P_ int fd, int flags)
{
  unsigned char reify = anfds [fd].reify;
  anfds [fd].reify |= flags;
  //reify之前是0，要将fd加到fdchanges数组中
  if (expect_true (!reify))
    {
      ++fdchangecnt;
      array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
      fdchanges [fdchangecnt - 1] = fd;
    }
}

void noinline
ev_io_stop (EV_P_ ev_io *w) EV_THROW
{
  //如果该事件正在pending(等待执行的事件)中，从pending列表中移除该事件。
  //这里的一个技巧是不用真的移除掉(数组删除复杂度O(n))，只要将pending列表对应位置的指针指向一个空事件就可以了。
  clear_pending (EV_A_ (W)w);
  if (expect_false (!ev_is_active (w)))
    return;

  assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));

  EV_FREQUENT_CHECK;
  //从链表中删除一个节点，这里删除节点的方法也是Linus提倡的方法，不需要记录prev指针以及是否头节点什么的。
  wlist_del (&anfds[w->fd].head, (WL)w);

  //取消fd的active状态
  ev_stop (EV_A_ (W)w);

  //将fd加到fdchanges数组中，只设置REIFY标记，表示有改动(若什么标记都不设置该fd不会放入fdchanges)
  //之后事件驱动器扫描fdchanges数组会发现该fd不再监听任何事件，作出相应操作
  fd_change (EV_A_ w->fd, EV_ANFD_REIFY);

  EV_FREQUENT_CHECK;
}
//从链表中删除一个节点，十分经典的方法
inline_size void
wlist_del (WL *head, WL elem)
{
  while (*head)
    {
      if (expect_true (*head == elem))
        {
          *head = elem->next;
          break;
        }
      head = &(*head)->next;
    }
}

int
ev_run (EV_P_ int flags)
{
  ...
  //一直循环....
  do
    {
      ...
      //如果这个进程是新fork出来的，执行ev_fork事件的回调
      ...
      //执行ev_prepare回调，也就是每次poll前执行的函数
      ...
      //执行监听有改变的事件
      ...
      //计算poll应该等待的时间,这个时间和设置以及定时器超时时间有关
      ...
      //调用后台I/O复用端口等待事件触发
      backend_poll (EV_A_ waittime);
      ...
      //将定时器事件放入pending数组中
      ...
      //将ev_check事件翻入pending数组中
      ...
      //执行pending数组中所有的回调
      EV_INVOKE_PENDING;
    }
  while (条件成立);
}