C++20 coroutines (co_await)
От: okman Беларусь https://searchinform.ru/
Дата: 06.01.21 20:34
Оценка: 4 (2)
Всем привет!

Изучаю C++20. В целом все понятно, но одна вещь вызывает наибольшие затруднения — корутины.

Насколько я понял, в C++20 появился некий интерфейс, реализуя который, разработчик может обеспечить нужное ему
поведение, вплоть до низкоуровневых деталей, таких как выполнение задачи в отдельном потоке (например, в Windows
это можно сделать с помощью CreateThreadpoolWork/SubmitThreadpoolWork). Готовую библиотечную реализацию корутин,
как выясняется, не "завезли" (ждите C++23). Я прав?

Ну и тогда главный вопрос: где можно найти более-менее полноценное и толковое описание этого интерфейса?

Я пока плохо понимаю, как связаны task, promise и awaiter, чем отличаются "обычная" корутина и noop-coroutine,
куда конкретно нужно вставлять вызовы co_await/co_yield/co_return. А ведь там еще есть "загадочные" operator
co_await, await_transform, coroutine_handle, разделение на stackfull и stackless...

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

  Скрытый текст
#include <coroutine>
#include <utility>
#include <iostream>
 
template<class T>
struct task {
    struct promise_type {
        auto get_return_object() {
            return task(std::coroutine_handle<promise_type>::from_promise(*this));
        }
        std::suspend_always initial_suspend() { return {}; }
        struct final_awaiter {
            bool await_ready() noexcept { return false; }
            void await_resume() noexcept {}
            std::coroutine_handle<> await_suspend(std::coroutine_handle<promise_type> h) noexcept {
                // final_awaiter::await_suspend is called when the execution of the
                // current coroutine (referred to by 'h') is about to finish.
                // If the current coroutine was resumed by another coroutine via
                // co_await get_task(), a handle to that coroutine has been stored
                // as h.promise().previous. In that case, return the handle to resume
                // the previous coroutine.
                // Otherwise, return noop_coroutine(), whose resumption does nothing.
 
                auto previous = h.promise().previous;
                if (previous) {
                    return previous;
                } else {
                    return std::noop_coroutine();
                }
            }
        };
        final_awaiter final_suspend() noexcept { return {}; }
        void unhandled_exception() { throw; }
        void return_value(T value) { result = std::move(value); }
        T result;
        std::coroutine_handle<> previous;
    };
 
    task(std::coroutine_handle<promise_type> h) : coro(h) {}
    task(task&& t) = delete;
    ~task() { coro.destroy(); }
 
    struct awaiter {
        bool await_ready() { return false; }
        T await_resume() { return std::move(coro.promise().result); }
        auto await_suspend(std::coroutine_handle<> h) {
            coro.promise().previous = h;
            return coro;
        }
        std::coroutine_handle<promise_type> coro;
    };
    awaiter operator co_await() { return awaiter{coro}; }
    T operator()() {
        coro.resume();
        return std::move(coro.promise().result);
    }
private:
    std::coroutine_handle<promise_type> coro;
};
 
task<int> get_random() {
    std::cout << "in get_random()\n";
    co_return 4;
}
task<int> test() {
    task<int> v = get_random();
    task<int> u = get_random();
    std::cout << "in test()\n";
    int x = (co_await v + co_await u);
    co_return x;
}
 
int main() {
    task<int> t = test();
    int result = t();
    std::cout << result << '\n';
}



Пробовал вникать в примеры на en.cppreference.com, смотрел как устроены асинхронные вызовы в C++/WinRT, был на Хабре,
на MSDN, на MSVC Team Blog, смотрел исходники библиотеки cppcoro, но ясности не прибавилось.

> "Фреймворк для написания корутин состоит из более чем 20 функций которые частично нужно реализовать, а

> частично могут быть переписаны (Хабр, "Корутины в C++20. Часть 1").

Что это за функции? Где про это почитать подробнее? И т.д.


Ссылки ниже, вдруг кому-то пригодится:

Standard library header <coroutine>
https://en.cppreference.com/w/cpp/header/coroutine

C++ Coroutines in Visual Studio 2019 Version 16.8
https://devblogs.microsoft.com/cppblog/c-coroutines-in-visual-studio-2019-version-16-8/

lewissbaker/cppcoro
https://github.com/lewissbaker/cppcoro

C++20. Coroutines
https://habr.com/ru/post/519464/
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.