libhv学习笔记2：从hloop_test入手

从本文开始，由sample入手，逐渐理解libhv的源码。
如有理解错误，欢迎批评指正。

main()函数

int main() {
    // memcheck atexit
    HV_MEMCHECK;

    hloop_t* loop = hloop_new(0);

    // test idle and priority
    for (int i = HEVENT_LOWEST_PRIORITY; i <= HEVENT_HIGHEST_PRIORITY; ++i) {
        hidle_t* idle = hidle_add(loop, on_idle, 10);
        hevent_set_priority(idle, i);
    }

    // // test timer timeout
    for (int i = 1; i <= 10; ++i) {
        htimer_t* timer = htimer_add(loop, on_timer, i*1000, 3);
        hevent_set_userdata(timer, (void*)(intptr_t)i);
    }

    // // test timer period
    int minute = time(NULL)%3600/60;
    htimer_add_period(loop, cron_hourly, minute+1, -1, -1, -1, -1, INFINITE);

    // test network_logger
    htimer_add(loop, timer_write_log, 1000, INFINITE);
    logger_set_handler(hlog, mylogger);
    hlog_set_file("loop.log");
#ifndef _MSC_VER
    logger_enable_color(hlog, 1);
#endif
    nlog_listen(loop, DEFAULT_LOG_PORT);

    // test nonblock stdin
    printf("input 'quit' to quit loop\n");
    char buf[64];
    hread(loop, 0, buf, sizeof(buf), on_stdin);

   // test custom_events
    for (int i = 0; i < 10; ++i) {
        hevent_t ev;
        memset(&ev, 0, sizeof(ev));
        ev.event_type = (hevent_type_e)(HEVENT_TYPE_CUSTOM + i);
        ev.cb = on_custom_events;
        ev.userdata = (void*)(long)i;
        hloop_post_event(loop, &ev);
    }

    hloop_run(loop);
    hloop_free(&loop);
    return 0;
}

代码的结构和注释非常的清晰，其中包含了多个事件的类型：
1.空闲事件
2.定时器超时事件
3.周期性的超时事件
4.监听listen事件
5.键盘自定义事件
6.用户自定义事件

先看一下代码的开头。

hloop_t* loop = hloop_new(0);

这里创建并初始化了libhv的事件循环。看一下这里面具体做了什么。

hloop_t* hloop_new(int flags) {
    hloop_t* loop;
    HV_ALLOC_SIZEOF(loop);
    hloop_init(loop);
    loop->flags |= flags;
    return loop;
}

首先看一下这个flags的取值范围

#define HLOOP_FLAG_RUN_ONCE                     0x00000001 //事件循环体只执行一次
#define HLOOP_FLAG_AUTO_FREE                    0x00000002 //执行完自动释放资源
#define HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS   0x00000004 //当没有事件时，退出事件循环

具体使用，我们后面再看。
接下来看一下hloop_init具体做了什么

static void hloop_init(hloop_t* loop) {
#ifdef OS_WIN
    static int s_wsa_initialized = 0;
    if (s_wsa_initialized == 0) {
        s_wsa_initialized = 1;
        WSADATA wsadata;
        WSAStartup(MAKEWORD(2,2), &wsadata);
    }
#endif
#ifdef SIGPIPE
    // NOTE: if not ignore SIGPIPE, write twice when peer close will lead to exit process by SIGPIPE.
    signal(SIGPIPE, SIG_IGN);
#endif

    loop->status = HLOOP_STATUS_STOP;				//初始化状态为 停止状态
    loop->pid = hv_getpid();						//获取当前进程号
    loop->tid = hv_gettid();						//获取当前线程号

    // idles
    list_init(&loop->idles);						//初始化空闲事件的链表

    // timers
    heap_init(&loop->timers, timers_compare);		//初始化超时事件的堆

    // ios
    io_array_init(&loop->ios, IO_ARRAY_INIT_SIZE);	//初始化IO事件的数组

    // readbuf
    loop->readbuf.len = HLOOP_READ_BUFSIZE;			//分配读缓冲区内存
    HV_ALLOC(loop->readbuf.base, loop->readbuf.len);

    // iowatcher
    iowatcher_init(loop);							//初始化IO监控

    // custom_events
    hmutex_init(&loop->custom_events_mutex);
    event_queue_init(&loop->custom_events, CUSTOM_EVENT_QUEUE_INIT_SIZE);
    loop->sockpair[0] = loop->sockpair[1] = -1;    //创建一对连接的socket
    if (Socketpair(AF_INET, SOCK_STREAM, 0, loop->sockpair) != 0) {
        hloge("socketpair create failed!");
    }

    // NOTE: init start_time here, because htimer_add use it.
    loop->start_ms = gettimeofday_ms();				//获取当前事件ms
    loop->start_hrtime = loop->cur_hrtime = gethrtime_us(); //获取当前事件us
}

从代码上看，hloop_init针对loop做了一系列初始化工作，所以不得不去看一下hloop_t的定义。

typedef struct hloop_s      hloop_t;

struct hloop_s {
    uint32_t    flags;									//标记
    hloop_status_e status;								//状态
    uint64_t    start_ms;       // ms
    uint64_t    start_hrtime;   // us
    uint64_t    end_hrtime;								//结束的时间
    uint64_t    cur_hrtime;								//当前时间
    uint64_t    loop_cnt;								//循环的次数
    long        pid;									//进程号
    long        tid;									//线程号
    void*       userdata;								//用户数据
//private:
    // events
    uint32_t                    nactives;				//活动的事件的数量
    uint32_t                    npendings;				//将要被处理的事件的数量
    // pendings: with priority as array.index
    hevent_t*                   pendings[HEVENT_PRIORITY_SIZE];		//将要被处理的事件的数组
    // idles													    //数组的长度为HEVENT_PRIORITY_SIZE(10)个
    																//这里按事件的优先级，放入到不同链表中，执行时，由高到低执行
    struct list_head            idles;								//空闲事件链表
    uint32_t                    nidles;								//空闲事件的数量
    // timers
    struct heap                 timers;								//超时事件堆
    uint32_t                    ntimers;							//超时事件的数量
    // ios: with fd as array.index
    struct io_array             ios;								//IO事件数组
    uint32_t                    nios;								//IO事件数量
    // one loop per thread, so one readbuf per loop is OK.
    hbuf_t                      readbuf;							//读缓冲区，这里作者有解释：因为一个线程只有一个事件循环，所有只要分配一个读缓冲区就可以了
    void*                       iowatcher;							//io监视器
    // custom_events
    int                         sockpair[2];						//本地成对连接的socket
    event_queue                 custom_events;						//用户自定义事件队列
    hmutex_t                    custom_events_mutex;				//用户事件锁
};

从上面代码里可以看出来，建立本地连接的socket是为了执行用户自定义事件，这里比较有意思，我们后面具体再看如何使用的。

下面继续看sample，hloop_test.c代码

// test idle and priority
    for (int i = HEVENT_LOWEST_PRIORITY; i <= HEVENT_HIGHEST_PRIORITY; ++i) {
        hidle_t* idle = hidle_add(loop, on_idle, 10);
        hevent_set_priority(idle, i);
    }

    // // test timer timeout
    for (int i = 1; i <= 10; ++i) {
        htimer_t* timer = htimer_add(loop, on_timer, i*1000, 3);
        hevent_set_userdata(timer, (void*)(intptr_t)i);
    }

    // // test timer period
    int minute = time(NULL)%3600/60;
    htimer_add_period(loop, cron_hourly, minute+1, -1, -1, -1, -1, INFINITE);
  // test nonblock stdin
    printf("input 'quit' to quit loop\n");
    char buf[64];
    hread(loop, 0, buf, sizeof(buf), on_stdin);

   // test custom_events
    for (int i = 0; i < 10; ++i) {
        hevent_t ev;
        memset(&ev, 0, sizeof(ev));
        ev.event_type = (hevent_type_e)(HEVENT_TYPE_CUSTOM + i);
        ev.cb = on_custom_events;
        ev.userdata = (void*)(long)i;
        hloop_post_event(loop, &ev);
    }

上面是注册各种事件，先看最简单的空闲事件

hidle_t* hidle_add(hloop_t* loop, hidle_cb cb, uint32_t repeat) {
    hidle_t* idle;
    HV_ALLOC_SIZEOF(idle);
    idle->event_type = HEVENT_TYPE_IDLE;
    idle->priority = HEVENT_LOWEST_PRIORITY;
    idle->repeat = repeat;
    list_add(&idle->node, &loop->idles);						//将空间事件加入到空闲事件链表中
    EVENT_ADD(loop, idle, cb);
    loop->nidles++;
    return idle;
}

我们可以看到，上面代码将空闲事件加入到了loop的空闲列表中。（其他内容先不深究）

超时事件

htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout, uint32_t repeat) {
    if (timeout == 0)   return NULL;
    htimeout_t* timer;
    HV_ALLOC_SIZEOF(timer);
    timer->event_type = HEVENT_TYPE_TIMEOUT;
    timer->priority = HEVENT_HIGHEST_PRIORITY;
    timer->repeat = repeat;
    timer->timeout = timeout;
    hloop_update_time(loop);
    timer->next_timeout = hloop_now_hrtime(loop) + timeout*1000;
    heap_insert(&loop->timers, &timer->node);			//超时事件加入堆
    EVENT_ADD(loop, timer, cb);
    loop->ntimers++;
    return (htimer_t*)timer;
}

同样，将超时事件加入loop的堆中

htimer_t* htimer_add_period(hloop_t* loop, htimer_cb cb,
                int8_t minute,  int8_t hour, int8_t day,
                int8_t week, int8_t month, uint32_t repeat) {
    if (minute > 59 || hour > 23 || day > 31 || week > 6 || month > 12) {
        return NULL;
    }
    hperiod_t* timer;
    HV_ALLOC_SIZEOF(timer);
    timer->event_type = HEVENT_TYPE_PERIOD;
    timer->priority = HEVENT_HIGH_PRIORITY;
    timer->repeat = repeat;
    timer->minute = minute;
    timer->hour   = hour;
    timer->day    = day;
    timer->month  = month;
    timer->week   = week;
    timer->next_timeout = (uint64_t)cron_next_timeout(minute, hour, day, week, month) * 1000000;//将周期时间转为下一次的超时时间
    heap_insert(&loop->timers, &timer->node);
    EVENT_ADD(loop, timer, cb);
    loop->ntimers++;
    return (htimer_t*)timer;
}

listen监听事件

hio_t* nlog_listen(hloop_t* loop, int port) {
    s_logger.loop = loop;
   //这里实例化了一个servet的socket，并把其listen事件加入到IO事件数组中，当有客户端连接时，调用on_accept回调函数
    s_logger.listenio = hloop_create_tcp_server(loop, "0.0.0.0", port, on_accept);
   
    list_init(&s_logger.clients);
    hmutex_init(&s_mutex);
    return s_logger.listenio;
}

键盘事件

hio_t* hread(hloop_t* loop, int fd, void* buf, size_t len, hread_cb read_cb) {
    hio_t* io = hio_get(loop, fd);
    assert(io != NULL);
    io->readbuf.base = (char*)buf;
    io->readbuf.len = len;
    if (read_cb) {
        io->read_cb = read_cb;
    }
    hio_read(io);
    return io;
}

其实就是一个io事件，后面再具体分析
下面是用户自定义事件

    for (int i = 0; i < 10; ++i) {
        hevent_t ev;
        memset(&ev, 0, sizeof(ev));
        //定义用户类型，从HEVENT_TYPE_CUSTOM 开始往上定义
        ev.event_type = (hevent_type_e)(HEVENT_TYPE_CUSTOM + i);
        ev.cb = on_custom_events;
        ev.userdata = (void*)(long)i;
        //发送用户事件
        hloop_post_event(loop, &ev);
    }

添加了这么多的事件，libhv是怎样执行的呢？
下面就是真正开始libhv事件循环的核心

int hloop_run(hloop_t* loop) {
    loop->pid = hv_getpid();
    loop->tid = hv_gettid();

    // intern events
    //这里，如果定义了本地相互连接的socket，那么就为读socket注册一个读事件，缓冲区为loop初始化时定义的缓冲区
    int intern_events = 0;
    if (loop->sockpair[0] != -1 && loop->sockpair[1] != -1) {
        hread(loop, loop->sockpair[SOCKPAIR_READ_INDEX], loop->readbuf.base, loop->readbuf.len, sockpair_read_cb);
        ++intern_events;
    }
#ifdef DEBUG
    htimer_add(loop, hloop_stat_timer_cb, HLOOP_STAT_TIMEOUT, INFINITE);
    ++intern_events;
#endif

    loop->status = HLOOP_STATUS_RUNNING;
    while (loop->status != HLOOP_STATUS_STOP) {				//检查loop的状态
        if (loop->status == HLOOP_STATUS_PAUSE) {
            msleep(HLOOP_PAUSE_TIME);						//如果是暂停状态，就休眠一段时间
            hloop_update_time(loop);
            continue;
        }
        ++loop->loop_cnt;
        //如果没有激活的事件，且loop的标志为HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS	就退出事件循环							
        if (loop->nactives <= intern_events && loop->flags & HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS) {
            break;
        }
        //核心：处理事件
        hloop_process_events(loop);
        //如果只执行一次的话，就退出事件循环
        if (loop->flags & HLOOP_FLAG_RUN_ONCE) {
            break;
        }
    }
    loop->status = HLOOP_STATUS_STOP;
    loop->end_hrtime = gethrtime_us();
	//退出事件循环时，清理释放loop的资源
    if (loop->flags & HLOOP_FLAG_AUTO_FREE) {
        hloop_cleanup(loop);
        HV_FREE(loop);
    }
    return 0;
}

在这里终于看到了loop的flags的作用

 if (loop->nactives <= intern_events && loop->flags & HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS) {
            break;
        }

if (loop->flags & HLOOP_FLAG_RUN_ONCE) {
            break;
        }

if (loop->flags & HLOOP_FLAG_AUTO_FREE) {
        hloop_cleanup(loop);
        HV_FREE(loop);
    }

最后，我们看一下libhv是如何处理事件的

// hloop_process_ios -> hloop_process_timers -> hloop_process_idles -> hloop_process_pendings
//作者注释，libhv处理事件的顺序是IO事件->超时事件->空闲事件 => 要执行的事件 
static int hloop_process_events(hloop_t* loop) {
    // ios -> timers -> idles
    int nios, ntimers, nidles;
    nios = ntimers = nidles = 0;

    // calc blocktime
    int32_t blocktime = HLOOP_MAX_BLOCK_TIME;
    if (loop->timers.root) {
        hloop_update_time(loop);
        //从超时事件堆中，找到最近要执行的超时事件
        uint64_t next_min_timeout = TIMER_ENTRY(loop->timers.root)->next_timeout;
        //计算与当前时间的时间差
        int64_t blocktime_us = next_min_timeout - hloop_now_hrtime(loop);
        //如果已经超时了，立马执行
        if (blocktime_us <= 0) goto process_timers;
        //计算可以阻塞的时间（ms）
        blocktime = blocktime_us / 1000;
        ++blocktime;
        blocktime = MIN(blocktime, HLOOP_MAX_BLOCK_TIME);
    }

    //检查是否有IO事件
    if (loop->nios) {
        nios = hloop_process_ios(loop, blocktime);
    }
    else {
        msleep(blocktime);
    }
    hloop_update_time(loop);
    // wakeup by hloop_stop
    if (loop->status == HLOOP_STATUS_STOP) {
        return 0;
    }

process_timers:
	//检查是否有超时事件
    if (loop->ntimers) {
        ntimers = hloop_process_timers(loop);
    }
    
	//查看有没有需要处理的事件，如果没有则查看有没有空间事件
    int npendings = loop->npendings;
    if (npendings == 0) {
        if (loop->nidles) {
            nidles= hloop_process_idles(loop);
        }
    }
    //执行需要处理的事件（需要处理的事件其实就是当前需要处理的IO事件，超时事件，空间事件）
    int ncbs = hloop_process_pendings(loop);
    // printd("blocktime=%d nios=%d/%u ntimers=%d/%u nidles=%d/%u nactives=%d npendings=%d ncbs=%d\n",
    //         blocktime, nios, loop->nios, ntimers, loop->ntimers, nidles, loop->nidles,
    //         loop->nactives, npendings, ncbs);
    return ncbs;
}

通过上面的源码理解分析，大致明白了libhv的事件循环的过程，总结一下流程就是：

下一次详细分析hloop_process_events函数中的内容