数据归档

实现一个简单的C++协程库 - twoon

作者:admin 2017-05-20 我要评论

...

过去的看协程相关性的东西时,一次考虑过,考虑着什么创造生命本源 C++ 用,但他被本身非法劫回现场的请求和回复,不注意深化的做研究,归于许可。以新的方式,微博音符民族说什么创造任何人 user space 螺纹库,重要的人物提到它 setcontext,swapcontext 如此的效能,可以用来保持和切换环境,我突然觉得这必不可少的事物也能用来创造协程,对感到懊悔或忏悔搜,果真,重要的人物用这些效能做了相关性的事实,略略看了已确定的,依我看它不轻易运用,无妨做任何人简略的点。

说到 c++ 上的协程,boost 实则,先前有相关性的创造,无论如何接合眼神宁愿引起麻烦的,偏航的符号讲,我觉得 Lua 的协程最精炼易用了,从概念上讲比力正好的,你为什么不做任何人类比的呢?因而我要尾随 Lua 来创办任何人,只需证实四元组交谈就够了:

1)到达 coroutine。

2)run/resume coroutine。

3)产品 running corouinte。

4)IsCoroutineAlive。 

保持与回复环境

创造协程/螺纹,最引起麻烦的的是保持和切换环境,幸亏 makecontext,swapcontext 这些效能好的用,这个问题先前完整处理了:makecontext 可以帮咱们创办起协程的环境,swapcontext 可以切换差别的环境,创造了目前职务的短暂地终止,切换,给予帮忙及其他效能,因此切换回持续EF:

#include 
#include 
usingnamespace std;

staticchar g_stack[2048];
static ucontext_t ctx,ctx_main;

void func()
{
    // do 什么东西。
    cout << "enter func" << endl;

    swapcontext(&ctx, &ctx_main);

    cout << "func1 resume from yield" << endl;
    // continue to do 什么东西。}

int main()
{
   getcontext(&CTX)
   ctx.uc_stack.ss_sp = g_stack;
   ctx.uc_stack.ss_size = sizeof g_stack;
   ctx.uc_link = &ctx_main;
    
   makecontext(&ctx, func, 0);

   cout << "in main, before coroutine starts" << endl;

   swapcontext(&ctx_main, &CTX)

   cout << "back to main" << endl;

   swapcontext(&ctx_main, &CTX)
   
   cout << "back to main again" << endl;
   return0;
}

如加密所示,很明显,咱们得把它包起来 swapcontext,它可以简单明了地做 Yield 和 Resume,受胎它们的帮忙协程做起来就轻易多了。

运用和执行

在运用 makecontext,swapcontext 的按照,我花了任何人多小时简略创造了任何人协程库,参考这边,该加密被研究到超越200行完整,参加突袭的是简略的,运用起来也很手边的:

#include ""

#include 

usingnamespace std;

CoroutineScheduler* sched = NULL;

void func1(void* 精氨酸)
{
    uintptr_t ret;
    cout << "1 a now!,arg:" << arg << ", start to 产品。" << endl;
    ret = sched->Yield((uintptr_t)"func1 yield 1");
    cout << "1.fun1 return from yield:" << (constchar*)ret << endl;
    ret = sched->Yield((uintptr_t)"func1 yield 2");
    cout << "2.fun1 return from yield:" << (constchar*)ret << ", going to stop" << endl;

}

void func2(void* s)
{
    cout << "function2 a now!, arg:" << s << ", start to 产品。" << endl;
    constchar* y = (constchar*)sched->Yield((uintptr_t)"func2 yield 1");
    cout << "fun2 return from yield:" << y <<", going to stop" << endl;
}

int main()
{
    sched = new CoroutineScheduler();

    bool stop = false;
    int f1 = sched->CreateCoroutine(func1, (void*)111);
    int f2 = sched->CreateCoroutine(func2, (void*)222);

    while (!终止)
    {
        stop = true;
        if (附加物IsCoroutineAlive(f1))
        {
            stop = false;
            constchar* y1 = (constchar*)sched->ResumeCoroutine(f1, (uintptr_t)"resume func1");
            cout << "func1 yield:" << y1 << endl;
        }

        if (附加物IsCoroutineAlive(f2))
        {
            stop = false;
            constchar* y2 = (constchar*)sched->ResumeCoroutine(f2, (uintptr_t)"resume func2");
            cout << "func2 yield:" << y2 << endl;
        }
    }

    delete sched;
    return0;
}

如上所示,Yield 内地前进的决定因素将被要求 Resume 回转,同样地 Resume 次要的决定因素,会在 Yield 回转外面,机制也容许复制的 Lua 来的,有些时辰可以用来在协程间前进已确定的决定因素,很手边的,眼神也很酷,但创造相当精炼,紧排加密如次:

// static functionvoid CoroutineScheduler::SchedulerImpl::Schedule(void* 精氨酸)
{
    assert(精氨酸);
    SchedulerImpl* sched = (SchedulerImpl*) arg;

    int running = sched->running_;

    coroutine* cor = sched->id2routine_[running];
    断言(感情)

    cor(肺效能精氨酸);

    sched->running_ = -1;
    cor->status = CO_FINISHED;
}

// resume 协程。
uintptr_t CoroutineScheduler::SchedulerImpl::ResumeCoroutine(int id, uintptr_t y)
{
    coroutine* cor = id2routine_[id];
    if (肺 == NULL || cor->status == CO_RUNNING) return0;

    cor->yield = y;
    switch (肺->国家的)
    {
        case CO_READY:
            {
                getcontext(&cor->CXT)

                cor->status = CO_RUNNING;
                cor->cxt.uc_stack.ss_sp = cor->stack;
                cor->cxt.uc_stack.ss_size = stacksize_;
                // sucessor 背景。
                cor->cxt.uc_link = &mainContext_;

                running_ = id;
                makecontext(&cor->cxt, (void (*)())Schedule, 1, this);
                swapcontext(&mainContext_, &cor->CXT)
            }
            break;
        case CO_SUSPENDED:
            {
                running_ = id;
                cor->status = CO_RUNNING;
                swapcontext(&mainContext_, &cor->CXT)
            }
            break;
        default:
            assert(0);
    }

    uintptr_t ret = cor->yield;

    if (运转 == -1 && cor->status == CO_FINISHED) DestroyCoroutine(id);

    return ret;
}

uintptr_t CoroutineScheduler::SchedulerImpl::Yield(uintptr_t y)
{
    if (运转 < 0) return0;

    int cur = running_;
    running_ = -1;

    coroutine* cor = id2routine_[cur];

    cor->yield = y;
    cor->status = CO_SUSPENDED;

    swapcontext(&cor->cxt, &mainContext_);
    return cor->yield;
}

在加密堆积起来和程序结构小眼面,前述的创造精炼,但在详细资料,每个协程都要分派任何人必然堆积起来的栈空的,空的性能能够非常地,光照差强人意的;运转性能上来说,swapcontext 的给予帮忙性能什么,现时还不觉悟,无论如何为了结论的实体的,让咱们先做,你可以知情及其他人做什么。 

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

相关文章
  • 实现一个简单的C++协程库 - t

    实现一个简单的C++协程库 - t

  • 上海莫泰168酒店地址分别在哪

    上海莫泰168酒店地址分别在哪

  • 惠阳区地图_惠阳区地图全图

    惠阳区地图_惠阳区地图全图

  • 鲁东大学商学院与大屋集团威

    鲁东大学商学院与大屋集团威