c++ - C++/gcc/linux中的延续/协程/生成器

背景:我正在尝试通过提出这个玩具问题来弄清楚如何实现延续/协程/生成器(无论以下内容如何)。环境是gcc 4.6和linux 3.0 x86_64上的C++ 11。非便携式很好，但是不允许使用外部库(boost.coroutine，COROUTINE等)。我认为longjmp(3)和/或makecontext(2)和 friend 可能会有所帮助，但不确定。

说明:

下面的玩具解析器应该解析长度相等的as和bs的序列。 IE

((a+)(b+))+

这样，第二个带括号的产品的长度等于第三个带括号的产品的长度。

找到产品(例如aaabbb)时，将输出找到的a的数量(例如3)。

代码:

#include <stdlib.h>
#include <iostream>
using namespace std;

const char* s;

void yield()
{
        // TODO: no data, return from produce
        abort();
}

void advance()
{
        s++;
        if (*s == 0)
                yield();
}

void consume()
{
        while (true)
        {
                int i = 0;

                while (*s == 'a')
                {
                        i++;
                        advance();
                }

                cout << i << " ";

                while (i-- > 0)
                {
                    if (*s != 'b')
                        abort();
                    advance();
                }
        }
}

void produce(const char* s_)
{
        s = s_;

        // TODO: data available, continue into consume()
        consume();
}

int main()
{
        produce("aaab");
        produce("bba");
        produce("baa");
        produce("aabbb");
        produce("b");

        // should print: 3 1 4

        return 0;
}

问题:

如您所见，当调用consume然后yield返回时，必须保存produce调用堆栈的状态。当再次调用produce时，必须通过从consume返回来重新启动yield。挑战在于修改produce调用consume的方式并实现yield以便它们按预期运行。

(显然，重新实现消耗以便保存并重建其状态会破坏该练习的目的。)

我认为需要做的事情类似于makecontext手册页底部的示例:http://www.kernel.org/doc/man-pages/online/pages/man3/makecontext.3.html，但尚不清楚如何将其转换为此问题。 (我需要 sleep )

解决方案:

(感谢Chris Dodd的设计)

#include <stdlib.h>
#include <iostream>
#include <ucontext.h>
using namespace std;

const char* s;
ucontext_t main_context, consume_context;

void yield()
{
    swapcontext(&consume_context, &main_context);
}

void advance()
{
    s++;
    if (*s == 0)
            yield();
}

void consume()
{
    while (true)
    {
            int i = 0;

            while (*s == 'a')
            {
                    i++;
                    advance();
            }

            cout << i << " ";

            while (i-- > 0)
            {
                    advance();
            }
    }
}

void produce(const char* s_)
{
    s = s_;

    swapcontext(&main_context, &consume_context);
}

int main()
{
    char consume_stack[4096];

    getcontext(&consume_context);
    consume_context.uc_stack.ss_sp = consume_stack;
    consume_context.uc_stack.ss_size = sizeof(consume_stack);
    makecontext(&consume_context, consume, 0);

    produce("aaab");
    produce("bba");
    produce("baa");
    produce("aabbb");
    produce("b");

    // should print: 3 1 4

    return 0;
}

最佳答案

为此，很容易使用makecontext/swapcontext －您可以使用makecontext创建一个新的协程上下文，并使用swapcontext在它们之间进行交换。在这种情况下，您需要一个额外的协程来运行consume无限循环，然后在main上下文中运行main和production。

因此，main应该调用getcontext + makecontext来创建一个新的上下文，该上下文将运行消耗循环:

getcontext(&consume_ctxt);
// set up stack in consume_context
makecontext(&consume_ctxt, consume, 0);

然后produce将切换到它，而不是直接调用consume:

void produce(const char* s_)
{
    s = s_;
    swapcontext(&main_ctxt, &consume_ctxt);
}

最后yield仅调用swapcontext(&consume_ctxt, &main_ctxt);切换回主上下文(它将继续在produce中并立即返回)。

请注意，由于consume是一个无限循环，因此您不必担心返回时会发生什么(因此永远不会使用该链接)

Consume

c++ - C++/gcc/linux中的延续/协程/生成器