Блог

следующая программа тестирования:

 #include <coroutine>
#include <iostream>
#include <optional>

//#define FIX1
//#define FIX2
//#define FIX3


struct final_awaiter
{
    std::coroutine_handle<> continuation;

    bool await_ready() const noexcept { return false; }

    std::coroutine_handle<> await_suspend(std::coroutine_handle<> h) const noexcept
    {
        std::cout << "resuming continuation=" << continuation.address() << std::endl;
        return continuation ? continuation : std::noop_coroutine();
    }

    void await_resume() const noexcept {}
};


struct schedule
{};

// test...
std::coroutine_handle<> inner_coro;

struct schedule_awaiter
{
    bool await_ready() const noexcept { return false; }

    void await_suspend(std::coroutine_handle<> h) const noexcept
    {
        std::cout << "'scheduling' inner_coro h=" << h.address() << std::endl;
        inner_coro = h;
    }
    void await_resume() const noexcept { std::cout << "schedule resumed " << std::endl; }
};


template<typename PromiseType>
struct task_awaiter
{
    std::coroutine_handle<PromiseType> handle;

    bool await_ready() const noexcept
    {
        const bool ready = handle.promise().value.has_value();

        std::cout << "[task, h=" << handle.address()
                  << "] await_ready(), value=" << handle.promise().value.value_or(-1)
                  << ", ready=" << (ready ? "YES <<<<< ????? " : "no") << std::endl;
        return ready;
    }

    void await_suspend(std::coroutine_handle<> h) const noexcept
    {
        std::cout << "[task, h=" << handle.address()
                  << "] await_suspend(), saving continuation=" << h.address() << std::endl;
        handle.promise().continuation = h;
    }

    auto await_resume() const noexcept
    {
        std::cout << "[task, h=" << handle.address()
                  << "] await_resume(), returnnig value == " << *handle.promise().value
                  << std::endl;
        return std::move(*(handle.promise().value));
    }
};


struct task
{
    struct promise_type
    {
#ifdef FIX1
        std::coroutine_handle<> continuation; // works (1)
        std::optional<int> value;
#else
        std::optional<int> value;
        std::coroutine_handle<> continuation; // segfaults (1)
#endif

#ifdef FIX3
        promise_type() = defau<
        explicit promise_type(int) {} // works (3)
#endif

        task get_return_object()
        {
            return task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }

        std::suspend_never initial_suspend() const noexcept { return {}; }

        auto final_suspend() const noexcept { return final_awaiter{continuation}; }

        void return_value(int val) noexcept
        {
            std::cout << "return_value, val=" << val << std::endl;
            value = val;
        }

        [[noreturn]] void unhandled_exception() { std::terminate(); }

        // await schedule
        auto await_transform(schedule) const noexcept { return schedule_awaiter{}; }

        // await task
        auto await_transform(const taskamp; t) const noexcept
        {
            return task_awaiter{t.handle};
        }
    };


    explicit task(std::coroutine_handle<promise_type> handle)
        : handle(handle)
    {}

    task(taskamp;amp; other) noexcept
        : handle(std::exchange(other.handle, nullptr))
    {}

    ~task()
    {
        std::cout << "~task, h=" << handle.address() << std::endl;
        if (handle) { handle.destroy(); }
    }

    int get() const
    {
        if (handle) { return *handle.promise().value; }
        throw std::logic_error("get(): moved from task");
    }

    std::coroutine_handle<promise_type> handle;
};


// ---

#ifdef FIX2
task inner() // works (2)
#else
task inner(int r) // segfaults (2)
#endif
{
    std::cout << ">> inner 1" << std::endl;
    co_await schedule{};
    std::cout << ">> inner 2" << std::endl;
    co_return 10; // co_return r;
}


task outer()
{
    std::cout << "> outer 1" << std::endl;

#ifdef FIX2
    auto t = inner(); // works (2)
#else
    auto t = inner(5); // segfaults (2)
#endif

    std::cout << "> outer 2" << std::endl;
    auto r = co_await t;
    std::cout << "> outer 3" << std::endl;
    co_return r;
}


int main()
{
    auto result = outer();

    std::cout << "...manually resuming h=" << inner_coro.address() << std::endl;
    inner_coro.resume();

    std::cout << "result = " << result.get() << std::endl;
}
 

работает, как и ожидалось, в MSVC:

 > outer 1
>> inner 1
'scheduling' inner_coro h=000001A5F5DF1DD0
> outer 2
[task, h=000001A5F5DF1DD0] await_ready(), value=-1, ready=no
[task, h=000001A5F5DF1DD0] await_suspend(), saving continuation=000001A5F5DF0C40
...manually resuming h=000001A5F5DF1DD0
schedule resumed
>> inner 2
return_value, val=10
resuming continuation=000001A5F5DF0C40
[task, h=000001A5F5DF1DD0] await_resume(), returnnig value == 10
> outer 3
return_value, val=10
~task, h=000001A5F5DF1DD0
resuming continuation=0000000000000000
result = 10
~task, h=000001A5F5DF0C40
 

но segfaults в gcc (godbolt):

 > outer 1
>> inner 1
'scheduling' inner_coro h=0x18c354e1770
> outer 2
[task, h=0x18c354e1770] await_ready(), value=5, ready=YES <<<<< ?????
[task, h=0x18c354e1770] await_resume(), returnnig value == 5
> outer 3
return_value, val=5
~task, h=0x18c354e1770
resuming continuation=0
...manually resuming h=0x18c354e1770
Segmentation fault
 

Похоже, что task::promise_type::value это перезаписывается inner() аргументом ‘s ( 5 ), поэтому «внутренняя» сопрограмма не приостанавливается, как ожидалось, а завершается/уничтожается, а затем происходит segfault после (ручного) resume() вызова. Есть ли какая-то ошибка в программе или это ошибка gcc?

Раскомментируйте FIX1 FIX2 или FIX3 «исправьте» segfault…