Libevent(2.1.8)中的事件結構和管理

Libevent(2.1.8)中的事件結構體

這裏的libevent版本爲 2.1.8 。 libevent中事件的結構體struct event，定義在event_struct.h 中， 這裏咱們簡單看一下：

struct event {
    struct event_callback ev_evcallback; //事件的回調函數

    /* for managing timeouts */
    union {
        TAILQ_ENTRY(event) ev_next_with_common_timeout;// 鏈表形式管理定時 以前只用最小堆管理超時
        int min_heap_idx; //最小堆 管理超時事件
    } ev_timeout_pos;// 二選一
    evutil_socket_t ev_fd; // io事件時爲關心的文件描述符，信號事件時爲信號值

    struct event_base *ev_base;// 所屬事件堆的實例

    union {
        /* used for io events */
        struct {
            LIST_ENTRY (event) ev_io_next;
            struct timeval ev_timeout;
        } ev_io;  //這部分指io事件時 所關心的同一描述符下，全部IO事件的鏈表

        /* used by signal events */
        struct {
            LIST_ENTRY (event) ev_signal_next;
            short ev_ncalls;
            /* Allows deletes in callback */
            short *ev_pncalls;
        } ev_signal;//同一信號下信號事件鏈表
    } ev_;

    short ev_events;     //事件的類型  可讀可寫 超時等
    short ev_res;        /* result passed to event callback */
    struct timeval ev_timeout; //事件超時時間
};

這裏能夠看到這個版本下的event 結構體比以前的好像少了很多東西， 如以前的結構：

//event提供了函數接口,供Reactor在事件發生時調用,以執行相應的事件處理,
//一般它會綁定一個有效的句柄(ev_fd)作爲回調函數的參數.
struct event {
    //已註冊事件隊列入口
    TAILQ_ENTRY (event) ev_next;
    //已激活事件隊列入口
    TAILQ_ENTRY (event) ev_active_next;
    //信號事件隊列入口 不過在之前的分析中能夠看到，未來這個隊列中的內容會被添加到ev_active_next隊列中。
    TAILQ_ENTRY (event) ev_signal_next;
    //表示該event在定時器事件最小堆min_heap的索引
    unsigned int min_heap_idx;    /* for managing timeouts */
    //該事件所屬的反應堆實例
    struct event_base *ev_base;
    //對於I/O事件,是綁定的文件描述符; 對於signal事件,是綁定的信號.
    int ev_fd;

    //表示事件類型: I/O,定時器或者信號
    short ev_events;

    //事件就緒執行時,將要調用ev_callback 的次數,一般爲1
    short ev_ncalls;

    //該事件的超時時間,在定時器最小堆min_heap操做中做爲節點值進行比較.
    struct timeval ev_timeout;

    //該事件的優先級,越小越優先.
    int ev_pri;        /* smaller numbers are higher priority */

    //該事件被激活時的回調函數
    void (*ev_callback)(int, short, void *arg);

    //該事件的標記信息,表示其當前的狀態,即它在哪一個鏈表中
    int ev_flags;

    ... //其餘成員.
};

這裏能夠看到在老版本的libevent 中event結構體中有回調函數， 參數，優先級參數， 新版本中都被定義在了struct event_callback ev_evcallback;中 以下：

struct event_callback {
    TAILQ_ENTRY(event_callback) evcb_active_next;
    short evcb_flags;     //選擇回調類型 由如下四種
    ev_uint8_t evcb_pri;    /* smaller numbers are higher priority */
    ev_uint8_t evcb_closure; 
    /* allows us to adopt for different types of events */
        union {
        void (*evcb_callback)(evutil_socket_t, short, void *);
        void (*evcb_selfcb)(struct event_callback *, void *);
        void (*evcb_evfinalize)(struct event *, void *);
        void (*evcb_cbfinalize)(struct event_callback *, void *);
    } evcb_cb_union;
    void *evcb_arg;
};

比起老版本 新版本又丟棄了TAILQ_ENTRY(event) ev_next; 已註冊事件隊列入口   ev_active_next 已激活隊列入口 ev_signal_next 信號事件隊列入口等結構。

Libevent 事件堆實例結構體：

新版本的struct base_event 以下：

struct event_base {
    /** Function pointers and other data to describe this event_base's
     * backend. */
    const struct eventop *evsel;//具體事件處理模型結構(select /poll/epoll)指針
    /** Pointer to backend-specific data. */
    void *evbase;//指向IO複用的真正操做 經過evsel來初始化

    /** List of changes to tell backend about at next dispatch.  Only used
     * by the O(1) backends. */
    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. */
    struct evsig_info sig;

    /** Number of virtual events */
    int virtual_event_count; //？？？？？？後續
    /** Maximum number of virtual events active */
    int virtual_event_count_max; //？？？？？
    /** Number of total events added to this event_base */
    int event_count;   //事件總數
    /** Maximum number of total events added to this event_base */
    int event_count_max;//事件堆最多的事件數量
    /** Number of total events active in this event_base */
    int event_count_active; 
    /** Maximum number of total events active in this event_base */
    int event_count_active_max;

    /** 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;  //當前running 事件的優先級

    /** Set if we're running the event_base_loop function, to prevent
     * reentrant invocation. */
    int running_loop; //是否正在loop event

    /** Set to the number of deferred_cbs we've made 'active' in the
     * loop.  This is a hack to prevent starvation; it would be smarter
     * to just use event_config_set_max_dispatch_interval's max_callbacks
     * feature */
    int n_deferreds_queued;

    /* Active event management. */
    /** An array of nactivequeues queues for active event_callbacks (ones
     * that have triggered, and whose callbacks need to be called).  Low
     * priority numbers are more important, and stall higher ones.
     */
    //已激活的回調事件隊列  即event_callback 結構的隊列
    struct evcallback_list *activequeues;
    /** The length of the activequeues array */
    int nactivequeues; //激活隊列長度
    /** A list of event_callbacks that should become active the next time
     * we process events, but not this time. */
    struct evcallback_list active_later_queue;// 下次激活的事件隊列？

    /* 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;

    /** Mapping from file descriptors to enabled (added) events */
    struct event_io_map io;//存儲io 事件

    /** Mapping from signal numbers to enabled (added) events. */
    struct event_signal_map sigmap;//存儲信號事件

    /** 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;

    struct evutil_monotonic_timer monotonic_timer;

    /** 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;

#ifndef EVENT__DISABLE_THREAD_SUPPORT   //多線程支持
    /* threading support */
    /** The thread currently running the event_loop for this base */
    unsigned long th_owner_id;
    /** A lock to prevent conflicting accesses to this event_base */
    void *th_base_lock;
    /** 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. */
    int current_event_waiters;
#endif
    /** The event whose callback is executing right now */
    struct event_callback *current_event;


    /** Flags that this base was configured with */
//這裏後續的event config 會講到
    enum event_base_config_flag flags;

    struct timeval max_dispatch_time;
    int max_dispatch_callbacks;
    int limit_callbacks_after_prio;

    /* Notify main thread to wake up break, etc. */
　　//多線程   主線程loop過程當中通常會阻塞  
　　//若這時添加或者刪除事件的話， 就須要喚醒阻塞的主線程， 加入了一個未決狀態 
    /** True if the base already has a pending notify, and we don't need
     * to add any more. */
    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);//喚醒主線程的函數指針

    /** Saved seed for weak random number generator. Some backends use
     * this to produce fairness among sockets. Protected by th_base_lock. */
    struct evutil_weakrand_state weakrand_seed;

    /** List of event_onces that have not yet fired. */
    LIST_HEAD(once_event_list, event_once) once_events;

};

對於事件的存儲 老版本中用隊列來存儲， 在新版本中使用哈希表map 如event_io_map , event_signal_map結構。還有一些多線程支持的參數後續會看到它們的用途。後續還會詳細解釋其中的各個字段含義。