libev源代码分析--基本的接口函数

ibev的代码很简练 但对于看他代码的人 简直就是噩梦 到处都是宏 宏还嵌套 于是我在看libev代码时 对其进行了还原 去掉了宏

1 struct ev_io {
2 int fd;
3 int events;
4 struct ev_watcher_list *list;
5 int active;
6 int pending;
7 int priority;
8 void* data;
9 void (*cb)(structev_loop *loop, structev_io *w,int revents);
10 };

ev_io在触发EV_READ或者是EV_WRITE被调用

1 struct ev_timer {
2 ev_tstamp at;
3 ev_tstamp repeat;
4 int active;
5 int pending;
6 int priority;
7 void* data;
8 void (*cb)(structev_loop *loop, structev_timer *w,int revents);
9 };

ev_timer在特定的时间调用，并周期性进行，其基于单调时钟
(PS:单调时钟：此时间来源会严格的线性递增，一般linux会使用系统正常运行时间来表示，也就是从开机开始算起） 触发事件EV_TIMEOUT

1 struct ev_periodic {
2 ev_tstamp offset;
3 ev_tstamp interval;
4 ev_tstamp (*reschedule_cb)(structev_periodic *w, ev_tstamp now);
5 ev_tstamp at;
6 int active;
7 int pending;
8 int priority;
9 void* data;
10 void (*cb)(structev_loop *loop, structev_periodic *w,int revents);
11 };

ev_periodic在特定的时间调用，可能会在定期间隔反复调用，其基于UTC时间
（PS:UTC:协调时间 也就是从1970年1月1日00:00:00开始记时） 触发事件EV_PERIODIC

1 struct ev_signal {
2 int signum;
3 struct ev_watcher_list *next;
4 int active;
5 int pending;
6 int priority;
7 void* data;
8 void (*cb)(structev_loop *loop, structev_signal *w,int revents);
9 };

ev_signal当接收到指定的信号时调用 触发事件EV_SIGNAL

1 struct ev_child {
2 int flag;
3 int pid;
4 int rpid;
5 int rstatus;
6 struct ev_watcher_list *next;
7 int active;
8 int pending;
9 int priority;
10 void* data;
11 void (*cb)(structev_loop *loop, structev_child *w,int revents);
12 };

ev_child当接收到SIGCHLD信号并且waitpid表示了给出的pid时调用 触发EV_CHILD事件
其不支持优先级

1 struct ev_stat {
2 ev_timer timer;
3 ev_tstamp interval;
4 const char *path;
5 ev_statdata prev;
6 ev_statdata attr;
7 int wd;
8 struct ev_watcher_list *next;
9 int active;
10 int pending;
11 int priority;
12 void* data;
13 void (*cb)(structev_loop *loop, structev_stat *w,int revents);
14 };

ev_stat当每次指定的路径状态数据发生改变时调用 触发EV_STAT

1 struct ev_idle {
2 int active;
3 int pending;
4 int priority;
5 void* data;
6 void (*cb)(structev_loop *loop, structev_idle *w,int revents);
7 };

ev_idle当啥事情都不需要做的时候调用，用来保持进程远离阻塞 触发EV_IDLE

1 struct ev_prepare {
2 int active;
3 int pending;
4 int priority;
5 void* data;
6 void (*cb)(structev_loop *loop, structev_prepare *w,int revents);
7 };

ev_prepare每次执行mainloop主循环，在主循环之前调用 触发EV_PREPARE；

1 struct ev_check {
2 int active;
3 int pending;
4 int priority;
5 void* data;
6 void (*cb)(structev_loop *loop, structev_check *w,int revents);
7 };

ev_check每次执行mainloop主循环，在主循环之后调用 触发EV_CHECK

1 struct ev_fork {
2 int active;
3 int pending;
4 int priority;
5 void* data;
6 void (*cb)(structev_loop *loop,structev_fork *w,int revents);
7 };

ev_fok在fork行为被检测到，并且在检测子进程之前调用 触发EV_FORK;

1 struct ev_cleanup {
2 int active;
3 int pending;
4 int priority;
5 void* data;
6 void (*cb)(structev_loop *loop,structev_cheanup *w,int revents);
7 };

ev_cleanup在主循被销毁之后调用 触发EV_CLEANUP

1 struct ev_embed {
2 struct ev_loop* other;
3 ev_io io;
4 ev_prepare prepare;
5 ev_check check;
6 ev_timer timer;
7 ev_periodic periodic;
8 ev_idle idle;
9 ev_fork fork;
10 ev_cleanup cleanup;
11 };

ev_embed用于将一个事件循环嵌套到另一个中，当事件循环处理事件的时候被调用

1 struct ev_async {
2 sig_atomic_t volatile sent;
3 int active;
4 int pending;
5 int priority;
6 void* data;
7 void (*cb)(structev_loop *loop, structev_async *w, int revents);
8 };

ev_async当ev_async_send通过watcher调用时调用，触发EV_ASYNC

1 union ev_any_watcher {
2 struct ev_watcher w;
3 struct ev_watcher_list wl;
4 struct ev_io io;
5 struct ev_timer timer;
6 struct ev_periodic periodic;
7 struct ev_signal signal;
8 struct ev_child child;
9 #if EV_STAT_ENABLE
10 struct ev_stat stat;
11 #endif
12 #if EV_IDLE_ENABLE
13 struct ev_idle idle;
14 #endif
15 struct ev_prepare prepare;
16 struct ev_check check;
17 #if EV_FORK_ENABLE
18 struct ev_fork fork;
19 #endif
20 #if EV_CLEANUP_ENABLE
21 struct ev_cleanup cleanup;
22 #endif
23 #if EV_EMBED_ENABLE
24 struct ev_embed embed;
25 #endif
26 #if EV_ASYNC_ENABLE
27 struct ev_async async;
28 #endif
29 };

该结构的存在用以强制类似结构的布局

1 struct ev_watcher {
2 int active;
3 int pending;
4 int priority;
5 void* data;
6 void (*cb)(structev_loop* loop, structev_watcher *w, int revent);
7 }
8
9 struct ev_watcher_list {
10 struct ev_wather_list *next;
11 int active;
12 int pending;
13 int prioirty;
14 void* data;
15 void (*cb)(structev_loop* loop, structev_watcher_list *w,intrevent);
16 };

1 static unsigned int ev_linux_version(void)

通过使用utsname结构以及uname函数获取linux版本号

1 static void ev_printerr(constchar *msg)

输出错误新方法，实现很简单用write直接往STDERR写数据

1 void ev_set_syserr_cb(void(*cb)(const char *msg))

设置系统错误控制方法回调

1 static void ev_syserr(constchar *msg)

系统错误处理函数，首先判断msg是否为空，msg==NULL填充为”(libev) system error”,然后如果系统错误控制回调不为空 也就是通过上面方法设置的，就调用该控制回调 否则的话就格式化输出 并中断程序运行

1 static void* ev_realloc_emul(void*ptr, long size)

作者分装的一个realloc，主要为了屏蔽不同平台的差异，比如 有些系统(如openBSD)不支持realloc(x,0)这种行为，于是作者进行了判定如果是含有__GLIBC__宏 那么就可以之间诶用realloc 否则的话当size为0则进行free操作

1 static void *(*alloc)(void*ptr, long size) = ev_realloc_emul;

定义了一个变量，并赋值，啥变量 一个指向返回值是void* 参数是void*,long的函数指针 不过看着总觉得不爽 习惯于typedef的写法，另一方面也就是说alloc等价与ev_realloc_emul哦

1 void ev_set_allocator(void*(*cb)(void* ptr,longsize))

设置alloc函数的实现，我们在上面的语句看到alloc的默认实现是啥，通过该函数可以改变其实现

1 inline_speed void* ev_realloc(void* ptr,long size)

一个realloc的实现调用的alloc，比之增加错误日志输出 有意思的是这里有一个叫做inline_speed的宏，libev的作者在libev中大量使用了，使人看代码相当不爽的说

1 #if EV_FEATURE_CODE
2 #define inline_speed static inline
3 #else
4 #define inline_speed static noinline
5 #endif

这里又一把宏定义，不过都是见名知义，EV_FEATURE_CODE默认情况是非0，也就是inline_speed默认为static inline

1 #define ev_malloc(size) ev_realloc(0,(size))
2 #define ev_free(ptr)m ev_realloc((ptr),0)

我们看到ev_malloc以及ev_free其实也是通过ev_realloc实现的

1 typedef struct{
2 ev_watcher_list* head; //监听者链表
3 unsigned charevents; //监听的事件
4 unsigned charreify;//状态位 用来表示具体是EV_ANFD_REIFY还是EV_IOFDSET
5 unsigned charemask;//epoll用来保存内核mask的值
6 unsigned charunused;//同名字
7 #if EV_USE_EPOLL
8 unsigned integen;
9 #endif
10 #if EV_SELECT_ISWINSOCKET || EV_USE_IOCP
11 SOCKET handle
12 #endif
13 #if EV_USE_IOCP
14 OVERLAPPED or,ow;
15 #endif
16 } ANFD;

文件描述符信息结构

1 typedef struct {
2 ev_watcher* w;
3 int events;
4 } ANPENDING;

指定等待事件的监听者结构

1 typedef struct {
2 ev_watcher_list* head;
3 } ANFS;

每个inotify-id对应的哈希表的每个节点的结构

1 typedef struct {
2 ev_tstamp at;
3 ev_watcher_time* w;
4 } ANHE;

堆结构的节点

1 struct ev_loop {
2 ev_tstamp ev_rt_now;
3 }

1 ev_tstamp ev_time(void)

获取当前时间如果设置了EV_USE_REALTIME会考虑是否使用clock_gettime纳秒（have_realtiem如果为非负就使用 clock_gettime了） 否则使用gettimeofday 注意这里的时间都是和当前设置的时间是有关系的 也就是说如果我把系统时间修改了 可能得到过去的时间
另外这里用了一个宏expect_true 其原型是__builtin_expect((a) != 0, 1)也就是告诉编译器绝大多数情况下a != 0是满足的 方便编译器进行优化 同理相反的还有expect_false

1 inline_size ev_tstamp get_clock(void)

这个函数优先是使用CLOCK_MONOTONIC时间 也就是单调时间不会被修改减小 然后达不到要求 则调用ev_time来获取时间 inline_size就是 static inline

1 ev_tstamp ev_now(structev_loop *loop)

获取当前时间时间 也就是loop->ev_rt_now

1 void ev_sleep(ev_tstamp delay)

如果可以使用nanosleep则使用nanosleep 如果在window下使用Sleep,否则使用select实现

1 inline_size intarray_next(int elem, int cur, int cnt)

用来生成内存对齐大小的实际需要开辟的内存大

1 static ninline void* array_realloc(intelem, void *base, int *cur, int cnt)

开辟或重新非配一定大小的内存块，该方法会调用上面的函数进行内存对齐大小 所以返回后的大小不一定会和想开辟的相等

1 array_init_zero(base,count)

顾名思义初始化为0，通过memset实现

1 array_needsize(type,base,cur,cnt,init)

分配需要大小的内存 就是分配出内存 并初始化为0

1	array_free(stem,idx）