1
struct event_base {
2
    const struct eventop *evsel;    // I/O复用机制（epoll/select等）
3
    void *evbase;                   // I/O复用机制的数据
4

5
    struct event_io_map io;         // fd到event的映射
6
    struct event_signal_map sigmap; // 信号到event的映射
7

8
    struct min_heap timeheap;       // 定时器小根堆
9

10
    struct evcallback_list *activequeues;  // 活跃事件队列
11
    int nactivequeues;              // 活跃队列数量
12

13
    int event_count;                // 事件总数
14
    int event_count_active;         // 活跃事件数
15
    // ...
16
};

1
int event_add(struct event *ev, const struct timeval *tv) {
2
    struct event_base *base = ev->ev_base;
3

4
    // 1. 如果有超时，添加到定时器堆
5
    if (tv != NULL && !(ev->ev_flags & EVLIST_TIMEOUT)) {
6
        if (min_heap_reserve(&base->timeheap, 1) == -1)
7
            return -1;
8
        min_heap_push(&base->timeheap, ev);
9
    }
10

11
    // 2. 如果是I/O事件，添加到I/O映射
12
    if ((ev->ev_events & (EV_READ | EV_WRITE)) &&
13
        !(ev->ev_flags & (EVLIST_INSERTED | EVLIST_ACTIVE))) {
14

15
        // 调用底层I/O复用机制的add函数
16
        if (base->evsel->add(base, ev->ev_fd,
17
            old, ev->ev_events, ev->ev_.ev_io.ev_timeout) == -1)
18
            return -1;
19

20
        ev->ev_flags |= EVLIST_INSERTED;
21
    }
22

23
    return 0;
24
}

1
static int epoll_add(struct event_base *base, int fd,
2
                     short old, short events, void *p) {
3
    struct epoll *epollop = base->evbase;
4
    struct epoll_event epev;
5

6
    memset(&epev, 0, sizeof(epev));
7
    epev.data.fd = fd;
8

9
    if (events & EV_READ)
10
        epev.events |= EPOLLIN;
11
    if (events & EV_WRITE)
12
        epev.events |= EPOLLOUT;
13

14
    int op = old ? EPOLL_CTL_MOD : EPOLL_CTL_ADD;
15

16
    if (epoll_ctl(epollop->epfd, op, fd, &epev) == -1) {
17
        return -1;
18
    }
19

20
    return 0;
21
}

1
int event_base_loop(struct event_base *base, int flags) {
2
    while (!done) {
3
        // 1. 计算超时时间
4
        timeout = get_timeout(base);
5

6
        // 2. 调用I/O复用机制等待事件
7
        res = base->evsel->dispatch(base, timeout);
8

9
        // 3. 处理定时器事件
10
        process_timers(base);
11

12
        // 4. 处理活跃事件
13
        process_active_events(base);
14

15
        if (flags & EVLOOP_ONCE)
16
            break;
17
    }
18

19
    return 0;
20
}

1
static int epoll_dispatch(struct event_base *base, struct timeval *tv) {
2
    struct epoll *epollop = base->evbase;
3
    struct epoll_event events[32];
4
    int timeout = -1;
5

6
    // 计算超时时间（毫秒）
7
    if (tv != NULL) {
8
        timeout = tv->tv_sec * 1000 + tv->tv_usec / 1000;
9
    }
10

11
    // 调用epoll_wait
12
    int n = epoll_wait(epollop->epfd, events, 32, timeout);
13

14
    if (n > 0) {
15
        for (int i = 0; i < n; i++) {
16
            int fd = events[i].data.fd;
17
            short what = 0;
18

19
            if (events[i].events & EPOLLIN)
20
                what |= EV_READ;
21
            if (events[i].events & EPOLLOUT)
22
                what |= EV_WRITE;
23
            if (events[i].events & EPOLLERR)
24
                what |= EV_READ | EV_WRITE;
25

26
            // 将事件加入活跃队列
27
            event_active(evmap_io_get_event(base, fd), what, 1);
28
        }
29
    }
30

31
    return 0;
32
}

1
void event_active(struct event *ev, int what, short ncalls) {
2
    struct event_base *base = ev->ev_base;
3

4
    // 如果已经在活跃队列中，不重复添加
5
    if (ev->ev_flags & EVLIST_ACTIVE)
6
        return;
7

8
    // 设置活跃事件类型
9
    ev->ev_.ev_io.ev_res = what;
10

11
    // 加入活跃队列
12
    ev->ev_flags |= EVLIST_ACTIVE;
13
    TAILQ_INSERT_TAIL(&base->activequeues[ev->ev_pri],
14
                      ev->ev_.ev_io.ev_active_next);
15
}

1
static void process_active_events(struct event_base *base) {
2
    struct event *ev;
3

4
    // 按优先级处理活跃事件
5
    for (int i = 0; i < base->nactivequeues; i++) {
6
        while ((ev = TAILQ_FIRST(&base->activequeues[i])) != NULL) {
7
            // 从活跃队列移除
8
            TAILQ_REMOVE(&base->activequeues[i], ev, ev_.ev_io.ev_active_next);
9
            ev->ev_flags &= ~EVLIST_ACTIVE;
10

11
            // 执行回调
12
            if (ev->ev_events & EV_SIGNAL) {
13
                ev->ev_.ev_signal.ev_ncalls = ev->ev_.ev_signal.ev_pncalls;
14
                while (ev->ev_.ev_signal.ev_ncalls--) {
15
                    ev->ev_callback(ev->ev_fd, ev->ev_.ev_signal.ev_res, ev->ev_arg);
16
                }
17
            } else {
18
                ev->ev_callback(ev->ev_fd, ev->ev_.ev_io.ev_res, ev->ev_arg);
19
            }
20

21
            // 如果是持久事件，重新添加
22
            if (ev->ev_flags & EVLIST_INSERTED) {
23
                // 事件仍在插入状态，如果是EV_PERSIST，保持
24
            }
25
        }
26
    }
27
}