Libevent源码剖析（三）

事件集合（struct event_base）

struct event_base *event_base_new(void)

其中有很多的函数已经追踪阅读，但是没有展示，设计思想不难，但是代码由于#define的存在，有点复杂。

Order 0：struct event_base *event_base_new(void)

struct event_base * event_base_new(void)
{
        struct event_base *base = NULL;
    struct event_config *cfg = event_config_new();        //获取一个struct event_config对象
    if (cfg) {        //如果对象获取成功，根据config对struct event_base对象进行设置，然后free config object
        base = event_base_new_with_config(cfg);
        event_config_free(cfg);
    }
    return base;
}

Order 1：struct event_config* event_config_new(void)和void event_config_free(struct event_config *cfg)

struct event_config* event_config_new(void)
{
    struct event_config *cfg = mm_calloc(1, sizeof(*cfg));        //从自定义的alloc中分配一块空间用于存放config object

    if (cfg == NULL)        //如果分配失败，返回NULL
        return (NULL);

    TAILQ_INIT(&cfg->entries);        //初始化config object的双向队列
    cfg->max_dispatch_interval.tv_sec = -1;        //如果为-1，则在没有事件时陷入等待，直到有事件发生。
    cfg->max_dispatch_callbacks = INT_MAX;        //将callback的处理限制为INT_MAX
    cfg->limit_callbacks_after_prio = 1;        //优先级默认为1，就是全局只有这么一个优先级

    return (cfg);
}

void event_config_free(struct event_config *cfg)
{
    struct event_config_entry *entry;        //从config object中逐个取出struct event_config_entry对象（这个对象中没啥实际的东西）并删除

    while ((entry = TAILQ_FIRST(&cfg->entries)) != NULL) {
        TAILQ_REMOVE(&cfg->entries, entry, next);
        event_config_entry_free(entry);
    }
    mm_free(cfg);        //归还config Object内存
}

Order 1：struct event_base * event_base_new_with_config(const struct event_config *cfg)

struct event_base * event_base_new_with_config(const struct event_config *cfg)
{
    int i;
    struct event_base *base;
    int should_check_environment;

#ifndef EVENT__DISABLE_DEBUG_MODE
    event_debug_mode_too_late = 1;
#endif

    if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) {        //获取存储struct event_base的对象
        event_warn("%s: calloc", __func__);
        return NULL;
    }

    if (cfg)    //根据config对象设置event_base
        base->flags = cfg->flags;

    should_check_environment =
        !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV));        //判断是否需要检查当前环境

    {
        struct timeval tmp;
        int precise_time =
            cfg && (cfg->flags & EVENT_BASE_FLAG_PRECISE_TIMER);        //检查是否设置了精确时间的选项
        int flags;
        if (should_check_environment && !precise_time) {
            precise_time = evutil_getenv_("EVENT_PRECISE_TIMER") != NULL;
            base->flags |= EVENT_BASE_FLAG_PRECISE_TIMER;
        }
        flags = precise_time ? EV_MONOT_PRECISE : 0;        //判断是否需要精确时间选项
        evutil_configure_monotonic_time_(&base->monotonic_timer, flags);        //配置那个为空的对象

        gettime(base, &tmp);        //获取时间
    }

    min_heap_ctor_(&base->timeheap);        //将超时时间以最小堆组织起来

    base->sig.ev_signal_pair[0] = -1;        //将sockpair处理的事件机制的fd初始化为-1
    base->sig.ev_signal_pair[1] = -1;
    base->th_notify_fd[0] = -1;
    base->th_notify_fd[1] = -1;

    TAILQ_INIT(&base->active_later_queue);        //初始化下一轮循环通知的事件初始化

    evmap_io_initmap_(&base->io);        //初始化IO事件map（HASH）
    evmap_signal_initmap_(&base->sigmap);        //初始化信号事件（HASH）
    event_changelist_init_(&base->changelist);        //初始化事件修改链表

    base->evbase = NULL;        //将指向特定数据的指针初始化为NULL

    if (cfg) {
        memcpy(&base->max_dispatch_time,
            &cfg->max_dispatch_interval, sizeof(struct timeval));        //根据config对象，初始化struct event_base的：
        base->limit_callbacks_after_prio =
            cfg->limit_callbacks_after_prio;
    } else {
        base->max_dispatch_time.tv_sec = -1;        //事件循环时间
        base->limit_callbacks_after_prio = 1;        //事件优先级
    }
    if (cfg && cfg->max_dispatch_callbacks >= 0) {        //初始化事件处理的最大数量
        base->max_dispatch_callbacks = cfg->max_dispatch_callbacks;
    } else {
        base->max_dispatch_callbacks = INT_MAX;
    }
    if (base->max_dispatch_callbacks == INT_MAX &&
        base->max_dispatch_time.tv_sec == -1)
        base->limit_callbacks_after_prio = INT_MAX;        //初始化优先级数量

    for (i = 0; eventops[i] && !base->evbase; i++) {        //eventops是一个全局数据结构，如果全局数据结构存在并且base的私有数据不存在，就执行代码
        if (cfg != NULL) {        //如果有config object
            if (event_config_is_avoided_method(cfg,
                eventops[i]->name))        //将eventop中的name字符串，传递给配置对象
                continue;
            if ((eventops[i]->features & cfg->require_features)
                != cfg->require_features)
                continue;
        }

        /* also obey the environment variables */
        if (should_check_environment &&
            event_is_method_disabled(eventops[i]->name))
            continue;

        base->evsel = eventops[i];        //将信号处理ops注册给base的信号处理ops

        base->evbase = base->evsel->init(base);        //私有数据 = struct event_base对象？？有可能是反向获取struct event_base的方式之一
    }

    if (base->evbase == NULL) {        //如果反向获取指针处理失败，直接返回
        event_warnx("%s: no event mechanism available",
            __func__);
        base->evsel = NULL;
        event_base_free(base);
        return NULL;
    }

    if (evutil_getenv_("EVENT_SHOW_METHOD"))        
        event_msgx("libevent using: %s", base->evsel->name);

    /* allocate a single active event queue */
    if (event_base_priority_init(base, 1) < 0) {        //初始化事件处理的优先级队列
        event_base_free(base);
        return NULL;
    }

    /* prepare for threading */

#if !defined(EVENT__DISABLE_THREAD_SUPPORT) && !defined(EVENT__DISABLE_DEBUG_MODE)
    event_debug_created_threadable_ctx_ = 1;
#endif

    if (EVTHREAD_LOCKING_ENABLED() &&
        (!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK))) {
        int r;
        EVTHREAD_ALLOC_LOCK(base->th_base_lock, 0);        //初始化互斥锁
        EVTHREAD_ALLOC_COND(base->current_event_cond);        //初始化条件变量
        r = evthread_make_base_notifiable(base);        //这个函数会初始化与唤醒主线程的sockpair以及注册唤醒主线程的函数，都不难，可以很快用C++实现
        if (r<0) {
            event_warnx("%s: Unable to make base notifiable.", __func__);
            event_base_free(base);
            return NULL;
        }
    }

    return (base);        //返回已经初始化的struct event_base对象
}

void event_base_free(struct event_base *base)

Order 0：void event_base_free(struct event_base *base)

void event_base_free(struct event_base *base)
{
    event_base_free_(base, 1);
}

Order 1：static void event_base_free_(struct event_base *base, int run_finalizers)

static void event_base_free_(struct event_base *base, int run_finalizers)
{
    int i, n_deleted=0;
    struct event *ev;
    
    if (base == NULL && current_base)        //获取现有的struct event_base对象
        base = current_base;

    if (base == NULL) {
        event_warnx("%s: no base to free", __func__);
        return;
    }

    if (base->th_notify_fd[0] != -1) {        //在事件库中存在多个线程，终止时需要合理的处理这些线程
        event_del(&base->th_notify);        //从事件队列中删除与多线程通信的事件
        EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);        //关闭管道fd
        if (base->th_notify_fd[1] != -1)
            EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);        //关闭管道fd
        base->th_notify_fd[0] = -1;
        base->th_notify_fd[1] = -1;
        event_debug_unassign(&base->th_notify);        //测试这个event是否已经取消注册
    }

    evmap_delete_all_(base);        //删除事件链表中所有的IO事件与信号事件

    while ((ev = min_heap_top_(&base->timeheap)) != NULL) {        //从最小堆中删除所有的超时事件 
        event_del(ev);
        ++n_deleted;
    }
    for (i = 0; i < base->n_common_timeouts; ++i) {        //这个管理超时事件的common没有搞懂
        struct common_timeout_list *ctl =
            base->common_timeout_queues[i];
        event_del(&ctl->timeout_event); /* Internal; doesn't count */
        event_debug_unassign(&ctl->timeout_event);
        for (ev = TAILQ_FIRST(&ctl->events); ev; ) {
            struct event *next = TAILQ_NEXT(ev,
                ev_timeout_pos.ev_next_with_common_timeout);
            if (!(ev->ev_flags & EVLIST_INTERNAL)) {
                event_del(ev);
                ++n_deleted;
            }
            ev = next;
        }
        mm_free(ctl);
    }
    if (base->common_timeout_queues)        //释放公共超时事件队列
        mm_free(base->common_timeout_queues);

    for (;;) {        //回收处理事件的线程资源
        int i = event_base_free_queues_(base, run_finalizers);
        if (!i) {
            break;
        }
        n_deleted += i;
    }

    if (n_deleted)
        event_debug(("%s: %d events were still set in base",
            __func__, n_deleted));

    while (LIST_FIRST(&base->once_events)) {        //从只注册一次的事件，但是事件还没有发生的链表中，逐个删除事件
        struct event_once *eonce = LIST_FIRST(&base->once_events);
        LIST_REMOVE(eonce, next_once);
        mm_free(eonce);
    }

    if (base->evsel != NULL && base->evsel->dealloc != NULL)
        base->evsel->dealloc(base);        //使用注册的函数清理base

    for (i = 0; i < base->nactivequeues; ++i)        //在销毁struct event_base对象之前，逐个清理
        EVUTIL_ASSERT(TAILQ_EMPTY(&base->activequeues[i]));

    EVUTIL_ASSERT(min_heap_empty_(&base->timeheap));        //在销毁之前，确保最小堆已经被清理干净
    min_heap_dtor_(&base->timeheap);        //销毁最小堆

    mm_free(base->activequeues);        //释放活动事件队列

    evmap_io_clear_(&base->io);        //清理IO事件队列
    evmap_signal_clear_(&base->sigmap);        //清理信号事件队列
    event_changelist_freemem_(&base->changelist);        //清理改变事件队列

    EVTHREAD_FREE_LOCK(base->th_base_lock, 0);        //释放锁与条件变量
    EVTHREAD_FREE_COND(base->current_event_cond);

    if (base == current_base)
        current_base = NULL;
    mm_free(base);
}

int event_reinit(struct event_base *base)

Order 0：int event_reinit(struct event_base *base)

int event_reinit(struct event_base *base)
{
    const struct eventop *evsel;
    int res = 0;
    int was_notifiable = 0;
    int had_signal_added = 0;

    EVBASE_ACQUIRE_LOCK(base, th_base_lock);        //获取锁

    evsel = base->evsel;        //获取处理事件的ops

    if (evsel->need_reinit) {        //如果struct event_base对象在fork之后需要重新进行处理
        base->evsel = &nil_eventop;        //获取信号处理
    }

    if (base->sig.ev_signal_added) {
        event_del_nolock_(&base->sig.ev_signal, EVENT_DEL_AUTOBLOCK);
        event_debug_unassign(&base->sig.ev_signal);
        memset(&base->sig.ev_signal, 0, sizeof(base->sig.ev_signal));
        had_signal_added = 1;
        base->sig.ev_signal_added = 0;
    }
    if (base->sig.ev_signal_pair[0] != -1)
        EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[0]);
    if (base->sig.ev_signal_pair[1] != -1)
        EVUTIL_CLOSESOCKET(base->sig.ev_signal_pair[1]);
    if (base->th_notify_fn != NULL) {
        was_notifiable = 1;
        base->th_notify_fn = NULL;
    }
    if (base->th_notify_fd[0] != -1) {
        event_del_nolock_(&base->th_notify, EVENT_DEL_AUTOBLOCK);
        EVUTIL_CLOSESOCKET(base->th_notify_fd[0]);
        if (base->th_notify_fd[1] != -1)
            EVUTIL_CLOSESOCKET(base->th_notify_fd[1]);
        base->th_notify_fd[0] = -1;
        base->th_notify_fd[1] = -1;
        event_debug_unassign(&base->th_notify);
    }

    /* Replace the original evsel. */
        base->evsel = evsel;

    if (evsel->need_reinit) {
        /* Reconstruct the backend through brute-force, so that we do
         * not share any structures with the parent process. For some
         * backends, this is necessary: epoll and kqueue, for
         * instance, have events associated with a kernel
         * structure. If didn't reinitialize, we'd share that
         * structure with the parent process, and any changes made by
         * the parent would affect our backend's behavior (and vice
         * versa).
         */
        if (base->evsel->dealloc != NULL)
            base->evsel->dealloc(base);
        base->evbase = evsel->init(base);
        if (base->evbase == NULL) {
            event_errx(1,
               "%s: could not reinitialize event mechanism",
               __func__);
            res = -1;
            goto done;
        }

        /* Empty out the changelist (if any): we are starting from a
         * blank slate. */
        event_changelist_freemem_(&base->changelist);

        /* Tell the event maps to re-inform the backend about all
         * pending events. This will make the signal notification
         * event get re-created if necessary. */
        if (evmap_reinit_(base) < 0)
            res = -1;
    } else {
        res = evsig_init_(base);
        if (res == 0 && had_signal_added) {
            res = event_add_nolock_(&base->sig.ev_signal, NULL, 0);
            if (res == 0)
                base->sig.ev_signal_added = 1;
        }
    }

    /* If we were notifiable before, and nothing just exploded, become
     * notifiable again. */
    if (was_notifiable && res == 0)
        res = evthread_make_base_notifiable_nolock_(base);

done:
    EVBASE_RELEASE_LOCK(base, th_base_lock);
    return (res);
}