libco源码解析---co_eventloop

引言

　　我们总能在运行libco协程代码的最后看到对于函数co_eventloop的调用，它可以理解为主协程执行的函数。我们举一个简单的例子来说明它的作用：

void* routinefun(void* args){
    co_enable_hook_sys();
    while(true){
        poll(NULL, 0, 1000);
    }
    return 0;
}

int main(int argc,char *argv[])
{
    vector<task_t> v;
    for(int i=1;i<argc;i+=2)
    {
        task_t task = { 0 };
        SetAddr( argv[i],atoi(argv[i+1]),task.addr );
        v.push_back( task );
    }

    for(int i=0;i<2;i++)
    {
        stCoRoutine_t *co = 0;
        co_create( &co,NULL,routinefun,v2 );
        printf("routine i %d\n",i);
        co_resume( co );
    }

    co_eventloop( co_get_epoll_ct(),0,0 );

    return 0;
}

　　这段代码非常简单，主协程运行两个协程，协程函数所做的事情就是使用poll切换执行权，并在一秒后切换回来（超时）。这里线程的执行过程是这样的，我们把主协程看做A，其他两个协程看做BC。执行过程为：

• B协程执行，使用poll把一个stPoll_t结构插入时间轮，切换执行权，回到A协程。
• C协程执行，使用poll把一个stPoll_t结构插入时间轮，切换执行权，回到A协程。
• 此时A协程执行Eventloop中，不停的循环，直到B协程注册的事件超时，调用回调回到B协程。
• B协程继续执行，再次使用poll，重复第一步，回到A协程。
• A协程继续执行Eventloop，不停的循环，直到C协程注册的事件超时，调用回调回到C协程。
• C协程继续执行，再次使用poll，重复第二步，回到A协程。
• …

　　这样我们就可以看清楚co_eventloop到底做了什么，其实就是不停的轮询等待其他协程注册的事件成立，仅此而已。主协程就相当于libco非对称协程当中的一个特殊的调度器，负责唤醒协程B和协程C，它绝不会通过yied操作主动让出CPU，但是可以通过co_resume。唤醒另一个协程，唤醒协程的回调函数OnSignalProcessEvent或OnPollProcessEvent。源码如下：

static void OnSignalProcessEvent( stTimeoutItem_t * ap )
{
    stCoRoutine_t *co = (stCoRoutine_t*)ap->pArg;
    co_resume( co );
}

void OnPollProcessEvent( stTimeoutItem_t * ap )
{
    stCoRoutine_t *co = (stCoRoutine_t*)ap->pArg;
    co_resume( co );
}

 

co_eventloop

co_eventloop函数源码如下：

/*
* libco的核心调度
* 在此处调度三种事件：
* 1. 被hook的io事件，该io事件是通过co_poll_inner注册进来的
* 2. 超时事件
* 3. 用户主动使用poll的事件
* 所以，如果用户用到了三种事件，必须得配合使用co_eventloop
*
* @param ctx epoll管理器
* @param pfn 每轮事件循环的最后会调用该函数
* @param arg pfn的参数
*/
void co_eventloop( stCoEpoll_t *ctx,pfn_co_eventloop_t pfn,void *arg )
{
    if( !ctx->result )// 给结果集分配空间
    {
        // _EPOLL_SIZE：epoll结果集大小
        ctx->result =  co_epoll_res_alloc( stCoEpoll_t::_EPOLL_SIZE );
    }
    co_epoll_res *result = ctx->result;


    for(;;)
    {
        //调用 epoll_wait() 等待 I/O 就绪事件，为了配合时间轮⼯作，这里的 timeout设置为 1 毫秒。
        int ret = co_epoll_wait( ctx->iEpollFd,result,stCoEpoll_t::_EPOLL_SIZE, 1 );

        /**
         * 获取激活事件队列和定时超时事件的临时存放链表
         * 不使用局部变量的原因是epoll循环并不是元素的唯一来源.例如条件变量相关(co_routine.cpp stCoCondItem_t)
         */
        stTimeoutItemLink_t *active = (ctx->pstActiveList);
        stTimeoutItemLink_t *timeout = (ctx->pstTimeoutList);

        //初始化timeout
        memset( timeout,0,sizeof(stTimeoutItemLink_t) );

        /**
         * 处理返回的结果集，如果pfnPrepare不为NULL，就直接调用注册的回调函数进行处理
         * 否则，将其直接加入就绪事件的队列，pfnPrepare实际上就是OnPollPreparePfn函数
         */
        for(int i=0;i<ret;i++)
        {
            // 获取在co_poll_inner放入epoll_event中的stTimeoutItem_t结构体
            stTimeoutItem_t *item = (stTimeoutItem_t*)result->events[i].data.ptr;
            // 如果用户设置预处理回调的话就执行
            if( item->pfnPrepare )
            {
                // 若是hook后的poll的话,会把此事件加入到active队列中,并更新一些状态
                item->pfnPrepare( item,result->events[i],active );
            }
            else
            {
                AddTail( active,item );
            }
        }

        //从时间轮上取出已超时的事件，放到 timeout 队列。
        unsigned long long now = GetTickMS();
        TakeAllTimeout( ctx->pTimeout,now,timeout );

        //遍历 timeout 队列，设置事件已超时标志（bTimeout 设为 true）。
        stTimeoutItem_t *lp = timeout->head;
        // 遍历超时链表,设置超时标志,并加入active链表
        while( lp )
        {
            //printf("raise timeout %p\n",lp);
            lp->bTimeout = true;
            lp = lp->pNext;
        }

        //将 timeout 队列中事件合并到 active 队列。
        Join<stTimeoutItem_t,stTimeoutItemLink_t>( active,timeout );

        /**
         * 遍历 active 队列，调用⼯作协程设置的 pfnProcess() 回调函数 resume挂起的⼯作协程，
         * 处理对应的 I/O 或超时事件。
         */
        lp = active->head;
        // 开始遍历active链表
        while( lp )
        {
            // 在链表不为空的时候删除active的第一个元素 如果删除成功,那个元素就是lp
            PopHead<stTimeoutItem_t,stTimeoutItemLink_t>( active );
            //如果被设置为超时并且当前事件还没有到达实际设置的超时事件
            if (lp->bTimeout && now < lp->ullExpireTime)
            {
                // 一种排错机制,在超时和所等待的时间内已经完成只有一个条件满足才是正确的
                int ret = AddTimeout(ctx->pTimeout, lp, now);
                if (!ret)//插入成功
                {
                    //重新开始定时
                    lp->bTimeout = false;
                    lp = active->head;
                    continue;
                }
            }
            if( lp->pfnProcess )
            {
                lp->pfnProcess( lp );
            }

            lp = active->head;
        }
        // 每次事件循环结束以后执行该函数, 用于终止协程，相当于终止回调函数
        if( pfn )
        {
            if( -1 == pfn( arg ) )
            {
                break;
            }
        }

    }
}

　　首先我们可以看到active和timeout链表都在stCoEpoll_t中存储，而这个结构是线程私有的。那么为什么不把这个值设置成局部变量呢？答案不在co_eventloop中，而藏在其他函数，比如libco实现的条件变量中，条件变量会在signal后把值放入到active链表或者timeout链表，而这些只能放在stCoEpoll_t中。

stCoEpoll_t函数源码：

struct stCoEpoll_t
{
    int iEpollFd;    // epoll 实例的⽂件描述符

    /**
     * 值为 10240 的整型常量。作为 epoll_wait() 系统调用的第三个参数，
     * 即⼀次 epoll_wait 最多返回的就绪事件个数。
     */
    static const int _EPOLL_SIZE = 1024 * 10;

    /**
     * 该结构实际上是⼀个时间轮（Timingwheel）定时器，只是命名比较怪，让⼈摸不着头脑。
     * 单级时间轮来处理其内部的超时事件。
     */
    struct stTimeout_t *pTimeout;

    /**
     * 该指针实际上是⼀个链表头。链表用于临时存放超时事件的 item。
     */
    struct stTimeoutItemLink_t *pstTimeoutList;

    /**
     * 也是指向⼀个链表。该链表用于存放 epoll_wait 得到的就绪事件和定时器超时事件。
     */
    struct stTimeoutItemLink_t *pstActiveList;

    /**
     * 对 epoll_wait()第⼆个参数的封装，即⼀次 epoll_wait 得到的结果集。
     */
    co_epoll_res *result;

};

　　还有这里的timeout链表其实最终会合并到active中，先分开纯粹是为了处理方便一点。然后就是把事件从epoll结果集中拿出来，如果需要的话就去执行预处理回调。我们来看看预处理回调，我们曾在poll中提到过：

void OnPollPreparePfn( stTimeoutItem_t * ap,struct epoll_event &e,stTimeoutItemLink_t *active )
{
    stPollItem_t *lp = (stPollItem_t *)ap;
    // 把epoll此次触发的事件转换成poll中的事件
    lp->pSelf->revents = EpollEvent2Poll( e.events );


    stPoll_t *pPoll = lp->pPoll;
    // 已经触发的事件数加一
    pPoll->iRaiseCnt++;

    // 若此事件还未被触发过
    if( !pPoll->iAllEventDetach )
    {
        // 设置已经被触发的标志
        pPoll->iAllEventDetach = 1;

        // 将该事件从时间轮中移除
        // 因为事件已经触发了，肯定不能再超时了
        RemoveFromLink<stTimeoutItem_t,stTimeoutItemLink_t>( pPoll );

        // 将该事件添加到active列表中
        AddTail( active,pPoll );

    }
}

所做的事情：

• 将触发的事件由epoll类型转换为poll类型
• 触发的事件数加1
• 如果当前事件是第一次被触发，就设置触发标志位，并将其从超时事件队列中移除，最后将其加入就绪事件队列active，如果不是第一次触发，就不再进行任何处理

其实所做的事情就是把epoll事件对应的stPoll_t结构中的值执行一些修改，并把此项插入到active链表中。

然后就是从时间轮中取出根据目前时间来说已经超时的事件，并插入到timeout链表中：

inline void TakeAllTimeout( stTimeout_t *apTimeout,unsigned long long allNow,stTimeoutItemLink_t *apResult )
{
    // 第一次调用是设置初始时间
    if( apTimeout->ullStart == 0 )
    {
        apTimeout->ullStart = allNow;
        apTimeout->llStartIdx = 0;
    }

    // 当前时间小于初始时间显然是有问题的
    if( allNow < apTimeout->ullStart )
    {
        return ;
    }
    // 求一个取出事件的有效区间
    int cnt = allNow - apTimeout->ullStart + 1;
    if( cnt > apTimeout->iItemSize )
    {
        cnt = apTimeout->iItemSize;
    }
    if( cnt < 0 )
    {
        return;
    }
    for( int i = 0;i<cnt;i++)
    {    // 把上面求的有效区间过一遍，某一项存在数据的话插入到超时链表中
        int idx = ( apTimeout->llStartIdx + i) % apTimeout->iItemSize;
        // 链表操作，没什么可说的
        Join<stTimeoutItem_t,stTimeoutItemLink_t>( apResult,apTimeout->pItems + idx  );
    }
    // 更新时间轮属性
    apTimeout->ullStart = allNow;
    apTimeout->llStartIdx += cnt - 1;
}

　　然后就是把超时链表处理以后加入到active链表啦。

　　然后就是遍历active链表，一一执行每一个事件的回调啦，当然没执行一次回调就意味着一次协程的切换，因为我们在poll中注册的回调执行co_resume。

　　循环的最后调用了pfn，这是一个我们在调用co_eventloop时传入的函数指针，它的作用是什么呢？跳出Eventloop循环的时候使用，因为不是所有的协程使用都想例子一样把 co_eventloop放在函数最后，协程更多的是嵌到代码中，我们需要在有些时候终止eventloop，传入一个终止回调就是一个不错的方法。

co_eventloop完成的工作总结：

1、监听所有事件

2、如果必要的话，对就绪事件做一些预处理，再将其加入就绪事件队列，否则直接加入就绪事件队列

3、获取超时事件

4、将超时事件合并到就绪事件队列

5、遍历整个就绪事件队列，调用相应的回调函数，唤醒相应的协程对改事件进行处理

6、如果需要跳出循环的话就跳出循环，否则继续执行epoll_wait开始监听事件

转载：

https://blog.csdn.net/weixin_43705457/article/details/106891077?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162694514116780271590368%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=162694514116780271590368&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-1-106891077.pc_search_result_cache&utm_term=libco+co_eventloop&spm=1018.2226.3001.4187