Как вы реализуете сопрограммы на C++

Указывает ли COROUTINE - переносимая библиотека C++ для секвенирования сопрограмм в правильном направлении? Вроде элегантное решение, которое выдержало испытание временем ... ему 9 лет!

В папке DOC находится pdf-файл статьи Келда Хелсгауна «Переносимая библиотека C++ для секвенирования сопрограмм», в которой описывается библиотека и приводятся короткие примеры ее использования.

[обновление] Я сам успешно использую это. Любопытство взяло верх, поэтому я изучил это решение и обнаружил, что оно хорошо подходит для проблемы, над которой я работал некоторое время!

Если возможно, вам будет лучше использовать итератор, чем сопрограмму. Таким образом, вы можете продолжать вызывать next() для получения следующего значения, но вы можете сохранить свое состояние как переменные-члены, а не локальные переменные.

Это может сделать вещи более удобными в обслуживании. Другой разработчик C++ может не сразу понять сопрограмму, тогда как он может быть более знаком с итератором.

Я не думаю, что на C++ есть много полноценных и чистых реализаций. Одна попытка, которая мне нравится, - Библиотека протопотоков Адама Данкельса.

См. Также Protothreads: упрощение событийного программирования встроенных систем с ограничением памяти в цифровой библиотеке ACM и обсуждение в Википедии темы Протонить,

Да это можно сделать без проблем. Все, что вам нужно, это небольшой ассемблерный код, чтобы переместить стек вызовов в только что выделенный стек в куче.

Я бы посмотрите библиотеку boost :: coroutine.

Единственное, на что следует обратить внимание, - это переполнение стека. В большинстве операционных систем переполнение стека вызовет segfault, поскольку страница виртуальной памяти не отображается. Однако, если вы разместите стек в куче, вы не получите никакой гарантии. Просто имейте это в виду.

Вы всегда должны использовать вместо этого потоки; особенно в современном оборудовании. Если у вас есть работа, которую можно логически разделить в совместных подпрограммах, использование потоков означает, что работа может фактически выполняться одновременно отдельными исполнительными модулями (ядрами процессора).

Но, возможно, вы действительно хотите использовать сопрограммы, возможно, потому, что у вас есть хорошо протестированный алгоритм, который уже был написан и протестирован таким образом, или потому, что вы переносите код, написанный таким образом.

Если вы работаете в Windows, вам следует взглянуть на волокна. Fibers предоставят вам структуру, подобную сопрограммам, с поддержкой ОС.

Я не знаком с другими ОС, чтобы рекомендовать там альтернативы.

В POSIX вы можете использовать процедуры makecontext () / swapcontext () для переносимого переключения контекстов выполнения. В Windows вы можете использовать Fibre API. В противном случае все, что вам нужно, - это немного связующего кода сборки, который переключает контекст машины. Я реализовал сопрограммы как с ASM (для AMD64), так и с swapcontext (); ни то, ни другое не очень сложно.

WvCont - это часть WvStreams, которая реализует так называемые полукорутины. С ними немного проще работать, чем с полноценными сопрограммами: вы вызываете их, и они возвращаются тому, кто их вызвал.

Это реализовано с использованием более гибкого WvTask, который поддерживает полноценные сопрограммы; вы можете найти его в той же библиотеке.

По крайней мере, работает на win32 и Linux и, вероятно, на любой другой системе Unix.

Он основан на макросах (cringe), но следующий сайт предоставляет простую в использовании реализацию генератора: http://www.codeproject.com/KB/cpp/cpp_generators.aspx

Для потомков,

замечательный веб-сайт Дмитрия Вьюкова имеет хитрый трюк с использованием ucontext и setjump для моделирования сопрограмм на C++.

Кроме того, контекстная библиотека Оливера Ковалька была недавно принято в Boost, поэтому, надеюсь, скоро мы увидим обновленную версию boost.coroutine, которая работает на x86_64.

Я сам пробовал реализовать сопрограммы, используя C++ 11 и потоки:

#include <iostream>
#include <thread>

class InterruptedException : public std::exception {
};

class AsyncThread {
public:
    AsyncThread() {
        std::unique_lock<std::mutex> lock(mutex);
        thread.reset(new std::thread(std::bind(&AsyncThread::run, this)));
        conditionVar.wait(lock); // wait for the thread to start
    }
    ~AsyncThread() {
        {
            std::lock_guard<std::mutex> _(mutex);
            quit = true;
        }
        conditionVar.notify_all();
        thread->join();
    }
    void run() {
        try {
            yield();
            for (int i = 0; i < 7; ++i) {
                std::cout << i << std::endl;
                yield();
            }
        } catch (InterruptedException& e) {
            return;
        }
        std::lock_guard<std::mutex> lock(mutex);
        quit = true;
        conditionVar.notify_all();
    }
    void yield() {
        std::unique_lock<std::mutex> lock(mutex);
        conditionVar.notify_all();
        conditionVar.wait(lock);
        if (quit) {
            throw InterruptedException();
        }
    }
    void step() {
        std::unique_lock<std::mutex> lock(mutex);
        if (!quit) {
            conditionVar.notify_all();
            conditionVar.wait(lock);
        }
    }
private:
    std::unique_ptr<std::thread> thread;
    std::condition_variable conditionVar;
    std::mutex mutex;
    bool quit = false;
};

int main() {
    AsyncThread asyncThread;
    for (int i = 0; i < 3; ++i) {
        std::cout << "main: " << i << std::endl;
        asyncThread.step();
    }
}

Сегодня была выпущена новая библиотека Boost.Context с переносимыми функциями для реализации сопрограмм.

Нет простого способа реализовать сопрограмму. Поскольку сама сопрограмма находится вне абстракции стека C / C++, как и поток. Таким образом, он не может поддерживаться без изменения уровня языка для поддержки.

В настоящее время (C++ 11) все существующие реализации сопрограмм C++ основаны на взломе на уровне сборки, что трудно обеспечить безопасным и надежным переходом между платформами. Чтобы быть надежным, он должен быть стандартным и обрабатываться компиляторами, а не взломом.

Для этого есть стандартное предложение - N3708. Проверьте это, если вам интересно.

Я придумал код реализации без асм. Идея состоит в том, чтобы использовать функцию создания системного потока для инициализации стека и контекста и использовать setjmp / longjmp для переключения контекста. Но он не переносится, см. сложная версия pthread, если вам интересно.

Это старый поток, но я хотел бы предложить взломать устройство Даффа, которое не зависит от ОС (насколько я помню):

C-сопрограммы, использующие устройство Даффа

И в качестве примера вот библиотека telnet, которую я модифицировал, чтобы использовать сопрограммы вместо вилок / потоков: Библиотека telnet cli с использованием сопрограмм

И поскольку стандартный C до C99, по сути, является истинным подмножеством C++, это хорошо работает и в C++.

Для тех, кто хочет знать, как они могут переносить сопрограммы на C++ y̶o̶u̶ ̶w̶i̶l̶l̶ ̶h̶a̶v̶e̶ ̶t̶o̶ ̶w̶a̶i̶t̶ ̶f̶o̶r̶ ̶C̶ + ̶ + ̶1̶7̶, ожидание окончено (см. Ниже)! Комитет по стандартам работает над этой функцией, см. Бумага N3722. Подводя итог текущему черновику документа, вместо Async и Await ключевые слова будут возобновлены и await.

Взгляните на экспериментальную реализацию в Visual Studio 2015, чтобы поиграть с экспериментальной реализацией Microsoft. Не похоже, что у clang еще есть реализация.

Cppcon Сопрограммы с отрицательной абстракцией накладных расходов рассказал о преимуществах использования сопрограмм в C++ и о том, как это влияет на простоту и производительность кода.

В настоящее время мы все еще должны использовать реализации библиотек, но в ближайшем будущем у нас будут сопрограммы в качестве основной функции C++.

Обновлять: Похоже, реализация сопрограммы намечена для C++ 20, но была выпущена в виде технической спецификации с C++ 17 (p0057r2). Visual C++, clang и gcc позволяют выбрать использование флага времени компиляции.

https://github.com/tonbit/coroutine - это реализация одиночной асимметричной сопрограммы .h C++ 11, поддерживающая примитивы возобновления / выхода / ожидания и модель канала. Он реализуется через ucontext / fiber, независимо от ускорения, на linux / windows / macOS. Это хорошая отправная точка для изучения реализации сопрограмм на C++.

Посмотрите мою реализацию, она иллюстрирует точку взлома asm и проста:

https://github.com/user1095108/generic/blob/master/coroutine.hpp

Также на основе макросов (устройство Даффа, полностью портативное, см. http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html ) и вдохновленный ссылкой, опубликованной Марком, следующее эмулирует совместные процессы, взаимодействующие с использованием событий в качестве механизма синхронизации (модель немного отличается от традиционных совместных подпрограмм / стиля генератора)

// Coprocess.h
#pragma once
#include <vector>

class Coprocess {
  public:
    Coprocess() : line_(0) {}
    void start() { line_ =  0; run(); }
    void end()   { line_ = -1; on_end(); }
    virtual void run() = 0;
    virtual void on_end() {}; 
  protected:
    int line_;
};

class Event {
  public:
    Event() : curr_(0) {}

    void wait(Coprocess* p) { waiters_[curr_].push_back(p); }

    void notify() {
        Waiters& old = waiters_[curr_];
        curr_ = 1 - curr_; // move to next ping/pong set of waiters
        waiters_[curr_].clear();
        for (Waiters::const_iterator I=old.begin(), E=old.end(); I != E; ++I)
            (*I)->run();
    }   
  private:
    typedef std::vector<Coprocess*> Waiters;
    int curr_;
    Waiters waiters_[2];
};

#define corun()   run() { switch(line_) { case 0:
#define cowait(e) line_=__LINE__; e.wait(this); return; case __LINE__:
#define coend     default:; }} void on_end()

Пример использования:

// main.cpp
#include "Coprocess.h"
#include <iostream>

Event e;
long sum=0;

struct Fa : public Coprocess {
    int n, i;
    Fa(int x=1) : n(x) {}
    void corun() {
        std::cout << i << " starts\n";
        for (i=0; ; i+=n) {
            cowait(e);
            sum += i;
        }
    } coend {
        std::cout << n << " ended " << i << std::endl;
    }   
};

int main() {
    // create 2 collaborating processes
    Fa f1(5);
    Fa f2(10);

    // start them
    f1.start();
    f2.start();
    for (int k=0; k<=100; k++) { 
        e.notify();
    }   
    // optional (only if need to restart them)
    f1.end();
    f2.end();

    f1.start(); // coprocesses can be restarted
    std::cout << "sum " << sum << "\n";
    return 0;
}