如何解决c++协程连续循环导致堆栈溢出
我在循环中的协程内的 Visual Studio 中遇到堆栈溢出异常,并发现该循环有一个阻止它终止的错误,但我想知道为什么堆栈溢出?协程甚至可能不使用堆栈而是使用堆,即使使用堆栈也根本没有任何递归调用
经过一些实验,我可以重现崩溃:
- msvc 19.28
- wsl 和 mingw64 上的 g++-10
- windows 上的 clang-cl 10 和 linux 上的 clang++-10
这段代码导致堆栈溢出:
#include <stdexcept>
#include <utility>
#include <cstdio>
#ifdef __clang__
#ifdef _WIN32
#pragma message "using clang coroutine header"
#include "clang-cl-coro.h"
#else
#pragma message "using coroutine experimental header"
#include <experimental/coroutine>
#endif
namespace std
{
template<class P = void>
using coroutine_handle = experimental::coroutine_handle<P>;
using suspend_never = experimental::suspend_never;
using suspend_always = experimental::suspend_always;
}
#else
#pragma message "using coroutine header"
#include <coroutine>
#endif
class vtask
{
inline static size_t task_count = 0;
public:
struct promise_type
{
inline static size_t promise_count = 0;
std::coroutine_handle<> waiter;
std::exception_ptr ex_ptr = nullptr;
struct resume_waiter
{
inline static size_t awaiter_count = 0;
std::coroutine_handle<> waiter;
resume_waiter(std::coroutine_handle<> waiter) noexcept : waiter{ waiter }
{
++awaiter_count;
printf("[%zu] resume_waiter(std::coroutine_handle<> waiter)\n",awaiter_count);
}
~resume_waiter()
{
--awaiter_count;
printf("[%zu] ~resume_waiter()\n",awaiter_count);
}
bool await_ready() const noexcept { return false; }
auto await_suspend(std::coroutine_handle<>) noexcept
{
return waiter;
}
void await_resume() const noexcept {}
};
promise_type()
{
++promise_count;
printf("[%zu] vtask::promise_type()\n",promise_count);
}
~promise_type()
{
--promise_count;
printf("[%zu] ~vtask::promise_type()\n",promise_count);
}
vtask get_return_object() { return { *this }; }
constexpr std::suspend_always initial_suspend() noexcept { return {}; }
resume_waiter final_suspend() const noexcept { return { waiter }; }
void unhandled_exception() noexcept
{
ex_ptr = std::current_exception();
}
void return_void() const noexcept {}
};
vtask(promise_type& p) : coro{ std::coroutine_handle<promise_type>::from_promise(p) }
{
++task_count;
printf("[%zu] vtask(promise_type& p)\n",task_count);
}
vtask(vtask&& other) noexcept : coro{ std::exchange(other.coro,nullptr) }
{
++task_count;
printf("[%zu] vtask(vtask&& other)\n",task_count);
}
~vtask()
{
if (coro)
coro.destroy();
--task_count;
printf("[%zu] ~vtask()\n",task_count);
}
bool await_ready() const noexcept
{
return false;
}
void await_suspend(std::coroutine_handle<> waiter)
{
coro.promise().waiter = waiter;
coro.resume();
}
void await_resume() noexcept {}
private:
std::coroutine_handle<promise_type> coro;
};
struct detached_task
{
struct promise_type
{
inline static size_t promise_count = 0;
promise_type()
{
++promise_count;
printf("[%zu] detached_task::promise_type()\n",promise_count);
}
~promise_type()
{
--promise_count;
printf("[%zu] ~detached_task::promise_type()\n",promise_count);
}
detached_task get_return_object() { return {}; }
std::suspend_never initial_suspend() noexcept { return {}; }
std::suspend_never final_suspend() noexcept { return {}; }
void unhandled_exception() noexcept
{
std::terminate();
}
constexpr void return_void() const noexcept {}
};
inline static size_t task_count = 0;
detached_task()
{
++task_count;
printf("[%zu] detached_task()\n",task_count);
}
~detached_task()
{
--task_count;
printf("[%zu] ~detached_task()\n",task_count);
}
};
vtask do_stackoverflow() { co_return; }
detached_task stackoverflow()
{
for (;;)
co_await do_stackoverflow();
}
int main()
{
stackoverflow();
}
使用的命令行:
cl /std:c++latest coro-stackoverflow.cpp /EHsc
用于 msvc
g++ -std=c++20 coro-stackoverflow.cpp -fcoroutines
用于 mingw64
clang-cl /std:c++latest coro-stackoverflow.cpp /EHsc
g++-10 -std=c++20 coro-stackoverflow.cpp -fcoroutines -o overflow.bug
在 wsl 上
clang++-10 -std=c++20 -stdlib=libc++ coro-stackoverflow.cpp -o overflow-clang.bug
在 wsl 上
这是 windows 上的 clang coro 标题:
#pragma once
namespace std { namespace experimental { inline namespace coroutines_v1 {
template <typename R,typename...> struct coroutine_traits {
using promise_type = typename R::promise_type;
};
template <typename Promise = void> struct coroutine_handle;
template <> struct coroutine_handle<void> {
static coroutine_handle from_address(void *addr) noexcept {
coroutine_handle me;
me.ptr = addr;
return me;
}
void operator()() { resume(); }
void *address() const { return ptr; }
void resume() const { __builtin_coro_resume(ptr); }
void destroy() const { __builtin_coro_destroy(ptr); }
bool done() const { return __builtin_coro_done(ptr); }
coroutine_handle &operator=(decltype(nullptr)) {
ptr = nullptr;
return *this;
}
coroutine_handle(decltype(nullptr)) : ptr(nullptr) {}
coroutine_handle() : ptr(nullptr) {}
// void reset() { ptr = nullptr; } // add to P0057?
explicit operator bool() const { return ptr; }
protected:
void *ptr;
};
template <typename Promise> struct coroutine_handle : coroutine_handle<> {
using coroutine_handle<>::operator=;
static coroutine_handle from_address(void *addr) noexcept {
coroutine_handle me;
me.ptr = addr;
return me;
}
Promise &promise() const {
return *reinterpret_cast<Promise *>(
__builtin_coro_promise(ptr,alignof(Promise),false));
}
static coroutine_handle from_promise(Promise &promise) {
coroutine_handle p;
p.ptr = __builtin_coro_promise(&promise,true);
return p;
}
};
template <typename _PromiseT>
bool operator==(coroutine_handle<_PromiseT> const& _Left,coroutine_handle<_PromiseT> const& _Right) noexcept
{
return _Left.address() == _Right.address();
}
template <typename _PromiseT>
bool operator!=(coroutine_handle<_PromiseT> const& _Left,coroutine_handle<_PromiseT> const& _Right) noexcept
{
return !(_Left == _Right);
}
template <typename _PromiseT>
bool operator==(coroutine_handle<_PromiseT> const& _Left,std::nullptr_t) noexcept
{
return _Left.address() == nullptr;
}
template <typename _PromiseT>
bool operator==(std::nullptr_t,coroutine_handle<_PromiseT> const& _Right) noexcept
{
return _Right.address() == nullptr;
}
template <typename _PromiseT>
bool operator!=(coroutine_handle<_PromiseT> const& _Left,std::nullptr_t) noexcept
{
return !(_Left == nullptr);
}
template <typename _PromiseT>
bool operator!=(std::nullptr_t,coroutine_handle<_PromiseT> const& _Right) noexcept
{
return _Right.address() != nullptr;
}
struct suspend_always {
bool await_ready() { return false; }
void await_suspend(coroutine_handle<>) {}
void await_resume() {}
};
struct suspend_never {
bool await_ready() { return true; }
void await_suspend(coroutine_handle<>) {}
void await_resume() {}
};
}}}
在 Windows 上,msvc 和 clang-cl 构建崩溃较早发生,但 mingw64 和 wsl 构建需要更多时间
我使用的 gcc 10.1 似乎有一个已知的错误,其中任务被构造两次但销毁一次,每次迭代都会泄漏任务,这似乎导致溢出
但是 clang 和 msvc 没有这个错误,它们也会崩溃!
编辑:尝试了 gcc 10.3 mingw64,它没有提到的 gcc 错误,但它也会导致堆栈溢出!被窃听的编译器甚至更快!也许这种行为是预期的?
我不知道上面的代码有什么问题
解决方法
问题出在这部分代码中:
void await_suspend(std::coroutine_handle<> waiter)
{
coro.promise().waiter = waiter;
coro.resume();
}
这种非对称传输导致stackoverflow并将代码更改为:
auto await_suspend(std::coroutine_handle<> waiter)
{
coro.promise().waiter = waiter;
return coro;
}
消除了 clang 和 msvc 上的问题,但 gcc 10.3 仍然崩溃,我认为它还不支持对称传输
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。