协程Part1-boost.Coroutine.md

首先，在计算机科学中 routine 被定义为一系列的操作，多个 routine 的执行形成一个父子关系，并且子 routine 一定会在父 routine 结束前结束，也就是一个个的函数执行和嵌套执行形成了父子关系。

coroutine 也是广义上的 routine，不同的是 coroutine 能够通过一些操作保持执行状态，显式地挂起和恢复，相对于 routine 的单控制流，coroutine 能提供一个加强版的控制流。

协程执行转移

如图中的处理流程，多个 coroutine 通过一些机制，首先执行 routine foo 上的 std::cout << "a" 然后切换到 routine bar 上执行 std::cout << "b"，再切换回 routine foo 直到两个 routine 都执行完成。

coroutine 如何运行？

通常每个 corotuine 都有自己的 stack 和 control-block，类似于线程有自己的线程栈和control-block，当协程触发切换的时候，当前 coroutine 所有的非易失(non-volatile)寄存器都会存储到 control-block 中，新的 coroutine 需要从自己相关联的 control-block 中恢复。

协程的分类

A. 根据协程的执行转移机制可以分为非对称协程和对程协程：

• 非对称协程能知道其调用方，调用一些方法能让出当前的控制回到调用方手上。
• 对程协程都是平等的，一个对程协程能把控制让给任意一个协程，因此，当对称协程让出控制的时候，必须指定被让出的协程是哪一个。

B. 根据运行时协程栈的分配方式又能分为有栈协程和无栈协程：

通常情况下，有栈协程比无栈协程的功能更加强大，但是无栈协程有更高的效率，除此之外还有下面这些区别：

有栈协程能够在嵌套的栈帧中挂起并且在之前嵌套的挂起点恢复，而无栈协程只有最外层的 coroutine 才能够挂起，由顶层 routine 调用的 sub-routine 是不能够被挂起的。

有栈协程通常需要分配一个确定且固定的内存用来适配 runtime-stack，上下文的切换的时候相比于无栈协程也更加消耗资源，比如无栈协程仅仅只需要存储一个程序计数器（EIP）。有栈协程在语言（编译器）的支持下，有栈协程能够利用编译期计算得到非递归协程栈的最大大小，因此，内存的使用方面能够有所优化。无栈协程，不是代表没有运行时的栈，无栈只是代表着无栈协程所使用的栈是当前所在上下文的栈（比如一个函数 ESP~EBP 的区间内），所以能够正常调用递归函数。相反，有栈协程调用递归函数的时候，所使用的栈是该协程所申请的栈。

分三个方面来总结的话就是：

1. 内存资源使用：无栈协程借助函数的栈帧来存储一些寄存器状态，可以调用递归函数。而有栈协程会要申请一个内存栈用来存储寄存器信息，调用递归函数可能会爆栈。

2. 速度：无栈协程的上下文比较少，所以能够进行更快的用户态上下文切换。

3. 功能性：有栈协程能够在嵌套的协程中进行挂起/恢复，而无栈协程只能对顶层的协程进行挂起，被调用方是不能挂起的。

Boost.Coroutine

C++ Boost 库在 2009 年就提供了一个子库叫做 Boost.Coroutine 实现了有栈协程，且实现了对称（symmetric）和非对程（symmetric）协程。

1. 非对程协程（Asymmetric coroutine）

非对程协程提供了 asymmetric_coroutine<T>::push_type 和 asymmetric_coroutine<T>::pull_type 两种类型用于处理协程的协作。由命名可以理解，非对程协程像是创建了一个管道，通过push_type写入数据，通过pull_type拉取数据。

协程例子 A

boost::coroutines::asymmetric_coroutine<int>::pull_type source(
    [&](boost::coroutines::asymmetric_coroutine<int>::push_type& sink){
        int first=1,second=1;
        sink(first);
        sink(second);
        for(int i=0;i<8;++i){
            int third=first+second;
            first=second;
            second=third;
            sink(third);
        }
    });

for(auto i : source)
    std::cout << i <<  " ";

output:
1 1 2 3 5 8 13 21 34 55

上面的例子是协程实现的斐波那契数列计算，在上面的例子中，push_type 的实例构造时接受了一个函数作为构造函数入参，而这个函数就是 协程函数（coroutine function），coroutine 在 pull_type 创建的上下文下运行。

该协程函数的入参是一个以 push_type&，当实例化外层上下文中 pull_type 的时候，Boost 库会自动合成一个 push_type 传递给协程函数使用，每当调用 asymmetric_coroutine<>::push_type::operator() 的时候，协程会重新把控制权交还给push_type所在的上下文。其中asymmetric_coroutine<T> 的模板参数 T 定义了协程协作时使用的数据类型。

由于 pull_type 提供了input iterator，重载了 std::begin和std::end所以能够用 range-based for 循环方式来输出结果。

另外要注意的是，当第一次实例化pull_type的时候，控制权就会转移到协程上，执行协程函数，就好比要拉取(pull)数据需要有数据先写入(push)。

协程例子 B

struct FinalEOL{
    ~FinalEOL(){
        std::cout << std::endl;
    }
};

const int num=5, width=15;
boost::coroutines::asymmetric_coroutine<std::string>::push_type writer(
    [&](boost::coroutines::asymmetric_coroutine<std::string>::pull_type& in){
        // finish the last line when we leave by whatever means
        FinalEOL eol;
        // pull values from upstream, lay them out 'num' to a line
        for (;;){
            for(int i=0;i<num;++i){
                // when we exhaust the input, stop
                if(!in) return;
                std::cout << std::setw(width) << in.get();
                // now that we've handled this item, advance to next
                in();
            }
            // after 'num' items, line break
            std::cout << std::endl;
        }
    });

std::vector<std::string> words{
    "peas", "porridge", "hot", "peas",
    "porridge", "cold", "peas", "porridge",
    "in", "the", "pot", "nine",
    "days", "old" };

std::copy(boost::begin(words),boost::end(words),boost::begin(writer));

output:
           peas       porridge            hot           peas       porridge
           cold           peas       porridge             in            the
            pot           nine           days            old

接下来的这个例子主要说明了控制的反转，通过在主上下文中实例化的类型是push_type，逐个传递一系列字符串给到协程函数完成格式化输出，其构造函数是以pull_type&作为入参的匿名函数，在实例化push_type的过程中，库仍然会合成一个pull_type传递给该匿名函数，也就是协程函数。

与实例化pull_type不同，在主上下文中实例化push_type并不会直接进入到协程函数中，而是需要调用push_type::operator() 才能切换到协程上。

asymmetric_coroutine<T> 的模板参数 T 的类型不是 void 的时候，在协程函数中，可以通过pull_type::get()来获取数据，并通过pull_type::bool()判断协程传递的数据是否合法。

协程函数会以一个简单的return语句回到调用方的routine上，此时pull_type和push_type都会变成完成状态，也就是pull_type::operator bool()和push_type::operator bool() 都会变成 false;

协程的异常处理

coroutine函数内的代码不能阻止 unwind 的异常，不然会 stack-unwinding失败。

stack unwinding 通常和异常处理一起讨论，当异常抛出的时候，执行权限会立即向上传递直到任意一层 catch 住抛出的异常，而在向上传递前，需要适当地回收、析构本地自动变量，如果一个自动变量在异常抛出的时候被合适地被释放了就可以称为"unwound"了。

stackoverflow: what is stack unwinding?

try {
    // code that might throw
} catch(const boost::coroutines::detail::forced_unwind&) {
    throw;
} catch(...) {
    // possibly not re-throw pending exception
}

在 coroutine 内部捕获到了 detail::forced_unwind 异常时要继续抛出异常，否则会 stack-unwinding 失败，另外在 push_type 和 pull_type 的构造参数 attribute 也控制是是否需要 stack-unwinding。

2. 对称协程（Symmetric coroutine）

相对于非对称协程来说，对称协程能够转移执行控制给任意对称协程。

std::vector<int> merge(const std::vector<int>& a,const std::vector<int>& b)
{
    std::vector<int> c;
    std::size_t idx_a=0,idx_b=0;
    boost::coroutines::symmetric_coroutine<void>::call_type* other_a=0,* other_b=0;

    boost::coroutines::symmetric_coroutine<void>::call_type coro_a(
        [&](boost::coroutines::symmetric_coroutine<void>::yield_type& yield) {
            while(idx_a<a.size())
            {
                if(b[idx_b]<a[idx_a])    // test if element in array b is less than in array a
                    yield(*other_b);     // yield to coroutine coro_b
                c.push_back(a[idx_a++]); // add element to final array
            }
            // add remaining elements of array b
            while ( idx_b < b.size())
                c.push_back( b[idx_b++]);
        });

    boost::coroutines::symmetric_coroutine<void>::call_type coro_b(
        [&](boost::coroutines::symmetric_coroutine<void>::yield_type& yield) {
            while(idx_b<b.size())
            {
                if (a[idx_a]<b[idx_b])   // test if element in array a is less than in array b
                    yield(*other_a);     // yield to coroutine coro_a
                c.push_back(b[idx_b++]); // add element to final array
            }
            // add remaining elements of array a
            while ( idx_a < a.size())
                c.push_back( a[idx_a++]);
        });

    other_a = & coro_a;
    other_b = & coro_b;

    coro_a(); // enter coroutine-fn of coro_a

    return c;
}

std::vector< int > a = {1,5,6,10};
std::vector< int > b = {2,4,7,8,9,13};
std::vector< int > c = merge(a,b);
print(a);
print(b);
print(c);

output:
    a : 1 5 6 10
    b : 2 4 7 8 9 13
    c : 1 2 4 5 6 7 8 9 10 13

上面的例子是使用对称协程实现的一个有序数组的合并，对称协程提供了相类似的symmetric_coroutine<>::call_type 和 symmetric_coroutine<>::yield_type 两种类型用于对称协程的协作。call_type 在实例化的时候，需要接受一个以yield_type& 作为参数的(协程)函数进行构造，Boost库会自动合成一个yield_type作为实参进行传递，并且实例化 call_type 的时候，不会转移控制到协程函数上，而是在第一次调用call_type::operator()的时候才会进入到协程内。

yield_type::operator() 的调用需要提供两个参数，分别是需要转移控制的协程和需要传递的值，如果 symmetric_coroutine<T> 的模板参数类型是 void，那么不需要提供值，只是简单的转移控制。

在异常处理和退出方面，对称协程和非对称协程基本一致，非对程提供了一种多协程协作方案。

结语

虽然 Boost.Coroutine 库已经被标记为标记为已过时(deprecated)了，但是可以从历史的角度来理解协程的分类和基本工作原理，为现在多样化的协程探索拓宽道路。