恋恋风辰的官方博客

libevent源码刨析
Posted on 2023-02-09 17:59:29 by 恋恋风辰 | In 网络编程 | 原文链接

最近自学libevent事件驱动库，参考的资料为libevent2.2版本以及张亮提供的《Libevent源码深度剖析》，参考资料： http://blog.csdn.net/sparkliang/article/details/4957667, libevent好处之类的就不赘述了，libevent和libiop，redis等一样都是采用事件回调机制，这种模式被称作Reactor模式。正常事件处理流程是应用程序调用某个接口触发某个功能，而Reactor模式需要我们将这些接口和宿主指针（谁调用这些接口）注册在Reactor，在合适的时机Reactor使用宿主指针调用注册好的回调函数。

一： Reactor基本知识

Reactor 模式是编写高性能网络服务器的必备技术之一，它具有如下的优点：
1）响应快，不必为单个同步时间所阻塞，虽然 Reactor 本身依然是同步的；
2）编程相对简单，可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销；
3）可扩展性，可以方便的通过增加 Reactor 实例个数来充分利用 CPU 资源；
4）可复用性， reactor 框架本身与具体事件处理逻辑无关，具有很高的复用性；
Reactor模式框架
https://cdn.llfc.club/reactorlib.png
<!--more-->
1） Handle 意思为句柄，在Linux表示文件描述符，在windows是socket或者handle。

2）EventDemultiplexer 表示事件多路分发机制，调用系统提供的I/O多路复用机制，比如select，epoll,程序先将关注的句柄注册到EventDemultiplexer上,当有关注的事件
到来时，触发EventDemultiplexer通知程序，程序调用之前注册好的回调函数完成消息相应。对应到 libevent 中，依然是 select、 poll、 epoll 等，但是 libevent 使用结构体eventop进行了 封装，以统一的接口来支持这些 I/O 多路复用机制，达到了对外隐藏底层系统机制的目的。
3）Reactor——反应器
Reactor，是事件管理的接口，内部使用 event demultiplexer 注册、注销事件；并运行事件循环，当有事件进入“就绪”状态时，调用注册事件的回调函数处理事件。
对应到 libevent 中，就是 event_base 结构体。一个典型的Reactor声明方式

  1. class Reactor
  2. {
  3. public:
  4. int register_handler(Event_Handler *pHandler, int event);
  5. int remove_handler(Event_Handler *pHandler, int event);
  6. void handle_events(timeval *ptv);
  7. // ...
  8. };

4） Event Handler——事件处理程序
事件处理程序提供了一组接口，每个接口对应了一种类型的事件，供 Reactor 在相应的事件发生时调用，执行相应的事件处理。通常它会绑定一个有效的句柄。
对应到 libevent 中，就是 event 结构体。下面是两种典型的 Event Handler 类声明方式， 二者互有优缺点。

  1. class Event_Handler
  2. {
  3. public:
  4. virtual void handle_read() = 0;
  5. virtual void handle_write() = 0;
  6. virtual void handle_timeout() = 0;
  7. virtual void handle_close() = 0;
  8. virtual HANDLE get_handle() = 0;
  9. // ...
  10. };
  11. class Event_Handler
  12. {
  13. public:
  14. // events maybe read/write/timeout/close .etc
  15. virtual void handle_events(int events) = 0;
  16. virtual HANDLE get_handle() = 0;
  17. // ...
  18. };

二：如何使用libevent库提供的API

1）首先初始化 libevent 库，并保存返回的指针struct event_base * base = event_init();
实际上这一步相当于初始化一个 Reactor 实例；在初始化 libevent 后，就可以注册事件了。

2）设置event属性和回调函数

调用函数void event_set(struct event ev, int fd, short event, void (cb)(int,
short, void ), void arg);

每个参数的意义：

ev：执行要初始化的 event 对象；
fd：该 event 绑定的“句柄”，对于信号事件，它就是关注的信号；
event：在该 fd 上关注的事件类型，它可以是 EV_READ, EV_WRITE, EV_SIGNAL；
cb：这是一个函数指针，当 fd 上的事件 event 发生时，调用该函数执行处理，它有三个参数，分别是关注的fd, 关注的事件类型（读/写/信号），回调函数的参数void* arg，调用时由event_base 负责传入，按顺序，实际上就是 event_set 时的 fd, event 和 arg；

arg：传递给 cb 函数指针的参数；

由于定时事件不需要 fd，并且定时事件是根据添加时（ event_add）的超时值设定的，因此这里 event 也不需要设置。
这一步相当于初始化一个 event handler，在 libevent 中事件类型保存在 event 结构体中。
注意： libevent 并不会管理 event 事件集合，这需要应用程序自行管理；

3）设置 event 从属的 event_base
event_base_set(base, &ev);
这一步相当于指明 event 要注册到哪个 event_base 实例上；

4）将事件添加到事件队列里
event_add(&ev, timeout);
基本信息都已设置完成，只要简单的调用 event_add()函数即可完成，其中 timeout 是定时值；

这一步相当于调用Reactor::register_handler()函数注册事件。

5）程序进入无限循环，等待就绪事件并执行事件处理
event_base_dispatch(base);

看一下libevent提供的sample

  1. int
  2. main(int argc, char **argv)
  3. {
  4.     struct event evfifo;
  5. #ifdef WIN32
  6.     HANDLE socket;
  7.     /* Open a file. */
  8.     socket = CreateFileA("test.txt",    /* open File */
  9.             GENERIC_READ,        /* open for reading */
  10.             0,            /* do not share */
  11.             NULL,            /* no security */
  12.             OPEN_EXISTING,        /* existing file only */
  13.             FILE_ATTRIBUTE_NORMAL,    /* normal file */
  14.             NULL);            /* no attr. template */
  16.     if (socket == INVALID_HANDLE_VALUE)
  17.         return 1;
  19. #else
  20.     struct stat st;
  21.     const char *fifo = "event.fifo";
  22.     int socket;
  24.     if (lstat(fifo, &st) == 0) {
  25.         if ((st.st_mode & S_IFMT) == S_IFREG) {
  26.             errno = EEXIST;
  27.             perror("lstat");
  28.             exit(1);
  29.         }
  30.     }
  32.     unlink(fifo);
  33.     if (mkfifo(fifo, 0600) == -1) {
  34.         perror("mkfifo");
  35.         exit(1);
  36.     }
  38.     /* Linux pipes are broken, we need O_RDWR instead of O_RDONLY */
  39. #ifdef __linux
  40.     socket = open(fifo, O_RDWR | O_NONBLOCK, 0);
  41. #else
  42.     socket = open(fifo, O_RDONLY | O_NONBLOCK, 0);
  43. #endif
  45.     if (socket == -1) {
  46.         perror("open");
  47.         exit(1);
  48.     }
  50.     fprintf(stderr, "Write data to %s\n", fifo);
  51. #endif
  52.     /* Initalize the event library */
  53.     event_init();
  55.     /* Initalize one event */
  56. #ifdef WIN32
  57.     event_set(&evfifo, (evutil_socket_t)socket, EV_READ, fifo_read, &evfifo);
  58. #else
  59.     event_set(&evfifo, socket, EV_READ, fifo_read, &evfifo);
  60. #endif
  62.     /* Add it to the active events, without a timeout */
  63.     event_add(&evfifo, NULL);
  65.     event_dispatch();
  66. #ifdef WIN32
  67.     CloseHandle(socket);
  68. #endif
  69.     return (0);
  70. }

main函数里调用event_init()初始化一个event_base,之后调用event_set对event设置了回调函数和读事件关注，event_add将此事件加入event队列里，超时设置为空最后调用event_dispatch()进行事件轮训派发。fifo_read是一个回调函数，格式就是之前说的cb格式

  1. static void
  2. fifo_read(evutil_socket_t fd, short event, void *arg)
  3. {
  4.     char buf[255];
  5.     int len;
  6.     struct event *ev = arg;
  7. #ifdef WIN32
  8.     DWORD dwBytesRead;
  9. #endif
  11.     /* Reschedule this event */
  12.     event_add(ev, NULL);
  14.     fprintf(stderr, "fifo_read called with fd: %d, event: %d, arg: %p\n",
  15.         (int)fd, event, arg);
  16. #ifdef WIN32
  17.     len = ReadFile((HANDLE)fd, buf, sizeof(buf) - 1, &dwBytesRead, NULL);
  19.     /* Check for end of file. */
  20.     if (len && dwBytesRead == 0) {
  21.         fprintf(stderr, "End Of File");
  22.         event_del(ev);
  23.         return;
  24.     }
  26.     buf[dwBytesRead] = '\0';
  27. #else
  28.     len = read(fd, buf, sizeof(buf) - 1);
  30.     if (len == -1) {
  31.         perror("read");
  32.         return;
  33.     } else if (len == 0) {
  34.         fprintf(stderr, "Connection closed\n");
  35.         return;
  36.     }
  38.     buf[len] = '\0';
  39. #endif
  40.     fprintf(stdout, "Read: %s\n", buf);
  41. }

三：《libevent 代码深度剖析》中对文件组织进行了归类

1）头文主要就是 event.h：事件宏定义、接口函数声明，主要结构体 event 的声明；

2）内部头文件
xxx-internal.h：内部数据结构和函数，对外不可见，以达到信息隐藏的目的；
3） libevent 框架
event.c： event 整体框架的代码实现；
4）对系统 I/O 多路复用机制的封装
epoll.c：对 epoll 的封装；
select.c：对 select 的封装；
devpoll.c：对 dev/poll 的封装;
kqueue.c：对 kqueue 的封装；
5）定时事件管理
min-heap.h：其实就是一个以时间作为 key 的小根堆结构；
6）信号管理
signal.c：对信号事件的处理；
7）辅助功能函数
evutil.h 和 evutil.c：一些辅助功能函数，包括创建 socket pair 和一些时间操作函数：加、减
和比较等。
8）日志
log.h 和 log.c： log 日志函数
9）缓冲区管理
evbuffer.c 和 buffer.c： libevent 对缓冲区的封装；
10）基本数据结构
compat\sys 下的两个源文件： queue.h 是 libevent 基本数据结构的实现，包括链表，双向链表，
队列等； _libevent_time.h：一些用于时间操作的结构体定义、函数和宏定义；
11）实用网络库

http 和 evdns：是基于 libevent 实现的 http 服务器和异步 dns 查询库；

四：event结构知识

下面着重看下event结构体，这是libevent核心结构

  1. struct event {
  2.     TAILQ_ENTRY(event) ev_active_next;
  3.     TAILQ_ENTRY(event) ev_next;
  4.     /* for managing timeouts */
  5.     union {
  6.         TAILQ_ENTRY(event) ev_next_with_common_timeout;
  7.         int min_heap_idx;
  8.     } ev_timeout_pos;
  9.     evutil_socket_t ev_fd;
  11.     struct event_base *ev_base;
  13.     union {
  14.         /* used for io events */
  15.         struct {
  16.             TAILQ_ENTRY(event) ev_io_next; 
  17.             struct timeval ev_timeout;
  18.         } ev_io;
  20.         /* used by signal events */
  21.         struct {
  22.             TAILQ_ENTRY(event) ev_signal_next;
  23.             short ev_ncalls;
  24.             /* Allows deletes in callback */
  25.             short *ev_pncalls;
  26.         } ev_signal;
  27.     } _ev;
  29.     short ev_events;
  30.     short ev_res;        /* result passed to event callback */
  31.     short ev_flags;
  32.     ev_uint8_t ev_pri;    /* smaller numbers are higher priority */
  33.     ev_uint8_t ev_closure;
  34.     struct timeval ev_timeout;
  36.     /* allows us to adopt for different types of events */
  37.     void (*ev_callback)(evutil_socket_t, short, void *arg);
  38.     void *ev_arg;
  39. };

ev_active_next： 表示就绪状态的事件链表指针，当关注的事件就绪后，会把

对应的event放入active的队列里。表示该事件在active队列里的位置

ev_next：表示所有事件队列链表的指针。表示该事件在所有时间列表的位置。

ev_timeout_pos：用于管理超时

ev_fd：event绑定的socket描述符

ev_events:event关注的事件类型，它可以是以下3种类型：
I/O事件： EV_WRITE和EV_READ
定时事件： EV_TIMEOUT
信号： EV_SIGNAL
辅助选项： EV_PERSIST，表明是一个永久事件

Libevent中的定义为：

  1. #define EV_TIMEOUT 0x01
  2. #define EV_READ 0x02
  3. #define EV_WRITE 0x04
  4. #define EV_SIGNAL 0x08
  5. #define EV_PERSIST 0x10 /* Persistant event */

ev_res：记录了当前激活事件的类型；

ev_flags： libevent 用于标记 event 信息的字段，表明其当前的状态，可能的值有：

  1. #define EVLIST_TIMEOUT 0x01 // event在time堆中
  2. #define EVLIST_INSERTED 0x02 // event在已注册事件链表中
  3. #define EVLIST_SIGNAL 0x04 // 未见使用
  4. #define EVLIST_ACTIVE 0x08 // event在激活链表中
  5. #define EVLIST_INTERNAL 0x10 // 内部使用标记
  6. #define EVLIST_INIT 0x80 // event 已被初始化

ev_pri：当前事件的优先级

ev_timeout：超时时间设置

ev_callback：该事件对应的回调函数，和cb类型一样

ev_arg：回调函数用到参数

ev_ncalls：事件就绪执行时，调用 ev_callback 的次数，通常为 1；
ev_pncalls：指针，通常指向 ev_ncalls 或者为 NULL；

五：libevent对于event的管理和使用

对于event使用流程之前有讲过，需要设置event的属性和回调函数，然后将其加入event队列里。设置event属性和回调函数的api如下

  1. void
  2. event_set(struct event *ev, evutil_socket_t fd, short events,
  3.       void (*callback)(evutil_socket_t, short, void *), void *arg)
  4. {
  5.     int r;
  6.     r = event_assign(ev, current_base, fd, events, callback, arg);
  7.     EVUTIL_ASSERT(r == 0);
  8. }

ev：表示event指针

fd:event要关注的socket fd

events:event关注的事件类型(读写I/O，信号，时间事件等)

callback:event就绪后会调用的回调函数

arg：调用回调函数时，函数的参数

该函数内部调用了event_assign完成设置

  1. int
  2. event_assign(struct event *ev, struct event_base *base, evutil_socket_t fd, short events, void (*callback)(evutil_socket_t, short, void *), void *arg)
  3. {
  4.     if (!base)
  5.         base = current_base;
  7.     _event_debug_assert_not_added(ev);
  9.     ev->ev_base = base;
  11.     ev->ev_callback = callback;
  12.     ev->ev_arg = arg;
  13.     ev->ev_fd = fd;
  14.     ev->ev_events = events;
  15.     ev->ev_res = 0;
  16.     ev->ev_flags = EVLIST_INIT;
  17.     ev->ev_ncalls = 0;
  18.     ev->ev_pncalls = NULL;
  20.     if (events & EV_SIGNAL) {
  21.         if ((events & (EV_READ|EV_WRITE)) != 0) {
  22.             event_warnx("%s: EV_SIGNAL is not compatible with "
  23.                 "EV_READ or EV_WRITE", __func__);
  24.             return -1;
  25.         }
  26. 　　　　//对于信号设置终止信号
  27.         ev->ev_closure = EV_CLOSURE_SIGNAL;
  28.     } else {
  29.         if (events & EV_PERSIST) {
  30.             evutil_timerclear(&ev->ev_io_timeout);
  31. 　　　　//永久事件
  32.             ev->ev_closure = EV_CLOSURE_PERSIST;
  33.         } else {
  34.             ev->ev_closure = EV_CLOSURE_NONE;
  35.         }
  36.     }
  38.     min_heap_elem_init(ev);
  40.     if (base != NULL) {
  41.         /* by default, we put new events into the middle priority */
  42.         ev->ev_pri = base->nactivequeues / 2;
  43.     }
  45.     _event_debug_note_setup(ev);
  47.     return 0;
  48. }

设置好event属性和回调函数后，需要将event设置到指定的event_base中，因为有可能存在很多event_base。调用如下函数

  1. int
  2. event_base_set(struct event_base *base, struct event *ev)
  3. {
  4.     /* Only innocent events may be assigned to a different base */
  5.     if (ev->ev_flags != EVLIST_INIT)
  6.         return (-1);
  8.     _event_debug_assert_is_setup(ev);
  10.     ev->ev_base = base;
  11.     ev->ev_pri = base->nactivequeues/2;
  13.     return (0);
  14. }

该函数设置了优先级和隶属于哪个base另外还有一个设置优先级的函数

int event_priority_set(struct event *ev, int pri)
设置event ev的优先级，没什么可说的，注意的一点就是：当ev正处于就绪状态时，不能设置，返回-1

六：event_base结构分析和使用

event_base结构如下

  1. struct event_base {
  2.     /** Function pointers and other data to describe this event_base's
  3.      * backend. */
  4.     const struct eventop *evsel;
  5.     /** Pointer to backend-specific data. */
  6.     void *evbase;
  8.     /** List of changes to tell backend about at next dispatch.  Only used
  9.      * by the O(1) backends. */
  10.     struct event_changelist changelist;
  12.     /** Function pointers used to describe the backend that this event_base
  13.      * uses for signals */
  14.     const struct eventop *evsigsel;
  15.     /** Data to implement the common signal handelr code. */
  16.     struct evsig_info sig;
  18.     /** Number of virtual events */
  19.     int virtual_event_count;
  20.     /** Number of total events added to this event_base */
  21.     int event_count;
  22.     /** Number of total events active in this event_base */
  23.     int event_count_active;
  25.     /** Set if we should terminate the loop once we're done processing
  26.      * events. */
  27.     int event_gotterm;
  28.     /** Set if we should terminate the loop immediately */
  29.     int event_break;
  30.     /** Set if we should start a new instance of the loop immediately. */
  31.     int event_continue;
  33.     /** The currently running priority of events */
  34.     int event_running_priority;
  36.     /** Set if we're running the event_base_loop function, to prevent
  37.      * reentrant invocation. */
  38.     int running_loop;
  40.     /* Active event management. */
  41.     /** An array of nactivequeues queues for active events (ones that
  42.      * have triggered, and whose callbacks need to be called).  Low
  43.      * priority numbers are more important, and stall higher ones.
  44.      */
  45.     struct event_list *activequeues;
  46.     /** The length of the activequeues array */
  47.     int nactivequeues;
  49.     /* common timeout logic */
  51.     /** An array of common_timeout_list* for all of the common timeout
  52.      * values we know. */
  53.     struct common_timeout_list **common_timeout_queues;
  54.     /** The number of entries used in common_timeout_queues */
  55.     int n_common_timeouts;
  56.     /** The total size of common_timeout_queues. */
  57.     int n_common_timeouts_allocated;
  59.     /** List of defered_cb that are active.  We run these after the active
  60.      * events. */
  61.     struct deferred_cb_queue defer_queue;
  63.     /** Mapping from file descriptors to enabled (added) events */
  64.     struct event_io_map io;
  66.     /** Mapping from signal numbers to enabled (added) events. */
  67.     struct event_signal_map sigmap;
  69.     /** All events that have been enabled (added) in this event_base */
  70.     struct event_list eventqueue;
  72.     /** Stored timeval; used to detect when time is running backwards. */
  73.     struct timeval event_tv;
  75.     /** Priority queue of events with timeouts. */
  76.     struct min_heap timeheap;
  78.     /** Stored timeval: used to avoid calling gettimeofday/clock_gettime
  79.      * too often. */
  80.     struct timeval tv_cache;
  82. #if defined(_EVENT_HAVE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC)
  83.     /** Difference between internal time (maybe from clock_gettime) and
  84.      * gettimeofday. */
  85.     struct timeval tv_clock_diff;
  86.     /** Second in which we last updated tv_clock_diff, in monotonic time. */
  87.     time_t last_updated_clock_diff;
  88. #endif
  90. #ifndef _EVENT_DISABLE_THREAD_SUPPORT
  91.     /* threading support */
  92.     /** The thread currently running the event_loop for this base */
  93.     unsigned long th_owner_id;
  94.     /** A lock to prevent conflicting accesses to this event_base */
  95.     void *th_base_lock;
  96.     /** The event whose callback is executing right now */
  97.     struct event *current_event;
  98.     /** A condition that gets signalled when we're done processing an
  99.      * event with waiters on it. */
  100.     void *current_event_cond;
  101.     /** Number of threads blocking on current_event_cond. */
  102.     int current_event_waiters;
  103. #endif
  105. #ifdef WIN32
  106.     /** IOCP support structure, if IOCP is enabled. */
  107.     struct event_iocp_port *iocp;
  108. #endif
  110.     /** Flags that this base was configured with */
  111.     enum event_base_config_flag flags;
  113.     /* Notify main thread to wake up break, etc. */
  114.     /** True if the base already has a pending notify, and we don't need
  115.      * to add any more. */
  116.     int is_notify_pending;
  117.     /** A socketpair used by some th_notify functions to wake up the main
  118.      * thread. */
  119.     evutil_socket_t th_notify_fd[2];
  120.     /** An event used by some th_notify functions to wake up the main
  121.      * thread. */
  122.     struct event th_notify;
  123.     /** A function used to wake up the main thread from another thread. */
  124.     int (*th_notify_fn)(struct event_base *base);
  125. };

evsel：eventop类型的指针，针对不同的模型封装了同一套操作

evbase： 不同模型开辟的数据空间，放到event_base里。

evbase和evsel配套使用，eventop结构如下

  1. struct eventop {
  2.     /** The name of this backend. */
  3.     const char *name;
  4.     /** Function to set up an event_base to use this backend.  It should
  5.      * create a new structure holding whatever information is needed to
  6.      * run the backend, and return it.  The returned pointer will get
  7.      * stored by event_init into the event_base.evbase field.  On failure,
  8.      * this function should return NULL. */
  9.     void *(*init)(struct event_base *);
  10.     /** Enable reading/writing on a given fd or signal.  'events' will be
  11.      * the events that we're trying to enable: one or more of EV_READ,
  12.      * EV_WRITE, EV_SIGNAL, and EV_ET.  'old' will be those events that
  13.      * were enabled on this fd previously.  'fdinfo' will be a structure
  14.      * associated with the fd by the evmap; its size is defined by the
  15.      * fdinfo field below.  It will be set to 0 the first time the fd is
  16.      * added.  The function should return 0 on success and -1 on error.
  17.      */
  18.     int (*add)(struct event_base *, evutil_socket_t fd, short old, short events, void *fdinfo);
  19.     /** As "add", except 'events' contains the events we mean to disable. */
  20.     int (*del)(struct event_base *, evutil_socket_t fd, short old, short events, void *fdinfo);
  21.     /** Function to implement the core of an event loop.  It must see which
  22.         added events are ready, and cause event_active to be called for each
  23.         active event (usually via event_io_active or such).  It should
  24.         return 0 on success and -1 on error.
  25.      */
  26.     int (*dispatch)(struct event_base *, struct timeval *);
  27.     /** Function to clean up and free our data from the event_base. */
  28.     void (*dealloc)(struct event_base *);
  29.     /** Flag: set if we need to reinitialize the event base after we fork.
  30.      */
  31.     int need_reinit;
  32.     /** Bit-array of supported event_method_features that this backend can
  33.      * provide. */
  34.     enum event_method_feature features;
  35.     /** Length of the extra information we should record for each fd that
  36.         has one or more active events.  This information is recorded
  37.         as part of the evmap entry for each fd, and passed as an argument
  38.         to the add and del functions above.
  39.      */
  40.     size_t fdinfo_len;
  41. };

eventop封装了epoll, select 等不同网络模型的init，add，deldispatch等回调函数。

changelist：通知后端改变的列表。

evsigsel：告诉后台 eventbase用于处理signal事件的函数指针

event_count：eventbase中总共的event数量

event_count_active： eventbase中激活的event数量

event_gotterm：这个参数设置后，一旦我们对事件做了处理，就要终止循环。

event_break：立刻结束循环

event_continue：立刻开启一个新的循环实例

event_running_priority：当前事件队列的优先级。

activequeues：激活的事件队列，priority数字小的先触发。

struct event_io_map io： 用于管理io事件的描述符

struct event_signal_map sigmap： 用于管理signal的描述符

eventqueue：所有被加入event_base的事件组成的队列

event_tv：后台记录运行的时间

timeheap：用小根堆管理超时事件队列

其他的参数不是很了解，以后用到了再琢磨。

libevent提供如下两个函数可以生成eventbase实例

  1. event_init(void)
  2. {
  3.     struct event_base *base = event_base_new_with_config(NULL);
  5.     if (base == NULL) {
  6.         event_errx(1, "%s: Unable to construct event_base", __func__);
  7.         return NULL;
  8.     }
  10.     current_base = base;
  12.     return (base);
  13. }
  15. struct event_base *
  16. event_base_new(void)
  17. {
  18.     struct event_base *base = NULL;
  19.     struct event_config *cfg = event_config_new();
  20.     if (cfg) {
  21.         base = event_base_new_with_config(cfg);
  22.         event_config_free(cfg);
  23.     }
  24.     return base;
  25. }

到此为止基本的结构介绍完了。

七libevent事件添加/删除/初始化/派发接口分析

1 event_base初始化和模型初始化

先看下初始化，实际上初始化是在event_base_new_with_config函数中完成的。

  1. struct event_base *
  2. event_base_new_with_config(const struct event_config *cfg)
  3. {
  4.     ...
  5. 　　 base->evsel = eventops[i];
  6.     base->evbase = base->evsel->init(base);
  7.     ...
  8. }

event_init和eventbase_new都会调用event_base_new_with_config这个函数.

而base->evsel是不同模型的指针，进而实现调用不同模型的init

2 事件添加注册函数

  1. int
  2. event_add(struct event *ev, const struct timeval *tv)
  3. {
  4.     int res;
  6.     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
  7.         event_warnx("%s: event has no event_base set.", __func__);
  8.         return -1;
  9.     }
  11.     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
  13.     res = event_add_internal(ev, tv, 0);
  15.     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
  17.     return (res);
  18. }

防止多线程访问出错，加了锁，并且调用了

  1. static inline int
  2. event_add_internal(struct event *ev, const struct timeval *tv,
  3.     int tv_is_absolute)
  4. {
  5.     struct event_base *base = ev->ev_base;
  6.     int res = 0;
  7.     int notify = 0;
  9.     ...
  10.     /*
  11.      * 新的timer事件，调用timer heap接口在堆上预留一个位置
  12. 　　 *向系统I/O机制注册可能会失败，而当在堆上预留成功后，
  13.     * 定时事件的添加将肯定不会失败；
  15.     */
  16.     if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
  17.         if (min_heap_reserve(&base->timeheap,
  18.             1 + min_heap_size(&base->timeheap)) == -1)
  19.             return (-1);  /* ENOMEM == errno */
  20.     }
  22.     //根据不同的事件（IO，信号，超时事件等将fd放入不同的map
  23.     if ((ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL)) &&
  24.         !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE))) {
  25.         if (ev->ev_events & (EV_READ|EV_WRITE))
  26.             res = evmap_io_add(base, ev->ev_fd, ev);
  27.         else if (ev->ev_events & EV_SIGNAL)
  28.             res = evmap_signal_add(base, (int)ev->ev_fd, ev);
  29.         if (res != -1)
  30.            //将event放入事件队列
  31.             event_queue_insert(base, ev, EVLIST_INSERTED);
  32.         if (res == 1) {
  33.             /* evmap says we need to notify the main thread. */
  34.             notify = 1;
  35.             res = 0;
  36.         }
  37.     }
  39.     /*
  40.          EVLIST_TIMEOUT表明event已经在定时器堆中了，删除旧的
  41.          */
  42.         if (ev->ev_flags & EVLIST_TIMEOUT) {
  43.             /* XXX I believe this is needless. */
  44.             if (min_heap_elt_is_top(ev))
  45.                 notify = 1;
  46.             event_queue_remove(base, ev, EVLIST_TIMEOUT);
  47.         }
  49.         /* // 如果事件已经是就绪状态则从激活链表中删除 */
  50.         if ((ev->ev_flags & EVLIST_ACTIVE) &&
  51.             (ev->ev_res & EV_TIMEOUT)) {
  52.             if (ev->ev_events & EV_SIGNAL) {
  53.                 /* See if we are just active executing
  54.                  * this event in a loop
  55.                  */
  56.                 if (ev->ev_ncalls && ev->ev_pncalls) {
  57.                     /* Abort loop */
  58.                     *ev->ev_pncalls = 0;
  59.                 }
  60.             }
  62.             event_queue_remove(base, ev, EVLIST_ACTIVE);
  63.         }
  65.         gettime(base, &now);
  67.        ...       // 计算时间，并插入到timer小根堆中
  68.         event_queue_insert(base, ev, EVLIST_TIMEOUT);
  69.         return (res);
  70. }

在evmap_io_add里完成了io事件对于不同网络模型(select/epoll等)的绑定

  1. int
  2. evmap_io_add(struct event_base *base, evutil_socket_t fd, struct event *ev)
  3. {
  4.      ...
  5.      const struct eventop *evsel = base->evsel;
  6.      struct event_io_map *io = &base->io;
  7.      ...
  8.      //将event的fd和类型注册到不同的网络模型
  9.      if (evsel->add(base, ev->ev_fd,
  10.             old, (ev->ev_events & EV_ET) | res, extra) == -1)
  11.             return (-1);
  12.      ...
  14. }

event_queue_insert()负责将事件插入到对应的链表中；
event_queue_remove()负责将事件从对应的链表中删除；

  1. void event_queue_insert(struct event_base *base, struct event *ev,
  2. int queue)
  3. {
  4.     // ev可能已经在激活列表中了，避免重复插入
  5.     if (ev->ev_flags & queue) {
  6.     if (queue & EVLIST_ACTIVE)
  7.     return;
  8.     }
  9.     // // 记录queue标记
  10.     ev->ev_flags |= queue;
  11.     switch (queue) {
  12.          // I/O或Signal事件，加入已注册事件链表
  13.         case EVLIST_INSERTED:
  14.         TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next);
  15.         break;
  16.         // 就绪事件，加入激活链表
  17.         case EVLIST_ACTIVE: 
  18.         base->event_count_active++;
  19.         TAILQ_INSERT_TAIL(base->activequeues[ev->ev_pri], ev,
  20.         ev_active_next);
  21.         break;
  22.         // 定时事件，加入堆
  23.         case EVLIST_TIMEOUT: 
  24.         min_heap_push(&base->timeheap, ev);
  25.         break;
  26.     }
  27. }

3删除事件

  1. int
  2. event_del(struct event *ev)
  3. {
  4.     int res;
  6.     if (EVUTIL_FAILURE_CHECK(!ev->ev_base)) {
  7.         event_warnx("%s: event has no event_base set.", __func__);
  8.         return -1;
  9.     }
  11.     EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
  13.     res = event_del_internal(ev);
  15.     EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
  17.     return (res);
  18. }

内部调用了

  1. static inline int
  2. event_del_internal(struct event *ev)
  3. {
  4.     struct event_base *base;
  5.     int res = 0, notify = 0;
  7.     event_debug(("event_del: %p (fd "EV_SOCK_FMT"), callback %p",
  8.         ev, EV_SOCK_ARG(ev->ev_fd), ev->ev_callback));
  10.     /* An event without a base has not been added */
  11.     if (ev->ev_base == NULL)
  12.         return (-1);
  15.     base = ev->ev_base;
  18.     EVUTIL_ASSERT(!(ev->ev_flags & ~EVLIST_ALL));
  19.     //根据不同flag从队列中移除
  20.     if (ev->ev_flags & EVLIST_TIMEOUT) {
  21.         /* NOTE: We never need to notify the main thread because of a
  22.          * deleted timeout event: all that could happen if we don't is
  23.          * that the dispatch loop might wake up too early.  But the
  24.          * point of notifying the main thread _is_ to wake up the
  25.          * dispatch loop early anyway, so we wouldn't gain anything by
  26.          * doing it.
  27.          */
  28.         event_queue_remove(base, ev, EVLIST_TIMEOUT);
  29.     }
  31.     if (ev->ev_flags & EVLIST_ACTIVE)
  32.         event_queue_remove(base, ev, EVLIST_ACTIVE);
  34.     if (ev->ev_flags & EVLIST_INSERTED) {
  35.         event_queue_remove(base, ev, EVLIST_INSERTED);
  36.         if (ev->ev_events & (EV_READ|EV_WRITE))
  37.            //io事件从map中移除
  38.             res = evmap_io_del(base, ev->ev_fd, ev);
  39.         else
  40.             res = evmap_signal_del(base, (int)ev->ev_fd, ev);
  41.         if (res == 1) {
  42.             /* evmap says we need to notify the main thread. */
  43.             notify = 1;
  44.             res = 0;
  45.         }
  46.     }return (res);
  47. }

evmap_io_del 中完成了不同模型del函数调用

  1. int
  2. evmap_io_del(struct event_base *base, evutil_socket_t fd, struct event *ev)
  3. {
  5.     if (evsel->del(base, ev->ev_fd, old, res, extra) == -1)
  6.             return (-1);
  8. }

4 事件派发

  1. int
  2. event_base_loop(struct event_base *base, int flags)
  4. {
  5.     const struct eventop *evsel = base->evsel;
  6.     struct timeval tv;
  7.     struct timeval *tv_p;
  8.     int res, done, retval = 0;
  10.    while (!done) {
  11.         base->event_continue = 0;
  13.         /* Terminate the loop if we have been asked to */
  15. 　　　　//设置了event_gotterm或者event_break都会导致break
  16.         if (base->event_gotterm) {
  17.             break;
  18.         }
  20.         if (base->event_break) {
  21.             break;
  22.         }
  23.         //校正系统时间
  24.         timeout_correct(base, &tv);
  25.         // 根据timer heap中事件的最小超时时间，计算系统I/O demultiplexer
  26.          //的最大等待时间
  27.         tv_p = &tv;
  28.         if (!N_ACTIVE_CALLBACKS(base) && !(flags & EVLOOP_NONBLOCK)) {
  29.             timeout_next(base, &tv_p);
  30.         } else {
  31.             /*
  32.              * 如果有激活的事件，我们立即处理，不用等待
  33.              */
  34.             evutil_timerclear(&tv);
  35.         }
  37.         /* If we have no events, we just exit */
  38.         if (!event_haveevents(base) && !N_ACTIVE_CALLBACKS(base)) {
  39.             event_debug(("%s: no events registered.", __func__));
  40.             retval = 1;
  41.             goto done;
  42.         }
  44.         /* update last old time */
  45.         gettime(base, &base->event_tv);
  47.         clear_time_cache(base);
  48.         //完成事件的派发，将就绪的事件放倒active列表里
  49.         res = evsel->dispatch(base, tv_p);
  51.         if (res == -1) {
  52.             event_debug(("%s: dispatch returned unsuccessfully.",
  53.                 __func__));
  54.             retval = -1;
  55.             goto done;
  56.         }
  58.         update_time_cache(base);
  60.         timeout_process(base);
  61. 　　　　// 调用event_process_active()处理激活链表中的就绪event，调用其
  62.        //回调函数执行事件处理
  63.       // 该函数会寻找最高优先级（priority值越小优先级越高）的激活事件
  64.       //链表，
  65.       // 然后处理链表中的所有就绪事件；
  66.       // 因此低优先级的就绪事件可能得不到及时处理；
  67.         if (N_ACTIVE_CALLBACKS(base)) {
  68.             int n = event_process_active(base);
  69.             if ((flags & EVLOOP_ONCE)
  70.                 && N_ACTIVE_CALLBACKS(base) == 0
  71.                 && n != 0)
  72.                 done = 1;
  73.         } else if (flags & EVLOOP_NONBLOCK)
  74.             done = 1;
  75.     }
  76.     event_debug(("%s: asked to terminate loop.", __func__));
  78. done:
  79.     clear_time_cache(base);
  80.     base->running_loop = 0;
  82.     EVBASE_RELEASE_LOCK(base, th_base_lock);
  84.     return (retval);
  85. }

调用evsel->dispatch后将事件放入active队列,然后process_active处理激活队列里的事件

  1. static int
  2. event_process_active(struct event_base *base)
  3. {
  4.     /* Caller must hold th_base_lock */
  5.     struct event_list *activeq = NULL;
  6.     int i, c = 0;
  8.     for (i = 0; i < base->nactivequeues; ++i) {
  9.         if (TAILQ_FIRST(&base->activequeues[i]) != NULL) {
  10.             base->event_running_priority = i;
  11.             activeq = &base->activequeues[i];
  12.             c = event_process_active_single_queue(base, activeq);
  13.             if (c < 0) {
  14.                 base->event_running_priority = -1;
  15.                 return -1;
  16.             } else if (c > 0)
  17.                 break; /* Processed a real event; do not
  18.                     * consider lower-priority events */
  19.             /* If we get here, all of the events we processed
  20.              * were internal.  Continue. */
  21.         }
  22.     }
  24.     event_process_deferred_callbacks(&base->defer_queue,&base->event_break);
  25.     base->event_running_priority = -1;
  26.     return c;
  27. }

优先级数字base->nactivequeues 以下的会被先处理。到目前为止介绍了libevent库的基本api和流程。对于不同的网络模型libevent是如何封装的呢？

八libevent对于网络模型的封装(epoll为例)

epoll基本单元封装

  1. struct epollop {
  2.     struct epoll_event *events;
  3.     int nevents;
  4.     int epfd;
  5. };

epfd：epoll_create 返回的epoll表句柄

events: 表示epoll表监听的epoll_event 队列

nevents:epoll_event队列大小

在介绍epoll封装的一些接口前，先看以下两个结构体定义的对象

  1. static const struct eventop epollops_changelist = {
  2.     "epoll (with changelist)",
  3.     epoll_init,
  4.     event_changelist_add,
  5.     event_changelist_del,
  6.     epoll_dispatch,
  7.     epoll_dealloc,
  8.     1, /* need reinit */
  9.     EV_FEATURE_ET|EV_FEATURE_O1,
  10.     EVENT_CHANGELIST_FDINFO_SIZE
  11. };

结构体对象封装了epoll操作的函数指针，

event_changelist_add表示设置changlist标记位时将事件加入changelist

event_changelist_del表示如果设置了changelist标记位事件从changelist中移除。

  1. const struct eventop epollops = {
  2.     "epoll",
  3.     epoll_init,
  4.     epoll_nochangelist_add,
  5.     epoll_nochangelist_del,
  6.     epoll_dispatch,
  7.     epoll_dealloc,
  8.     1, /* need reinit */
  9.     EV_FEATURE_ET|EV_FEATURE_O1,
  10.     0
  11. };

这个结构体对象对应的是没设置changelist标记位时epoll的操作接口接下来看下epoll_init函数

  1. epoll_init(struct event_base *base)
  2. {
  3.     int epfd;
  4.     struct epollop *epollop;
  6.     /* Initialize the kernel queue.  (The size field is ignored since
  7.      * 2.6.8.) */
  8.     if ((epfd = epoll_create(32000)) == -1) {
  9.         if (errno != ENOSYS)
  10.             event_warn("epoll_create");
  11.         return (NULL);
  12.     }
  14.     evutil_make_socket_closeonexec(epfd);
  16.     if (!(epollop = mm_calloc(1, sizeof(struct epollop)))) {
  17.         close(epfd);
  18.         return (NULL);
  19.     }
  21.     epollop->epfd = epfd;
  23.     /* Initialize fields */
  24.     epollop->events = mm_calloc(INITIAL_NEVENT, sizeof(struct epoll_event));
  25.     if (epollop->events == NULL) {
  26.         mm_free(epollop);
  27.         close(epfd);
  28.         return (NULL);
  29.     }
  30.     epollop->nevents = INITIAL_NEVENT;
  31.     //如果设置了EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST
  32.     //添加和删除事件的回调函数变为changelist_add 和changelist_del
  34.     if ((base->flags & EVENT_BASE_FLAG_EPOLL_USE_CHANGELIST) != 0 ||
  35.         ((base->flags & EVENT_BASE_FLAG_IGNORE_ENV) == 0 &&
  36.         evutil_getenv("EVENT_EPOLL_USE_CHANGELIST") != NULL))
  37.         base->evsel = &epollops_changelist;
  39.     evsig_init(base);
  41.     return (epollop);
  42. }

接下来看下epoll封装的事件注册接口，只看epoll_nochangelist_add，epoll_changelist_add都是类似的。

  1. static int
  2. epoll_nochangelist_add(struct event_base *base, evutil_socket_t fd,
  3.     short old, short events, void *p)
  4. {
  5.     struct event_change ch;
  6.     ch.fd = fd;
  7.     ch.old_events = old;
  8.     ch.read_change = ch.write_change = 0;
  9.     if (events & EV_WRITE)
  10.         ch.write_change = EV_CHANGE_ADD |
  11.             (events & EV_ET);
  12.     if (events & EV_READ)
  13.         ch.read_change = EV_CHANGE_ADD |
  14.             (events & EV_ET);
  16.     return epoll_apply_one_change(base, base->evbase, &ch);
  17. }

在epoll_apply_one_change中完成事件添加

  1. static int
  2. epoll_apply_one_change(struct event_base *base,
  3.     struct epollop *epollop,
  4.     const struct event_change *ch)
  5. {
  6.     struct epoll_event epev;
  7.     int op, events = 0;
  9.     if (1) {
  11.         if ((ch->read_change & EV_CHANGE_ADD) ||
  12.             (ch->write_change & EV_CHANGE_ADD)) {
  14.             events = 0;
  15.             op = EPOLL_CTL_ADD;
  16.              //关注读事件
  17.             if (ch->read_change & EV_CHANGE_ADD) {
  18.                 events |= EPOLLIN;
  19.             } else if (ch->read_change & EV_CHANGE_DEL) {
  20.                 ;
  21.             } else if (ch->old_events & EV_READ) {
  22.                 events |= EPOLLIN;
  23.             }
  24.             //关注写事件
  25.             if (ch->write_change & EV_CHANGE_ADD) {
  26.                 events |= EPOLLOUT;
  27.             } else if (ch->write_change & EV_CHANGE_DEL) {
  28.                 ;
  29.             } else if (ch->old_events & EV_WRITE) {
  30.                 events |= EPOLLOUT;
  31.             }
  32.             //设置et模型
  33.             if ((ch->read_change|ch->write_change) & EV_ET)
  34.                 events |= EPOLLET;
  35.             //之前有事件关注，将操作改为EPOLL_CTL_MOD
  36.             if (ch->old_events) {
  38.                 op = EPOLL_CTL_MOD;
  39.             }
  40.         } else if ((ch->read_change & EV_CHANGE_DEL) ||
  41.             (ch->write_change & EV_CHANGE_DEL)) {
  43.             op = EPOLL_CTL_DEL;
  44.             //之前关注过删除该事件
  45.             if (ch->read_change & EV_CHANGE_DEL) {
  46.                 if (ch->write_change & EV_CHANGE_DEL) {
  47.                    //读写事件都设置删除标记
  48.                     events = EPOLLIN|EPOLLOUT;
  49.                 } else if (ch->old_events & EV_WRITE) {
  50.                     events = EPOLLOUT;
  51.                     //只有写事件要求删除，那么更改为读事件
  52.                     op = EPOLL_CTL_MOD;
  53.                 } else {
  54.                     //只删除读事件
  55.                     events = EPOLLIN;
  56.                 }
  57.             } else if (ch->write_change & EV_CHANGE_DEL) {
  58.                 if (ch->old_events & EV_READ) {
  59.                     events = EPOLLIN;
  60.                     //更改为关注读事件
  61.                     op = EPOLL_CTL_MOD;
  62.                 } else {
  63.                    //只删除写事件
  64.                     events = EPOLLOUT;
  65.                 }
  66.             }
  67.         }
  69.         if (!events)
  70.             return 0;
  72.         memset(&epev, 0, sizeof(epev));
  73.         epev.data.fd = ch->fd;
  74.         epev.events = events;
  75.         //调用epoll_ctl设置event进入epoll监听队列
  76.         if (epoll_ctl(epollop->epfd, op, ch->fd, &epev) == -1) {
  77.             if (op == EPOLL_CTL_MOD && errno == ENOENT) {
  79.                 if (epoll_ctl(epollop->epfd, EPOLL_CTL_ADD, ch->fd, &epev) == -1) {
  80.                     event_warn("Epoll MOD(%d) on %d retried as ADD; that failed too",
  81.                         (int)epev.events, ch->fd);
  82.                     return -1;
  83.                 } else {
  84.                     event_debug(("Epoll MOD(%d) on %d retried as ADD; succeeded.",
  85.                         (int)epev.events,
  86.                         ch->fd));
  87.                 }
  88.             } else if (op == EPOLL_CTL_ADD && errno == EEXIST) {
  90.                 if (epoll_ctl(epollop->epfd, EPOLL_CTL_MOD, ch->fd, &epev) == -1) {
  91.                     event_warn("Epoll ADD(%d) on %d retried as MOD; that failed too",
  92.                         (int)epev.events, ch->fd);
  93.                     return -1;
  94.                 } else {
  95.                     event_debug(("Epoll ADD(%d) on %d retried as MOD; succeeded.",
  96.                         (int)epev.events,
  97.                         ch->fd));
  98.                 }
  99.             } else if (op == EPOLL_CTL_DEL &&
  100.                 (errno == ENOENT || errno == EBADF ||
  101.                 errno == EPERM)) {
  103.                 event_debug(("Epoll DEL(%d) on fd %d gave %s: DEL was unnecessary.",
  104.                     (int)epev.events,
  105.                     ch->fd,
  106.                     strerror(errno)));
  107.             } else {
  108.                 event_warn("Epoll %s(%d) on fd %d failed.  Old events were %d; read change was %d (%s); write change was %d (%s)",
  109.                     epoll_op_to_string(op),
  110.                     (int)epev.events,
  111.                     ch->fd,
  112.                     ch->old_events,
  113.                     ch->read_change,
  114.                     change_to_string(ch->read_change),
  115.                     ch->write_change,
  116.                     change_to_string(ch->write_change));
  117.                 return -1;
  118.             }
  119.         } else {
  120.             event_debug(("Epoll %s(%d) on fd %d okay. [old events were %d; read change was %d; write change was %d]",
  121.                 epoll_op_to_string(op),
  122.                 (int)epev.events,
  123.                 (int)ch->fd,
  124.                 ch->old_events,
  125.                 ch->read_change,
  126.                 ch->write_change));
  127.         }
  128.     }
  129.     return 0;
  130. }

删除事件也是类似的，内部调用epoll_apply_onechange知识将事件标记位EV_CHANGE_DEL,到函数内部解析为epoll_del或者epoll_mod

  1. static int
  2. epoll_nochangelist_del(struct event_base *base, evutil_socket_t fd,
  3.     short old, short events, void *p)
  4. {
  5.     struct event_change ch;
  6.     ch.fd = fd;
  7.     ch.old_events = old;
  8.     ch.read_change = ch.write_change = 0;
  9.     if (events & EV_WRITE)
  10.         ch.write_change = EV_CHANGE_DEL;
  11.     if (events & EV_READ)
  12.         ch.read_change = EV_CHANGE_DEL;
  14.     return epoll_apply_one_change(base, base->evbase, &ch);
  15. }

最后是事件派发

  1. static int
  2. epoll_dispatch(struct event_base *base, struct timeval *tv)
  3. {
  4.     struct epollop *epollop = base->evbase;
  5.     struct epoll_event *events = epollop->events;
  6.     int i, res;
  7.     long timeout = -1;
  9.     if (tv != NULL) {
  10.         timeout = evutil_tv_to_msec(tv);
  11.         if (timeout < 0 || timeout > MAX_EPOLL_TIMEOUT_MSEC) {
  12.             /* Linux kernels can wait forever if the timeout is
  13.              * too big; see comment on MAX_EPOLL_TIMEOUT_MSEC. */
  14.             timeout = MAX_EPOLL_TIMEOUT_MSEC;
  15.         }
  16.     }
  18.     //处理changelis列表的所有事件
  19.     epoll_apply_changes(base);
  20.     event_changelist_remove_all(&base->changelist, base);
  22.     EVBASE_RELEASE_LOCK(base, th_base_lock);
  24.     //处理epoll_wait返回就绪描述符个数
  25.     res = epoll_wait(epollop->epfd, events, epollop->nevents, timeout);
  27.     EVBASE_ACQUIRE_LOCK(base, th_base_lock);
  29.     if (res == -1) {
  30.         if (errno != EINTR) {
  31.             event_warn("epoll_wait");
  32.             return (-1);
  33.         }
  35.         return (0);
  36.     }
  38.     event_debug(("%s: epoll_wait reports %d", __func__, res));
  39.     EVUTIL_ASSERT(res <= epollop->nevents);
  41.     for (i = 0; i < res; i++) {
  42.         int what = events[i].events;
  43.         short ev = 0;
  45.         if (what & (EPOLLHUP|EPOLLERR)) {
  46.             ev = EV_READ | EV_WRITE;
  47.         } else {
  48.             if (what & EPOLLIN)
  49.                 ev |= EV_READ;
  50.             if (what & EPOLLOUT)
  51.                 ev |= EV_WRITE;
  52.         }
  54.         if (!ev)
  55.             continue;
  56.         //将event放入active队列中
  57.         evmap_io_active(base, events[i].data.fd, ev | EV_ET);
  58.     }
  60.     //epoll就绪数量等于队列长度，额外开辟空间确保新的事件可以触发
  61.     if (res == epollop->nevents && epollop->nevents < MAX_NEVENT) {
  62.         /* We used all of the event space this time.  We should
  63.            be ready for more events next time. */
  64.         int new_nevents = epollop->nevents * 2;
  65.         struct epoll_event *new_events;
  67.         new_events = mm_realloc(epollop->events,
  68.             new_nevents * sizeof(struct epoll_event));
  69.         if (new_events) {
  70.             epollop->events = new_events;
  71.             epollop->nevents = new_nevents;
  72.         }
  73.     }
  75.     return (0);
  76. }

以上就是livevent对于epoll的基本封装。整个结构体对象epollops在event.c中被赋值给eventops[]的

  1. static const struct eventop *eventops[] = {
  2. #ifdef _EVENT_HAVE_EVENT_PORTS
  3.     &evportops,
  4. #endif
  5. #ifdef _EVENT_HAVE_WORKING_KQUEUE
  6.     &kqops,
  7. #endif
  8. #ifdef _EVENT_HAVE_EPOLL
  9.     &epollops,
  10. #endif
  11. #ifdef _EVENT_HAVE_DEVPOLL
  12.     &devpollops,
  13. #endif
  14. #ifdef _EVENT_HAVE_POLL
  15.     &pollops,
  16. #endif
  17. #ifdef _EVENT_HAVE_SELECT
  18.     &selectops,
  19. #endif
  20. #ifdef WIN32
  21.     &win32ops,
  22. #endif
  23.     NULL
  24. };

之后在event_base_new_with_config中调用base->evsel = eventops[i];完成不同模型的结构体对象赋值给base的evsel指针的。

目前对于libevent的分析和理解先告一段落，以后会更新对libevent的更深刻认识。

热门评论
点击查看更多评论 没有更多评论了,点击收起 展开评论

热门文章

  1. vscode搭建windows C++开发环境
    喜欢(596) 浏览(84498)

  2. 聊天项目(28) 分布式服务通知好友申请
    喜欢(507) 浏览(6142)

  3. 使用hexo搭建个人博客
    喜欢(533) 浏览(12038)

  4. Linux环境搭建和编码
    喜欢(594) 浏览(13708)

  5. Qt环境搭建
    喜欢(517) 浏览(25036)

最新评论

  1. visual studio配置boost库 一giao里我离giaogiao:请问是修改成这样吗：.\b2.exe toolset=MinGW
  2. Qt MVC结构之QItemDelegate介绍 胡歌-此生不换:gpt, google
  3. 利用栅栏实现同步 Dzher:作者你好！我觉得 std::thread a(write_x); std::thread b(write_y); std::thread c(read_x_then_y); std::thread d(read_y_then_x); 这个例子中的assert fail并不会发生，原子变量设定了非relaxed内存序后一个线程的原子变量被写入，那么之后的读取一定会被同步的，c和d线程中只可能同时发生一个z++未执行的情况，最终z不是1就是2了，我测试了很多次都没有assert，请问我这个观点有什么错误，谢谢！
  4. slice介绍和使用 恋恋风辰:切片作为引用类型极大的提高了数据传递的效率和性能，但也要注意切片的浅拷贝隐患，算是一把双刃剑，这世间的常态就是在两极之间寻求一种稳定。
  5. interface应用 secondtonone1:interface是万能类型，但是使用时要转换为实际类型来使用。interface丰富了go的多态特性，也降低了传统面向对象语言的耦合性。
  6. 答疑汇总(thread,async源码分析) Yagus:如果引用计数为0，则会执行 future 的析构进而等待任务执行完成，那么看到的输出将是 这边应该不对吧，std::future析构只在这三种情况都满足的时候才回block: 1.共享状态是std::async 创造的(类型是_Task_async_state) 2.共享状态没有ready 3.这个future是共享状态的最后一个引用 这边共享状态类型是“_Package_state”，引用计数即使为0也不应该block啊
  7. Qt 对话框 Spade2077:QDialog w(); //这里是不是不需要带括号
  8. 利用C11模拟伪闭包实现连接的安全回收 搁浅:看chatgpt说 直接传递 shared_from_this() 更安全 提问： socket_.async_read_some(boost::asio::buffer(data_, BUFFSIZE), // 接收客户端发生来的数据 std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2, shared_from_this())); socket_.async_read_some(boost::asio::buffer(data_, BUFFSIZE), std::bind(&Session::handle_read, shared_from_this(), std::placeholders::_1, std::placeholders::_2)); 这两种方式有区别吗？ 回答 ： 第一种方式：this 是裸指针，可能会导致生命周期问题，虽然 shared_from_this() 提供了一定的保护，但 this 依然存在风险。 第二种方式：完全使用 shared_ptr 来管理生命周期，更加安全。 通常，第二种方式更推荐使用，因为它可以确保在异步操作完成之前，Session 对象的生命周期得到完全管理，避免使用裸指针的潜在风险。
  9. 构造函数 secondtonone1:构造函数是类的基础知识，要着重掌握
  10. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理，无论工作也好生活也罢，最重要的是开心，即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃，所以我还是想去做喜欢的方向。
  11. C++ 线程安全的单例模式演变 183******95:单例模式的析构函数何时运行呢? 实际测试里：无论单例模式的析构函数为私有或公有，使用智能指针和辅助回收类，两种方法都无法在main()结束前调用单例的析构函数。
  12. 可变参数模板+异步队列实现异步打印功能 熊二:学到了%%%
  13. boost::asio之socket的创建和连接 项空月:发现一些错别字 :每隔vector存储  是不是是每个. asio::mutable_buffers_1 o或者    是不是多打了个o
  14. 网络编程学习方法和图书推荐 Corleone:啥程度可以找工作
  15. 处理网络粘包问题 zyouth: //消息的长度小于头部规定的长度，说明数据未收全，则先将部分消息放到接收节点里 if (bytes_transferred < data_len) { memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred); _recv_msg_node->_cur_len += bytes_transferred; ::memset(_data, 0, MAX_LENGTH); _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self)); //头部处理完成 _b_head_parse = true; return; } 把_b_head_parse = true;放在_socket.async_read_some前面是不是更好
  16. 聊天项目(9) redis服务搭建 pro_lin:redis线程池的析构函数，除了pop出队列，还要free掉redis连接把
  17. 面试题汇总(一) secondtonone1:看到网络上经常提问的go的问题，做了一下汇总，结合自己的经验给出的答案，如有纰漏，望指正批评。
  18. 无锁并发队列 TenThousandOne:_head  和 _tail  替换为原子变量。那里pop的逻辑，val = _data[h] 可以移到循环外面吗
  19. string类 WangQi888888:确实错了，应该是！isspace(sind[index]). 否则不进入循环，还是原来的字符串“some string”
  20. 再谈单例模式 secondtonone1:是的，C++11以后返回局部static变量对象能保证线程安全了。
  21. 聊天项目(7) visualstudio配置grpc diablorrr:cmake文件得改一下 find_package(Boost REQUIRED COMPONENTS system filesystem)，要加上filesystem。在target_link_libraries中也同样加上
  22. 聊天项目(15) 客户端实现TCP管理者 lkx:已经在&QTcpSocket::readyRead 回调函数中做了处理了的。
  23. 聊天项目(13) 重置密码功能 Doraemon:万一一个用户多个邮箱呢 有可能的
  24. 创建项目和编译 secondtonone1:谢谢支持
  25. 类和对象 陈宇航:支持！！！！
  26. C++ 并发三剑客future, promise和async Yunfei:大佬您好，如果这个线程池中加入的异步任务的形参如果有右值引用，这个commit中的返回类型推导和bind绑定就会出现问题，请问实际工程中，是不是不会用到这种任务，如果用到了，应该怎么解决？
  27. 堆排序 secondtonone1:堆排序非常实用，定时器就是这个原理制作的。
  28. protobuf配置和使用 熊二:你可以把dll放到系统目录，也可以配置环境变量，还能把dll丢到lib里
  29. 基于锁实现线程安全队列和栈容器 secondtonone1:我是博主，你认真学习的样子的很可爱，哈哈，我画的是链表由空变成1个的情况。其余情况和你思考的类似，只不过我用了一个无效节点表示tail的指向，最初head和tail指向的都是这个节点。

其他链接

  1. GitHub
  2. 个人博客
  3. 博客园
  4. CSDN

个人公众号

个人微信