libevent源码学习----io多路复用的封装和使用

因为是非阻塞监听事件的发生，所以内部其实还是采用io多路复用函数实现的。
又因为可供选择的io函数很多，linux下有epoll, poll, select等，window下有ICOP, select等，所以libevent需要在程序启动时选择一个合适的io多路复用函数，合适的依据是

• 系统支持，为了实现跨平台
• io函数的效率尽量高
• 用户是否主动设置了不想使用的io函数

为了解决跨平台，libevent对所有的io函数都进行了各自的封装
为了解决效率问题，libevent在选择时，从效率高的开始选
为了解决用户设置，libevent为每一个io函数提供一个名字，用户人为设置不想使用的io函数时也是传送io函数名字，libevent维护一个字符串队列，选择不在这个队列中的io函数

---

以下程序就是libevent如何初始化io多路复用函数的

/* 由event_base_new调用 */
struct event_base *
event_base_new_with_config(const struct event_config *cfg)
{
    int i;
    struct event_base *base;

    /* ... */

    /* 
     * 为了实现让base可以根据系统需要或者用户的需要调用不同的io复用函数，
     * 比如说系统可能不支持某个io复用函数，又或者是用户指明不想要使用
     * 哪个io复用函数，指明不想只要哪个函数可以通过调用带有config的函数提供
     * 创建base的配置
     * 为了解决这种情况，在全局变量中有一个eventopts数组，这个数组中存储着
     * 所有系统支持的io复用函数，每个io复用函数都是一个结构体实例化对象
     * 可以在每一个io函数的文件，比如select.c中看到
     * 而evbase存储的不是使用的io函数，而是使用的io函数对应的数据结构体
     * 其实就是存数据的，在io函数文件中也可以看到
     * 下面的for循环是为了找到第一个可用的io函数，因为数组中的函数是按效率
     * 排序的
     */
    base->evbase = NULL;



    /* 如上 */
    for (i = 0; eventops[i] && !base->evbase; i++) {
        if (cfg != NULL) {
            /* determine if this backend should be avoided */
            if (event_config_is_avoided_method(cfg,
                eventops[i]->name))
                continue;
            if ((eventops[i]->features & cfg->require_features)
                != cfg->require_features)
                continue;
        }

        base->evsel = eventops[i];
        /* 调用对应io函数的初始化函数
         * 注意：在这个函数内部同时对信号进行了初始化，其实是创建了一个socketpair
         * 目的是将信号统一成event，见evsig_init
         */
        base->evbase = base->evsel->init(base);
    }

    /* 如果没有找到可用的io函数，会出错返回，同时清除已经创建的base */
    if (base->evbase == NULL) {
        event_warnx("%s: no event mechanism available",
            __func__);
        base->evsel = NULL;
        event_base_free(base);
        return NULL;
    }

    /* ... */

    return (base);
}

全局io函数数组，以此实现跨平台，根据预编译头判断系统是否支持某个io函数，从而构造出一个存储着所有可用的io多路复用函数的数组，初始化base时，只需要筛选出用户允许的即可

/* Array of backends in order of preference. */
static const struct eventop *eventops[] = {
#ifdef _EVENT_HAVE_EVENT_PORTS
    &evportops,
#endif
#ifdef _EVENT_HAVE_WORKING_KQUEUE
    &kqops,
#endif
#ifdef _EVENT_HAVE_EPOLL
    &epollops,
#endif
#ifdef _EVENT_HAVE_DEVPOLL
    &devpollops,
#endif
#ifdef _EVENT_HAVE_POLL
    &pollops,
#endif
#ifdef _EVENT_HAVE_SELECT
    &selectops,
#endif
#ifdef WIN32
    &win32ops,
#endif
    NULL
};

接下来单独看每一个io函数的封装

select的封装，由此可见每个io函数的封装都是定义一个struct eventop类型的变量，将对应io函数的接口指针存储着，这就将所有的io函数都统一起来，不需要特定io调用特定接口

const struct eventop selectops = {
    "select",
    select_init,
    select_add,
    select_del,
    select_dispatch,
    select_dealloc,
    0, /* doesn't need reinit. */
    EV_FEATURE_FDS,
    0,
};

此外libevent也对每个io函数使用的数据类型进行了封装，比如说epoll_event，pollfd以及fd_set

对select的fd_set进行的封装，为什么read/write都有两份，可以参考几种服务器模型以及io多路复用函数中的select部分

struct selectop {
    int event_fds;      /* Highest fd in fd set */
    int event_fdsz;
    int resize_out_sets;
    fd_set *event_readset_in;
    fd_set *event_writeset_in;
    fd_set *event_readset_out;
    fd_set *event_writeset_out;
};

对于epoll也是如此，libevent内部epoll有另一种封装，不明白原理

const struct eventop epollops = {
    "epoll",
    epoll_init,
    epoll_nochangelist_add,
    epoll_nochangelist_del,
    epoll_dispatch,
    epoll_dealloc,
    1, /* need reinit */
    EV_FEATURE_ET|EV_FEATURE_O1,
    0
};

struct epollop {
    struct epoll_event *events;
    int nevents;
    int epfd;
};

可以发现，每个io多路复用函数的封装都是遵循struct eventop类型的，所以base中只需要存储着eventop类型的指针evsel，在初始化它之后只需要调用struct eventop提供的接口函数，就可以直接调用io多路复用函数的接口函数，实现了统一

而对于每个io多路复用函数的数据类型，libevent没有进行统一的封装，因为也没有必要。在初始化base中

/* 
 * evbase存储的就是对应的数据结构，它是个void*指针，所以可以存储任意类型的结构，比如
 * 对于select而言是struct selectop，
 * 对于epoll而言是struct epollop
 * /
base->evbase = base->evsel->init(base);

---

libevent中io多路复用的使用体现在

• 新建event注册到base中，此时会把监听的fd和事件添加到io复用中，本质上就是调用epoll_ctl，FD_SET等
• 删除event从base中，会把监听的fd从io复用中删除，本质上调用epoll_ctl等
• 开启事件驱动循环，监听事件的发生，本质上调用各种wait函数如epoll_wait，select，poll等
  比如添加event

//函数将event添加到base的io map和io复用函数的监听事件中
int
evmap_io_add(struct event_base *base, evutil_socket_t fd, struct event *ev)
{
    /* ... */

    if (evsel->add(base, ev->ev_fd,
        old, (ev->ev_events & EV_ET) | res, extra) == -1)
        return (-1);

    /* ... */
}

//将event从io map中删除,由event_del_internal调用
int
evmap_io_del(struct event_base *base, evutil_socket_t fd, struct event *ev)
{
    /* ... */

    if (evsel->del(base, ev->ev_fd, old, res, extra) == -1)
        return (-1);

    /* ... */
}

/*
 * 实际的事件驱动循环，其实就是一个while循环，每次调用io复用函数进行事件监听
 * 监听返回之前将活跃的event都按优先级添加到base的激活队列中
 * 回到循环后对base的激活队列中的event按照优先级顺序调用回调函数
 * 再根据是否是永久event决定要不要从base的所有队列中删除event
 * 对于具有超时时间的event则需要特殊处理，见timeout_process
 */
int
event_base_loop(struct event_base *base, int flags)
{
    const struct eventop *evsel = base->evsel;
    struct timeval tv;
    struct timeval *tv_p;
    int res, done, retval = 0;

    /* ... */

    done = 0;
    while (!done) {

        /* ... */

        /*
         * 调用Io复用函数的监听函数，开始阻塞/非阻塞的监听
         * 超时时间设置为最小堆中堆顶event的超时时间,原因如下
         * 
         * 此时监听的有三种event
         * 第一种是没有设置超时时间的，包括信号，所以什么时候返回都不影响
         * 第二种是取得最小超时时间的堆顶event，此时可以满足在超时时间返回
         * 第三种是最小堆中的其他event，这些event的超时时间在堆顶event之后，因为超时时间是绝对时间
         *      也就是说如果堆顶event没有超时，那么其它的event将不可能超时
         *      而当最小超时时间后返回处理超时之后重新开始监听，
         *      因为是绝对时间，所以不会影响最小堆的其他event的超时
         *
         * 在返回之间，将活跃的event添加到base的激活队列中
         * 
         * 注意：不处理具有超时时间的event，因为这些event根本就没有添加到io函数中
         * 处理这些是在timeout_process函数中
         */
        res = evsel->dispatch(base, tv_p);


         /* ... */
    }

     /* ... */
    return (retval);
}

其实都是间接调用每一个io接口

---

总结
这部分主要学习到libevent是如何实现跨平台的io多路复用函数的选择的，所谓跨平台，就是将所有可能的平台都考虑到。同时看到libevent是如何把所有io函数都进行统一的，这一点很值得学习
题外话，其实对io的封装就是基类纯虚函数加各种派生类，用基类指针实现多态….