PHP源码分析 - PHP-FPM定时事件

PHP-FPM内部采用IO和定时两种事件来保证系统流畅的运转。IO事件负责父子进程的通信、信号收集等工作，定时事件负责系统安全检查方面的工作。PHP-FPM内置fpm_pctl_perform_idle_server_maintenance_heartbeat 和 fpm_pctl_heartbeat两个定时事件，fpm_pctl_perform_idle_server_maintenance_heartbeat的功能在前篇《PHP-FPM运行模式详解》文章已作介绍，fpm_pctl_heartbeat主要负责PHP-PFM的慢日志采集及子进程状态检查操作。
下面我们将重点介绍PHP-FPM定时事件。

PHP-FPM定义一个fpm_event_queue_timer静态全局变量存放定时事件。如下。

static struct fpm_event_queue_s *fpm_event_queue_timer = NULL;

fpm_event_queue_timer是一个fpm_event_queue_s类型的数据。

typedef struct fpm_event_queue_s {    struct fpm_event_queue_s *prev;     struct fpm_event_queue_s *next;    struct fpm_event_s *ev;} fpm_event_queue;

fpm_event_queue_s是一个双向链表结构，prev指向前一个事件地址，next指向后一个事件地址，ev采用fpm_event_s结构来保存了当前事件信息。fpm_event_s代码如下：

struct fpm_event_s {    int fd; //文件描述符    struct timeval timeout;  //定时事件下一次触发的时间点    struct timeval frequency; //定时事件周期    void (*callback)(struct fpm_event_s *, short, void *); //回调方法    void *arg; //回调参数    int flags;    int index;                    short which; //事件类型};

其中timeout、frequency属于定时事件的特有属性。当flags=FPM_EV_READ时，表示I/O读事件；当flags=FPM_EV_PERSIST时，表示定时事件。

上面是事件数据结构的简单介绍，下面我们将分析定时事件的运行流程。

注册事件
FPM封装了fpm_event_set_timer函数，用于注册一个定时事件。fpm_event_set_timer代码如下：

#define fpm_event_set_timer(ev, flags, cb, arg) fpm_event_set((ev), -1, (flags), (cb), (arg));int fpm_event_set(struct fpm_event_s *ev, int fd, int flags, void (*callback)(struct fpm_event_s *, short, void *), void *arg){     if (!ev || !callback || fd < -1) {        return -1;    }    memset(ev, 0, sizeof(struct fpm_event_s));    ev->fd = fd;    //设置回调函数    ev->callback = callback;    //回调函数参数    ev->arg = arg;    ev->flags = flags;    return 0;}

fpm_event_set负责事件的初始化操作。与IO事件不同的是，此时ev->fd=-1。

添加事件
通过执行fpm_event_add将定时事件添加到事件列表中。fpm_event_add代码如下：

int fpm_event_add(struct fpm_event_s *ev, unsigned long int frequency){    struct timeval now;    struct timeval tmp;    if (!ev) {        return -1;    }    ev->index = -1;    if (ev->flags & FPM_EV_READ) {        ev->which = FPM_EV_READ;        if (fpm_event_queue_add(&fpm_event_queue_fd, ev) != 0) {            return -1;        }        return 0;    }    //定时事件(器)    ev->which = FPM_EV_TIMEOUT;    fpm_clock_get(&now);    if (frequency >= 1000) {        tmp.tv_sec = frequency / 1000;        tmp.tv_usec = (frequency % 1000) * 1000;    } else {        tmp.tv_sec = 0;        tmp.tv_usec = frequency * 1000;    }    ev->frequency = tmp;    //设置超时时间点 ev->timeout    fpm_event_set_timeout(ev, now);    if (fpm_event_queue_add(&fpm_event_queue_timer, ev) != 0) {        return -1;    }    return 0;}

fpm_event_queue_add函数的功能是将事件添加到事件列表中。如果ev是IO事件，则添加至&fpm_event_queue_fd列表。反之，系统会认为这是一个定时事件，则会被添加到&fpm_event_queue_timer列表。

触发事件
事件触发的功能位于fpm_event_loop，部分代码如下：

while (1) {    struct fpm_event_queue_s *q, *q2;    struct timeval ms;    struct timeval tmp;    struct timeval now;    unsigned long int timeout;    int ret;    fpm_clock_get(&now);    timerclear(&ms);    //寻找最近一个定时事件触发时间点    q = fpm_event_queue_timer;    while (q) {        if (!timerisset(&ms)) {            ms = q->ev->timeout;        } else {            if (timercmp(&q->ev->timeout, &ms, <)) {                ms = q->ev->timeout;            }        }        q = q->next;    }    if (!timerisset(&ms) || timercmp(&ms, &now, <) || timercmp(&ms, &now, ==)) {        timeout = 1000;    } else {        timersub(&ms, &now, &tmp);        timeout = (tmp.tv_sec * 1000) + (tmp.tv_usec / 1000) + 1;    }    //timeout 为 定时事件触发事件    ret = module->wait(fpm_event_queue_fd, timeout);    //子进程退出循环，主进程监控事件    // PM = PM_STYLE_DYNAMIC 模式，根据请求分配进程数    if (ret == -2) {        return;    }    //IO事件    if (ret > 0) {        zlog(ZLOG_DEBUG, "event module triggered %d events", ret);    }    //定时事件    q = fpm_event_queue_timer;    while (q) {        fpm_clock_get(&now);        if (q->ev) {            if (timercmp(&now, &q->ev->timeout, >) || timercmp(&now, &q->ev->timeout, ==)) {                //执行事件                fpm_event_fire(q->ev);                if (fpm_globals.parent_pid != getpid()) {                    return;                }                if (q->ev->flags & FPM_EV_PERSIST) {                    //重置下一次执行时间                    fpm_event_set_timeout(q->ev, now);                } else {                     //只执行单次,则从事件列表中移除该事件对象                    q2 = q;                    if (q->prev) {                        q->prev->next = q->next;                    }                    if (q->next) {                        q->next->prev = q->prev;                    }                    if (q == fpm_event_queue_timer) {                        fpm_event_queue_timer = q->next;                        if (fpm_event_queue_timer) {                            fpm_event_queue_timer->prev = NULL;                        }                    }                    q = q->next;                    free(q2);                    continue;                }            }        }        q = q->next;    }}

fpm_event_loop内部是一个死循环，其运行流程如下：
1. 遍历fpm_event_queue_timer事件列表，计算最近一个定时事件触发的等待时间，保存在timeout变量中。
2. 执行module->wait(fpm_event_queue_fd, timeout)获取IO事件，注意，这里需要传入等待的时间timeout秒。
module是事件驱动模块,wait对应的是事件模块方法。以”epoll”为例，调用的是fpm_event_epoll_wait方法。

static int fpm_event_epoll_wait(struct fpm_event_queue_s *queue, unsigned long int timeout) {    int ret, i;    memset(epollfds, 0, sizeof(struct epoll_event) * nepollfds);    //timeout = 0 表示立刻返回    //timeout = -1 标识一直等待    //timeout>0 超时时间    ret = epoll_wait(epollfd, epollfds, nepollfds, timeout);    if (ret == -1) {        //...省略部分代码...    }    for (i = 0; i < ret; i++) {        //...省略部分代码...        //回调事件        fpm_event_fire((struct fpm_event_s *)epollfds[i].data.ptr);        //...省略部分代码...    }    return ret;}

epoll_wait: 返回需处理的事件数目，如果等待超时(在timeout时间内，未有IO事件触发)，则返回0。
3. 遍历fpm_event_queue_timer定时事件列表，判断事件是否可以执行。倘若可以，则调用fpm_event_fire执行，根据事件类型选择调用fpm_event_set_timeout重置下一次执行时间或者free()来释放对象。

void fpm_event_fire(struct fpm_event_s *ev){    if (!ev || !ev->callback) {        return;    }    (*ev->callback)( (struct fpm_event_s *) ev, ev->which, ev->arg);    }

fpm_event_fire：回调事件函数。对于定时事件，ev->which = FPM_EV_TIMEOUT。

#ifndef timeradd# define timeradd(a, b, result)                          \    do {                                                 \        (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;    \        (result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \        if ((result)->tv_usec >= 1000000)                \        {                                                \            ++(result)->tv_sec;                          \            (result)->tv_usec -= 1000000;                \        }                                                \    } while (0)#endif#define fpm_event_set_timeout(ev, now) timeradd(&(now), &(ev)->frequency, &(ev)->timeout);

fpm_event_set_timeout计算事件的下一次执行时间点，并保存在ev对象的timeout属性。

总体来说，定时事件的实现比较简洁，在执行定时事件的时候，进程是一个阻塞的过程。所以当我们再定义一个定时事件时，应该避免冗长而又复杂的逻辑处理，减少运行的事件，降低对其他事件的影响。