Redis为什么这么快？

/* State of an event based program */
typedef struct aeEventLoop {
    intmaxfd;                 /* highest filedescriptor currently registered, 当前注册的最大fd数 */
    intsetsize;               /* max number offile descriptors tracked, 允许关注fd数量的上限(就是events和fired数组的大小) */
    longlong timeEventNextId  /* 下一个定时事件的ID */;
   time_t lastTime;           /* Usedto detect system clock skew */
   aeFileEvent *events;       /*Registered events, 指向aeFileEvent数组, 每个fd都有对应的aeFileEvent对象(fd就是当做下标用于索引)*/
   aeFiredEvent *fired;       /*Fired events, 指向aeFiredEvent数组,当检测到有文件事件时, 会将对应的fd和事件存放在数组里面*/
   aeTimeEvent *timeEventHead /* 指向首个时间事件结构体, 而时间事件结构体里有next指针, 指向下一个结构体, 实际上整体看上去是一个环形链表(最后一个时间事件结构体里的next指针会指向timeEventHead */;
    intstop                   /* 是否停止event loop循环 */;
    void*apidata;             /* This is used forpolling API specific data, 指向底层不同多路复用实现的数据结构, 可以是epoll, select, evport或者是kqueue */
   aeBeforeSleepProc *beforesleep;
   aeBeforeSleepProc *aftersleep;
} aeEventLoop;

aeEventLoop *aeCreateEventLoop(int setsize){
   aeEventLoop *eventLoop;
    inti;
 
    if((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) goto err;
   eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);
   eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);
    if(eventLoop->events == NULL || eventLoop->fired == NULL) goto err;
   eventLoop->setsize = setsize;
   eventLoop->lastTime = time(NULL);
   eventLoop->timeEventHead = NULL;
   eventLoop->timeEventNextId = 0;
   eventLoop->stop = 0;
   eventLoop->maxfd = -1;
   eventLoop->beforesleep = NULL;
   eventLoop->aftersleep = NULL;
    if(aeApiCreate(eventLoop) == -1) goto err;
    /*Events with mask == AE_NONE are not set. So let's initialize the
    * vector with it. */
    for(i = 0; i < setsize; i++)
       eventLoop->events[i].mask = AE_NONE;
    returneventLoop;
}

/* File event structure */
typedef struct aeFileEvent {
    intmask; /* one of AE_(READABLE|WRITABLE) */
   aeFileProc *rfileProc;  /* 指向有读事件调用的处理函数 */
   aeFileProc *wfileProc;  /* 指向有写事件调用的处理函数 */
    void*clientData;       /* 指向私有数据, 当做可读/可写函数的入参 */
} aeFileEvent;
 
/* A fired event */
typedef struct aeFiredEvent {
    int fd;
    intmask;
} aeFiredEvent;

int aeCreateFileEvent(aeEventLoop *eventLoop,int fd, int mask,
       aeFileProc *proc, void *clientData)
{
    if(fd >= eventLoop->setsize) {
       errno = ERANGE;
       return AE_ERR;
    }
   aeFileEvent *fe = &eventLoop->events[fd];
 
    if(aeApiAddEvent(eventLoop, fd, mask) == -1)
       return AE_ERR;
   fe->mask |= mask;
    if(mask & AE_READABLE) fe->rfileProc = proc;
    if(mask & AE_WRITABLE) fe->wfileProc = proc;
   fe->clientData = clientData;
    /*当前fd如果大于了目前的maxfd, 则需要进行更新 */
    if(fd > eventLoop->maxfd)
       eventLoop->maxfd = fd;
    returnAE_OK;
}

/* Time event structure */
typedef struct aeTimeEvent {
    longlong id;             /* time eventidentifier, 定时事件的ID */
    longwhen_sec;            /* seconds, 定时事件下一次触发的时间(秒) */
    longwhen_ms;             /* milliseconds, 定时事件下一次触发的时间(毫秒) */
   aeTimeProc *timeProc;     /* 指向定时事件发生时的调用函数 */
   aeEventFinalizerProc *finalizerProc; /* 指向当当前定时事件被删除时的清理函数 */
    void*clientData;         /* 指向私有数据, 当做定时事件函数的入参 */
    structaeTimeEvent *next; /* 指向下一个定时事件的指针 */
} aeTimeEvent;

static void aeAddMillisecondsToNow(long longmilliseconds, long *sec, long *ms) {
    longcur_sec, cur_ms, when_sec, when_ms;
 
    aeGetTime(&cur_sec,&cur_ms);
   when_sec = cur_sec + milliseconds/1000;
   when_ms = cur_ms + milliseconds%1000;
    if(when_ms >= 1000) {
       when_sec ++;
       when_ms -= 1000;
    }
    *sec= when_sec;
    *ms= when_ms;
}
 
long long aeCreateTimeEvent(aeEventLoop *eventLoop,long long milliseconds,
       aeTimeProc *proc, void *clientData,
       aeEventFinalizerProc *finalizerProc)
{
    longlong id = eventLoop->timeEventNextId++;
   aeTimeEvent *te;
 
   te = zmalloc(sizeof(*te));
    if(te == NULL) return AE_ERR;
   te->id = id;
    aeAddMillisecondsToNow(milliseconds,&te->when_sec,&te->when_ms);
   te->timeProc = proc;
   te->finalizerProc = finalizerProc;
   te->clientData = clientData;
   te->next = eventLoop->timeEventHead;
   eventLoop->timeEventHead = te;
    returnid;
}

int aeDeleteTimeEvent(aeEventLoop *eventLoop,long long id)
{
   aeTimeEvent *te = eventLoop->timeEventHead;
    while(te){
       if (te->id == id) {
           te->id = AE_DELETED_EVENT_ID;
           return AE_OK;
       }
       te = te->next;
    }
    returnAE_ERR; /* NO event with the specified ID found */
}

void aeMain(aeEventLoop *eventLoop) {
   eventLoop->stop = 0;
    while(!eventLoop->stop) {
       if (eventLoop->beforesleep != NULL)
           eventLoop->beforesleep(eventLoop);
       aeProcessEvents(eventLoop, AE_ALL_EVENTS|AE_CALL_AFTER_SLEEP);
    }
}

int aeResizeSetSize(aeEventLoop *eventLoop,int setsize) {
    inti;
 
    if(setsize == eventLoop->setsize) return AE_OK;
    if(eventLoop->maxfd >= setsize) return AE_ERR;
    if(aeApiResize(eventLoop,setsize) == -1) return AE_ERR;
 
   eventLoop->events = zrealloc(eventLoop->events,sizeof(aeFileEvent)*setsize);
   eventLoop->fired = zrealloc(eventLoop->fired,sizeof(aeFiredEvent)*setsize);
   eventLoop->setsize = setsize;
 
    *Make sure that if we created new slots, they are initialized with
    * an AE_NONE mask. */
    for(i = eventLoop->maxfd+1; i < setsize; i++)
       eventLoop->events[i].mask = AE_NONE;
    returnAE_OK;
}