libevent代码阅读（1）

一些概念：

1、libevent是一个高性能的io框架，基于Reactor模式

2、event_base即Reactor实例

3、event是事件处理器（注意event不是事件，而是事件处理器）

4、libevent实现了select、poll、epoll、iocp等io复用机制，在编译的时候会自动选择一个最高效io复用机制

5、本次的代码阅读基于libevent2.0

event_base结构

// 一个event_base就是一个Reactor实例
struct event_base {
/** Function pointers and other data to describe this event_base's
* backend. */
// 初始化Reactor的时候选择一种后端io复用机制，并记录到如下字段中
const struct eventop *evsel;

/** Pointer to backend-specific data. */
// 指向io复用机制真正存储的数据，它通过evsel的init函数莱初始化
void *evbase;

/** List of changes to tell backend about at next dispatch.  Only used
* by the O(1) backends. */
/*
* 事件变化队列，其用途是：如果一个文件描述符上注册的事件被多次修改
* 则可以使用缓冲区来避免重复的系统调用（如epoll_ctl）。它仅能用于时间复杂度为0（1）的io复用技术
*/
struct event_changelist changelist;

/** Function pointers used to describe the backend that this event_base
* uses for signals */
// 指向信号后端处理机制，目前仅仅定义了一种处理方法
const struct eventop *evsigsel;

/** Data to implement the common signal handelr code. */
// 信号事件处理器使用的数据结构，其中封装了一个由socketpair创建的管道
// 它用于信号处理函数和事件多路分发器之间的通信
struct evsig_info sig;

/** Number of virtual events */
// 虚拟事件的数量
int virtual_event_count;

/** Number of total events added to this event_base */
// 所有事件的数量
int event_count;

/** Number of total events active in this event_base */
// 激活事件的数量
int event_count_active;

/** Set if we should terminate the loop once we're done processing
* events. */
// 是否执行完活动事件队列上的剩余的任务之后就退出事件循环
int event_gotterm;

/** Set if we should terminate the loop immediately */
// 是否立即退出事件循环
int event_break;

/** Set if we should start a new instance of the loop immediately. */
// 是否启动一个新的事件循环
int event_continue;

/** The currently running priority of events */
// 目前正在处理的活动事件队列的优先级
int event_running_priority;

/** Set if we're running the event_base_loop function, to prevent
* reentrant invocation. */
// 事件循环是否已经启动
int running_loop;

/* Active event management. */
/** An array of nactivequeues queues for active events (ones that
* have triggered, and whose callbacks need to be called).  Low
* priority numbers are more important, and stall higher ones.
*/
/*
* 活动事件队列数组。索引值越小，优先级越高。高优先级的活动事件队列中的事件将被优先处理
*/
struct event_list *activequeues;

/** The length of the activequeues array */
// 活动事件队列数组的大小
int nactivequeues;

/* common timeout logic */

/** An array of common_timeout_list* for all of the common timeout
* values we know. */
// 下面三个成员用于管理通用定时器队列
struct common_timeout_list **common_timeout_queues;

/** The number of entries used in common_timeout_queues */
int n_common_timeouts;

/** The total size of common_timeout_queues. */
int n_common_timeouts_allocated;

/** List of defered_cb that are active.  We run these after the active
* events. */
/*
* 存放延迟回调函数的链表
* 事件循环每次成功处理完一个活动队列中的所有事件之后，就掉用一次延迟回调函数
*/
struct deferred_cb_queue defer_queue;

/** Mapping from file descriptors to enabled (added) events */
// 文件描述符和io事件处理器之间的关系
struct event_io_map io;

/** Mapping from signal numbers to enabled (added) events. */
// 信号值和信号事件之间的映射关系
struct event_signal_map sigmap;

/** All events that have been enabled (added) in this event_base */
// 注册事件队列，存放io事件处理器和信号事件处理器
struct event_list eventqueue;

/** Stored timeval; used to detect when time is running backwards. */
struct timeval event_tv;

/** Priority queue of events with timeouts. */
// 时间堆
struct min_heap timeheap;

/** Stored timeval: used to avoid calling gettimeofday/clock_gettime
* too often. */
struct timeval tv_cache;

#if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
/** Difference between internal time (maybe from clock_gettime) and
* gettimeofday. */
struct timeval tv_clock_diff;
/** Second in which we last updated tv_clock_diff, in monotonic time. */
time_t last_updated_clock_diff;
#endif

// 多线程支持
#ifndef _EVENT_DISABLE_THREAD_SUPPORT
/* threading support */
/** The thread currently running the event_loop for this base */
// 当前运行该event_base的事件循环的线程
unsigned long th_owner_id;

/** A lock to prevent conflicting accesses to this event_base */
// event_base的独占锁
void *th_base_lock;

/** The event whose callback is executing right now */
// 当前事件循环正在执行那个事件处理器的回调函数
struct event *current_event;

/** A condition that gets signalled when we're done processing an
* event with waiters on it. */
// 条件变量
void *current_event_cond;

/** Number of threads blocking on current_event_cond. */
// 等待current_event_cond的线程数量
int current_event_waiters;
#endif

#ifdef WIN32
/** IOCP support structure, if IOCP is enabled. */
// win32下的完成端口
struct event_iocp_port *iocp;
#endif

/** Flags that this base was configured with */
// 一些配置参数
enum event_base_config_flag flags;

/* Notify main thread to wake up break, etc. */
/** True if the base already has a pending notify, and we don't need
* to add any more. */
// 下面这组变量给工作线程唤醒主线程提供了方法（使用socketpair创建的管道）
int is_notify_pending;

/** A socketpair used by some th_notify functions to wake up the main
* thread. */
evutil_socket_t th_notify_fd[2];
/** An event used by some th_notify functions to wake up the main
* thread. */
struct event th_notify;
/** A function used to wake up the main thread from another thread. */
int (*th_notify_fn)(struct event_base *base);
};

event结构

// 一个event是一个事件处理器
struct event {
// 所有的被激活的事件处理器通过该成员串联成一个尾队列（有多个活动事件队列，按照不同的优先级来划分）
TAILQ_ENTRY(event) ev_active_next;

// 所有的已注册事件构成一个尾队列
TAILQ_ENTRY(event) ev_next;

/* for managing timeouts */
// 用于定时事件（定时器）
// 老版本的定时器由时间堆来管理，由min_heap_idx成员来标志
// 新版本的通用的定时器由简单的链表（尾队列）来管理，由ev_next_with_common_timeout来标志其在队列中的位置
union {
TAILQ_ENTRY(event) ev_next_with_common_timeout;
int min_heap_idx;
} ev_timeout_pos;

// 对于io事件，它是文件描述符
// 对于信号事件，它是信号值
evutil_socket_t ev_fd;

// 指向Reactor实例
struct event_base *ev_base;

// _ev：
// 或者存放相同文件描述符的io事件处理的队列，例如一个套接字可读可写、出错等等
// 或者存放相同信号值的信号事件处理器的队列（即信号事件处理器的队列）
union {
/* used for io events */
struct {
TAILQ_ENTRY(event) ev_io_next;
struct timeval ev_timeout;
} ev_io;

/* used by signal events */
struct {
TAILQ_ENTRY(event) ev_signal_next;
// 当一个信号到来时是需要调用该回调函数多少次
short ev_ncalls;
/* Allows deletes in callback */
//该参数要么是0，要么指向ev_ncalls
short *ev_pncalls;
} ev_signal;
} _ev;

// 事件类型
short ev_events;

// 记录当前激活事件的类型
short ev_res;		/* result passed to event callback */

// 一些事件标志 即一些EVLIST开头的宏的标志
short ev_flags;

// 事件处理器的优先级，值越小优先级越高
ev_uint8_t ev_pri;	/* smaller numbers are higher priority */

// 指定event——base执行事件处理器的回调函数时候的行为
// 可选值位于event-internal.h中
ev_uint8_t ev_closure;

// 超时时间，仅仅对定时器有效
struct timeval ev_timeout;

/* allows us to adopt for different types of events */
// 处理事件的回调函数，需要自己实现
// 它的三个参数分别是：ev_fd,ev_res,ev_arg
void (*ev_callback)(evutil_socket_t, short, void *arg);

// 回调函数的参数
void *ev_arg;
};