Merge pull request #1 from codeinred/exceptions

Coroutines now rethrow exceptions

Author: codeinred

CMakeLists.txt

@@ -16,8 +16,15 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CONDUIT_TARGET_NAME ${PROJECT_NAME})
 set(CONDUIT_INCLUDE_BUILD_DIR "${PROJECT_SOURCE_DIR}/include/")
 
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
 add_executable(run_tests main.cpp)
 
+target_link_libraries(run_tests PRIVATE Threads::Threads)
+
+
+
 add_library(${CONDUIT_TARGET_NAME} INTERFACE)
 
 target_compile_definitions(

include/conduit/continuation.hpp

@@ -5,7 +5,7 @@
 namespace conduit::promise {
 template <class Alloc>
 struct continuation : mixin::GetReturnObject<continuation<Alloc>, false>,
-                      mixin::UnhandledException<true>,
+                      mixin::UnhandledException<continuation<Alloc>>,
                       mixin::InitialSuspend<mixin::always>,
                       mixin::FinalSuspend<mixin::never>,
                       mixin::ReturnVoid,

include/conduit/coroutine.hpp

@@ -15,7 +15,7 @@ namespace conduit::promise {
 // and can't be resumed or checked for being done
 struct coroutine : mixin::InitialSuspend<false>,
                    mixin::FinalSuspend<false>,
-                   mixin::UnhandledException<>,
+                   mixin::UnhandledException<coroutine>,
                    mixin::ReturnVoid {
 
     auto get_return_object() noexcept { return conduit::coroutine{}; }

include/conduit/future.hpp

@@ -8,7 +8,7 @@ namespace conduit::promise {
 template <class ReturnValue>
 struct future : mixin::GetReturnObject<future<ReturnValue>>,
                 mixin::HasOwnerAndCallback,
-                mixin::UnhandledException<true> {
+                mixin::UnhandledException<future<ReturnValue>> {
     std::optional<ReturnValue> result;
     void return_value(ReturnValue const& r) { result.emplace(r); }
     void return_value(ReturnValue&& r) { result.emplace(std::move(r)); }
@@ -19,7 +19,7 @@ struct future : mixin::GetReturnObject<future<ReturnValue>>,
 template <class ReturnValue>
 struct optional_future : mixin::GetReturnObject<optional_future<ReturnValue>>,
                          mixin::HasOwnerAndCallback,
-                         mixin::UnhandledException<true> {
+                         mixin::UnhandledException<optional_future<ReturnValue>> {
     std::optional<ReturnValue> result;
 
     void return_value(ReturnValue const& r) { result.emplace(r); }

include/conduit/generator.hpp

@@ -8,7 +8,7 @@ template <class T>
 struct generator : mixin::GetReturnObject<generator<T>>,
                    mixin::InitialSuspend<false>,
                    mixin::FinalSuspend<true>,
-                   mixin::UnhandledException<>,
+                   mixin::UnhandledException<generator<T>>,
                    mixin::ReturnVoid {
    private:
     // yielded value stored here

include/conduit/mixin/promise_parts.hpp

@@ -9,6 +9,39 @@
 namespace conduit::mixin {
 enum suspend : bool { always = true, never = false };
 
+#if CONDUIT_USE_GCC_EXCEPTION_WORKAROUND
+namespace detail {
+using remuse_coro_t = void (*)();
+using destroy_coro_t = void (*)();
+struct frame_header_t {
+    remuse_coro_t resume_coro;
+    destroy_coro_t destroy_coro;
+};
+} // namespace detail
+template <bool suspend>
+struct InitialSuspend {
+    // If CONDUIT_USE_GCC_EXCEPTION_WORKAROUND is defined, then we need to keep
+    // track of this value in order to destroy the frame manually. This value is
+    // recorded inside initial_suspend_t
+    detail::destroy_coro_t destroy_coro = nullptr;
+
+    struct initial_suspend_t {
+        detail::destroy_coro_t& destroy_coro_ref;
+
+        inline constexpr bool await_ready() { return false; }
+        inline bool await_suspend(std::coroutine_handle<> h) {
+            destroy_coro_ref =
+                ((detail::frame_header_t*)h.address())->destroy_coro;
+            return suspend; // The coroutine is resumed if suspend is false
+        }
+        inline constexpr void await_resume() noexcept {}
+    };
+
+    inline constexpr auto initial_suspend() noexcept {
+        return initial_suspend_t{destroy_coro};
+    }
+};
+#else
 template <bool suspend>
 struct InitialSuspend {
     inline constexpr auto initial_suspend() noexcept {
@@ -19,6 +52,7 @@ struct InitialSuspend {
         }
     }
 };
+#endif
 template <bool suspend>
 struct FinalSuspend {
     inline constexpr auto final_suspend() noexcept {
@@ -32,13 +66,25 @@ struct FinalSuspend {
 struct ReturnVoid {
     inline constexpr void return_void() noexcept {}
 };
-template <bool IsNoexcept = true>
+
+template <class DerivedPromise>
 struct UnhandledException {
-    [[noreturn]] void unhandled_exception() noexcept { std::terminate(); }
-};
-template <>
-struct UnhandledException<false> {
-    void unhandled_exception() noexcept {}
+    void unhandled_exception() {
+        // NB: for some reason, GCC doesn't destroy the coroutine frame if
+        // there's an exception raised inside the coroutine. As a result, if
+        // we're on GCC, we need to destroy it manually.
+
+#ifdef CONDUIT_USE_GCC_EXCEPTION_WORKAROUND
+        DerivedPromise& promise = static_cast<DerivedPromise&>(*this);
+        auto coro_frame = static_cast<detail::frame_header_t*>(
+            std::coroutine_handle<DerivedPromise>::from_promise(promise)
+                .address());
+        coro_frame->destroy_coro = promise.destroy_coro;
+        std::coroutine_handle<>::from_address(coro_frame).destroy();
+#endif
+
+        std::rethrow_exception(std::current_exception());
+    }
 };
 template <class Promise, bool IsNoexcept = true>
 struct GetReturnObject;

include/conduit/recursive_generator.hpp

@@ -18,7 +18,7 @@ template <
     // Type output by generator
     class T>
 struct recursive_generator : mixin::InitialSuspend<false>,
-                             mixin::UnhandledException<> {
+                             mixin::UnhandledException<recursive_generator<T>> {
     using return_object = conduit::recursive_generator<T>;
     using handle_type = std::coroutine_handle<recursive_generator>;
     unique_handle<recursive_generator>* sauce = nullptr;

include/conduit/source.hpp

@@ -10,7 +10,7 @@ namespace conduit::promise {
 template <class ReturnValue>
 struct source : mixin::HasOwnerAndCallback,
                 mixin::GetReturnObject<source<ReturnValue>>,
-                mixin::UnhandledException<true> {
+                mixin::UnhandledException<source<ReturnValue>> {
    private:
     ReturnValue const* pointer = nullptr;
 
@@ -32,7 +32,7 @@ struct source : mixin::HasOwnerAndCallback,
 template <>
 struct source<void> : mixin::HasOwnerAndCallback,
                       mixin::GetReturnObject<source<void>>,
-                      mixin::UnhandledException<true>,
+                      mixin::UnhandledException<source<void>>,
                       mixin::ReturnVoid {
    public:
     auto yield_value(tags::nothing_t) noexcept { return callback.release(); }

include/conduit/task.hpp

@@ -6,7 +6,7 @@ namespace conduit {
 namespace promise {
 struct task : mixin::GetReturnObject<task>,
               mixin::HasOwnerAndCallback,
-              mixin::UnhandledException<true>,
+              mixin::UnhandledException<task>,
               mixin::ReturnVoid {};
 } // namespace promise
 

include/conduit/util/stdlib_coroutine.hpp

@@ -1,15 +1,31 @@
 #pragma once
 
+#if defined(__GNUC__) && !defined(__clang__)
+#if __GNUC__ == 10 && __GNUC_MINOR__ <= 2
+#define CONDUIT_USE_GCC_EXCEPTION_WORKAROUND 1
+#else
+#warning "GCC versions 10, 10.1, and 10.2 contained a bug \
+that resulted in the coroutine frame not being destroyed \
+when an exception was thrown. Conduit implements a work-around \
+for this bug that manually destroys the coroutine frame \
+when an exception is thrown. This workaround is only enabled \
+for these versions of GCC, so future versions of GCC that still \
+contain this bug are not accounted for. Please upgrade to a newer \
+version of conduit, or contact the maintainer at [email protected] if \
+a fix is needed for a newer version of GCC but with the same version of conduit."
+#endif
+#endif
+
 #if __has_include(<coroutine>)
 #if defined(__clang__) && !defined(__cpp_impl_coroutine)
 #define __cpp_impl_coroutine 201902L
 #endif
 #include <coroutine>
 
 #ifdef __clang__
-namespace std::experimental {
-using std::coroutine_handle;
-using std::coroutine_traits;
+    namespace std::experimental {
+    using std::coroutine_handle;
+    using std::coroutine_traits;
 } // namespace std::experimental
 #endif
 

include/conduit/util/unique_handle.hpp

@@ -24,11 +24,6 @@ struct unique_handle : private std::coroutine_handle<Promise> {
     // Type of the coroutine handle
     using handle = std::coroutine_handle<Promise>;
 
-    // true if the coroutine always suspends initially
-    constexpr static bool suspends_initially =
-        std::is_same_v<std::suspend_always,
-                       decltype(declPromise().initial_suspend())>;
-
     // Returns true if the coroutine handle isn't null
     using super::operator bool;
     // Checks if the coroutine has finished executing