Что вызывает этот код `Ошибка сегментации` после вызова сопрограммы` promise_type :: return_value () `?

Question

Обновлено

Segmentation fault было вызвано попыткой .get() на недопустимом std::future. Однако сопрограммы еще не совсем работают.

---

[ 1010 * godbolt *]
[ wandbox ]

У меня есть такой тип ожидания:

template<typename T>
struct awaitable
{
  awaitable() = default;
  awaitable(awaitable&& other) : val(std::move(other.val) ) { }
  awaitable(std::future<T>&& other_f) : val(std::move(other_f ) ) { }
  bool await_ready() { return true; }
  void await_suspend(std::experimental::coroutine_handle<> h) { h.resume(); }
  T await_resume() { return val.get(); }
private:
  std::future<T> val;
};

специализировать тип обещания coroutine_traits, как это

template<typename T, typename ...Args>
struct std::experimental::coroutine_traits<awaitable<T>, Args...>
{
  struct promise_type {
    suspend_never  initial_suspend()      { return {}; }
    suspend_never  final_suspend()        { return {}; }
    void           unhandled_exception()  { std::terminate(); }
    awaitable<T>   get_return_object()    { return std::move(f); }
    T              return_value(T r)      { 
      if constexpr (_DEBUG) std::cout << "About to return_value(" << r << ')' << std::endl;
      return r; }
  private:
    awaitable<T>   f;
  };
};

есть несколько ожидающих

awaitable<int> async_add(int a, int b) {
  auto fut = std::async([=]() {
    int c = a + b;
    return c;
  });

  return std::move(fut);
}

awaitable<int> async_fib(int n)
{
  if (n <= 2)
      co_return 1;

  int a = 1, b = 1;

  // iterate computing fib(n)
  for (int i = 0; i < n - 2; ++i)
  {
    int c = co_await async_add(a, b);
    if constexpr (_DEBUG) {
      std::cout << 
        "After co_await async_add(" << std::setw(3) << a << 
        ","    << std::setw(3) << b << ")\t"
        "i = " << i << "\t"
        "c = " << c << "\t"
        "[ fib(" << i + 3 << ") ]" << std::endl;
    }
    a = b;
    b = c;
  }

  co_return b;
}

Когда я пытался получить значение:

int main()
{
  std::string str;
  std::getline(std::cin, str);
  awaitable<int> continua_v = async_fib(std::stoi(str) );
  if constexpr (_DEBUG) std::cout << "About to retrieve value..." << std::endl;
  int result = continua_v.await_resume();
  if constexpr (_DEBUG) std::cout << "Retrieving has succeeded : " << result << std::endl;
  return result;

}

Произошла ошибка сегментации

Start

After co_await async_add(  1,  1)   i = 0   c = 2   [ fib(3) ]
After co_await async_add(  1,  2)   i = 1   c = 3   [ fib(4) ]
After co_await async_add(  2,  3)   i = 2   c = 5   [ fib(5) ]
After co_await async_add(  3,  5)   i = 3   c = 8   [ fib(6) ]
After co_await async_add(  5,  8)   i = 4   c = 13  [ fib(7) ]
After co_await async_add(  8, 13)   i = 5   c = 21  [ fib(8) ]
After co_await async_add( 13, 21)   i = 6   c = 34  [ fib(9) ]
After co_await async_add( 21, 34)   i = 7   c = 55  [ fib(10) ]
About to return_value(55)
About to retrieve value...

Segmentation fault

Почему происходит сбой при получении значения?
Как мне это исправить?

[ godbolt ]
[ wandbox ]

---

Обновлено

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * .get() *] * * * * * * * * * * * * * * 1045 Это можно измерить с помощью предварительной проверки.

  T await_resume() { 
    if (val.valid()) {
      if constexpr (_DEBUG) std::cout << "About to val.get()..." << std::endl;
       t_val = val.get();
      if constexpr (_DEBUG) std::cout << "val.get() : " << t_val << std::endl;
    }
    return t_val; }

К сожалению, похоже на линию

awaitable<int> continua_v = async_fib(std::stoi(str) );

continua_v почему-то всегда получает значение по умолчанию awaitable<int>, что нежелательно.

Start

About to val.get()...
val.get() : 2
After co_await async_add(  1,  1)   i = 0   c = 2   [ fib(3) ]
About to val.get()...
val.get() : 3
After co_await async_add(  1,  2)   i = 1   c = 3   [ fib(4) ]
About to val.get()...
val.get() : 5
After co_await async_add(  2,  3)   i = 2   c = 5   [ fib(5) ]
About to val.get()...
val.get() : 8
After co_await async_add(  3,  5)   i = 3   c = 8   [ fib(6) ]
About to val.get()...
val.get() : 13
After co_await async_add(  5,  8)   i = 4   c = 13  [ fib(7) ]
About to val.get()...
val.get() : 21
After co_await async_add(  8, 13)   i = 5   c = 21  [ fib(8) ]
About to val.get()...
val.get() : 34
After co_await async_add( 13, 21)   i = 6   c = 34  [ fib(9) ]
About to val.get()...
val.get() : 55
After co_await async_add( 21, 34)   i = 7   c = 55  [ fib(10) ]
About to return_value(55)
About to retrieve value...
Retrieving has succeeded : -1

255

[ godbolt ]
[ wandbox ]

Answer 1

Я думаю, что отсутствие интереса к этому вопросу в основном потому, что сопрограммы настолько новы (даже технически не стандартизированы на данный момент). Это интересная тема, хотя. Мне пришлось немного покопаться, но я обнаружил, этот доклад с CppCon 2016 был очень полезным, а также этот черновик стандарта сопрограмм .

Правильно разбираясь в проблеме: я думаю, что вы (и я тоже до того, как провести какое-то исследование) немного озадачены тем, как предполагается писать сопрограммы, что, к сожалению, требует большого понимания того, как язык C ++ реализует их под капотом. Например, сопрограммы должны контролироваться (включая возобновление) через дескриптор, но вы нигде не хранили дескриптор.

Кроме того, вам, вероятно, не следует использовать std::future или std::async (и просто к сведению, что использование std::async без std::launch::async в значительной степени бесполезно). Эти типы сложны в использовании сами по себе и не способствуют написанию сопрограмм в C ++ 20. Например, в моем тестировании я обнаружил, что ошибка произошла из-за того, что экземпляр std::future недействителен в точке доступа.

Вот фиксированный код, который вы предоставили (без лишних деталей). Здесь есть комментарии ко всем важным вещам, чтобы сказать, что происходит, где и почему. Я решил вкладывать все прямо в awaitable, чтобы он был чище и легче для чтения, но это также можно сделать с помощью coroutine_traits.

Примечание: я написал / протестировал это в VisualStudio 2017 с последним стандартным черновиком и флагом компиляции /await.

#include <iostream>
#include <utility>
#include <experimental/coroutine>

template<typename T>
class awaitable
{
public: // -- promise type -- //

    // declare the promise type and alias the handle type
    struct promise_type;
    typedef std::experimental::coroutine_handle<promise_type> handle;

    struct promise_type
    {
        T ret_val; // storage location for the return value

        // we need to provide a way to convert a promise into the awaitable object (via the handle)
        awaitable get_return_object() { return awaitable { handle::from_promise(*this) }; }

        // we won't suspend upon starting - we want to start immediately
        auto initial_suspend() { return std::experimental::suspend_never{}; }
        // we need to buffer the return value, so we need to suspend at the end of the coroutine.
        // if we didn't do this the coroutine object could be destroyed and we'd access undefined memory.
        auto final_suspend() { return std::experimental::suspend_always{}; }

        // this is called when the coroutine body uses co_return expr
        // where expr is not cv-qualified void (otherwise return_void() is used).
        // the current coroutine standard draft dictates this MUST return void.
        template<typename U>
        void return_value(U &&v) { ret_val = std::forward<U>(v); }

        // this is called if an exception is thrown in the coroutine.
        // immediately after this, the final suspend is performed (so the coroutine will be done() after this).
        void unhandled_exception()
        {
            // we can either terminate() (i.e. we do not allow/expect exeptions)
            // or we could store and rethrow the exception later (i.e. std::exception_ptr).
            // i'll use the terminate() option since that's what you used.
            std::terminate();
        }
    };

public: // -- non-coroutine support -- //

    // we provide a method to get the value - note that this method is not a coroutine.
    // if we didn't provide this, we couldn't use it in e.g. main() because main() cannot be a coroutine.
    T get()
    {
        while (!co.done()) co.resume(); // resume the coroutine until it's done (at final suspend)
        return co.promise().ret_val;    // then get its value (via copy to allow calling get() multiple times)
    }

public: // -- coroutine support -- //

    bool await_ready() { return co.done(); } // are we already done?
    T    await_resume() { return get(); }    // when await is resumed, we need to block and get the value

    // no special suspend logic - defaults are good.
    // this takes generic coroutine_handle<> rather than handle to be generic.
    // coroutine_handle<> is the same as coroutine_handle<void>.
    // it can kind of be though of like a void* to a coroutine of any type.
    // i.e. we can suspend this coroutine to co_await a coroutine of any type.
    void await_suspend(std::experimental::coroutine_handle<>) {}

public: // -- data -- //

    // we need to store a handle for the coroutine
    handle co = nullptr;

public: // -- ctor / dtor / asgn -- //

    // we can make an awaitable type from a (coroutine) handle
    explicit awaitable(handle h) : co(h) {}

    // in dtor, we need to destroy the coroutine if it's still valid
    ~awaitable() { if (co) co.destroy(); }

    // we can also make an empty awaitable
    awaitable() = default;

    // we can't copy an awaitable
    awaitable(const awaitable&) = delete;
    awaitable &operator=(const awaitable&) = delete;

    // but we can move from one
    awaitable(awaitable &&other) : co(std::exchange(other.co, nullptr)) {}
    awaitable &operator=(awaitable &&other) { co = std::exchange(other.co, nullptr); return *this; }
};

awaitable<int> async_add(int a, int b) { co_return a + b; }

awaitable<int> async_fib(int n)
{
    if (n <= 2) co_return 1;

    int a = 1, b = 1;

    for (int i = 0; i < n - 2; ++i)
    {
        int c = co_await async_add(a, b); // we're a coroutine, so we can co_await the result of async_add
        a = b;
        b = c;
    }

    co_return b;
}

int main()
{
    // we're NOT a coroutine, so we can't suspend and do other things - use .get() rather than co_await
    std::cerr << async_fib(8).get() << '\n';

    return 0;
}