coroutine

/*
Copyright (C) 2018-2024 Geoffrey Daniels. https://gpdaniels.com/

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License only.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#pragma once
#ifndef GTL_EXECUTION_COROUTINE_HPP
#define GTL_EXECUTION_COROUTINE_HPP

// Summary: Setjump/Longjump implementation of stackful coroutines.

#ifndef NDEBUG
#if defined(_MSC_VER)
#define __builtin_trap() __debugbreak()
#endif
/// @brief A simple assert macro to break the program if the coroutine is misused.
#define GTL_COROUTINE_ASSERT(ASSERTION, MESSAGE) static_cast<void>((ASSERTION) || (__builtin_trap(), 0))
#else
/// @brief At release time the assert macro is implemented as a nop.
#define GTL_COROUTINE_ASSERT(ASSERTION, MESSAGE) static_cast<void>(0)
#endif

#if (defined(linux) || defined(__linux) || defined(__linux__)) || defined(__APPLE__)

#if defined(_FORTIFY_SOURCE)
#define GTL_COROUTINE_UNFORTIFY_SOURCE
#pragma push_macro("_FORTIFY_SOURCE")
#undef _FORTIFY_SOURCE
#endif
#include <csetjmp>
#if defined(GTL_COROUTINE_UNFORTIFY_SOURCE)
#undef GTL_COROUTINE_UNFORTIFY_SOURCE
#pragma pop_macro("_FORTIFY_SOURCE")
#endif

#include <csignal>
#include <cstdint>
#include <cstdlib>

//  Valgrind.
#if !defined(NDEBUG) && __has_include(<valgrind/valgrind.h>)
#include <valgrind/valgrind.h>
#define GTL_COROUTINE_HAVE_VALGRIND 1
#else
#define GTL_COROUTINE_HAVE_VALGRIND 0
#endif

#endif

#if defined(_WIN32)

#if defined(_MSC_VER)
#pragma warning(push, 0)
#endif

#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#define STRICT

#include <windows.h>

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

#define sig_atomic_t int

#endif

#if defined(_MSC_VER)
#pragma warning(push, 0)
#endif

#include <mutex>
#include <thread>

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

namespace gtl {
    // Predeclarations.
    class coroutine;

    namespace this_coroutine {
        static coroutine* get_self();
    }

    // The process to create a coroutine follows the proces described in the below paper:
    // R.Engleschall's Portable Multithreading: "The Signal Stack Trick for User-Space Thread Creation" in Proceedings of the USENIX Annual Technical Conference, 2000

    /// @brief  The coroutine class creates and stores a stack and an execution context to enable non-pre-emptive threading of functions.
    class coroutine final {
    public:
#if !defined(_WIN32)
        /// @brief  The alignement of the stack memory.
        constexpr static const unsigned long long stack_alignment = 16;

        /// @brief  The amount of memory to allocate for the stack of the coroutine.
        constexpr static const unsigned long long stack_size = 32768; // Would use SIGSTKSZ but that macro calls a non-constexpr function.

        /// @brief  The id of the signal raised to trigger a signal handler.
        constexpr static const int trigger_signal_identifier = SIGUSR1;
#endif

    private:
        /// @brief  Friend accessor function that is allowed to access the coroutines private state.
        friend coroutine* this_coroutine::get_self();

    private:
        /// @brief  Each process can only have one signal handler, therefore only one thread can create a coroutine at a time, enforce this with a mutex.
        static inline std::mutex signal_handler_mutex;

        /// @brief  Store a pointer to the currently executing coroutine as a global thread_local variable.
        static inline thread_local coroutine* current = nullptr;

#if defined(_WIN32)
        /// @brief  Store the root thread fiber pointer
        static inline thread_local void* thread_fiber = nullptr;
#endif

    public:
        /// @brief  An identifier type used to uniquely identify coroutines.
        class id final {
        private:
            /// @brief  The identifier value.
            unsigned long long int value;

        public:
            /// @brief  Construct an identifier type from an integer.
            /// @param  unique_value The integer used as the id value.
            explicit id(unsigned long long int unique_value = 0)
                : value(unique_value) {
            }

            /// @brief  The less than operator is the only one defined using the identifier value, all other operators are defined using this one.
            /// @param  rhs The right hand side of the comparison.
            constexpr bool operator<(const id& rhs) const {
                return (this->value < rhs.value);
            }

            /// @brief  The greater than operator defined using the less than operator with the sides of the comparison reversed.
            /// @param  rhs The right hand side of the comparison.
            constexpr bool operator>(const id& rhs) const {
                return rhs < *this;
            }

            /// @brief  The less than or equal to operator defined using the greater than operator and inverted.
            /// @param  rhs The right hand side of the comparison.
            constexpr bool operator<=(const id& rhs) const {
                return !(*this > rhs);
            }

            /// @brief  The greater than or equal to operator defined using the less than operator and inverted.
            /// @param  rhs The right hand side of the comparison.
            constexpr bool operator>=(const id& rhs) const {
                return !(*this < rhs);
            }

            /// @brief  The inequality operator defined using the less than and greater than operators.
            /// @param  rhs The right hand side of the comparison.
            constexpr bool operator!=(const id& rhs) const {
                return (*this < rhs) || (*this > rhs);
            }

            /// @brief  The equality operator defined using the inequality operator and inverted.
            /// @param  rhs The right hand side of the comparison.
            constexpr bool operator==(const id& rhs) const {
                return !(*this != rhs);
            }
        };

        /// @brief  Simple lambda class for containing a void() lambda.
        class lambda final {
        private:
            /// @brief  A pointer to a heap allocated copy of the function.
            void* function;

            /// @brief  A lambda function to copy the function.
            void* (*copier)(void*);

            /// @brief  A lambda function to execute the function.
            void (*executor)(void*);

            /// @brief  A lambda function to delete the function.
            void (*deleter)(void*);

        public:
            /// @brief  The destructor calls the deleter function if it exists to cleanup the lambda function.
            ~lambda() {
                if (this->deleter != nullptr) {
                    this->deleter(this->function);
                }
            }

            /// @brief  The default constructor sets all internal variables to nullptrs.
            lambda()
                : function(nullptr)
                , copier(nullptr)
                , executor(nullptr)
                , deleter(nullptr) {
            }

            /// @brief  The copy constructor copies variables from another object, if there is a copier function it is used to copy the function.
            /// @param  other The lambda to copy.
            lambda(const lambda& other)
                : function(other.copier ? other.copier(other.function) : nullptr)
                , copier(other.copier)
                , executor(other.executor)
                , deleter(other.deleter) {
            }

            /// @brief  Defaulted move constructor.
            lambda(lambda&&) noexcept = default;

            /// @brief  The copy assignment operator copies variables from another object, if there is a copier function it is used to copy the function.
            /// @param  other The lambda to copy.
            lambda& operator=(const lambda& other) {
                if (this != &other) {
                    this->function = other.copier ? other.copier(other.function) : nullptr;
                    this->copier = other.copier;
                    this->executor = other.executor;
                    this->deleter = other.deleter;
                }
                return *this;
            }

            /// @brief  Defaulted move assignment operator.
            lambda& operator=(lambda&&) noexcept = default;

            /// @brief  Constructor from a function type copies a provided function to a heap allocated internal function,.
            /// @param  raw_function The function to wrap.
            template <typename function_type>
            lambda(const function_type& raw_function)
                : function(new function_type(raw_function))
                , copier([](void* function_pointer) -> void* {
                    if (function_pointer) {
                        return new function_type(*reinterpret_cast<function_type*>(function_pointer));
                    }
                    return nullptr;
                })
                , executor([](void* function_pointer) -> void {
                    return reinterpret_cast<function_type*>(function_pointer)->operator()();
                })
                , deleter([](void* function_pointer) -> void {
                    delete reinterpret_cast<function_type*>(function_pointer);
                }) {
            }

            /// @brief  Copy assignement operator from a function type copies a provided function to a heap allocated internal function,.
            /// @param  raw_function The function to wrap.
            template <typename function_type>
            lambda& operator=(const function_type& raw_function) {
                if (this->function != nullptr) {
                    this->deleter(this->function);
                }
                this->function = new function_type(raw_function);
                this->copier = [](void* function_pointer) -> void* {
                    if (function_pointer) {
                        return new function_type(*reinterpret_cast<function_type*>(function_pointer));
                    }
                    return nullptr;
                };
                this->executor = [](void* function_pointer) -> void {
                    return reinterpret_cast<function_type*>(function_pointer)->operator()();
                };
                this->deleter = [](void* function_pointer) -> void {
                    delete reinterpret_cast<function_type*>(function_pointer);
                };
                return *this;
            }

        public:
            /// @brief  The function call operator is overloaded to call the internal function.
            void operator()() {
                this->executor(this->function);
            }
        };

    private:
#if !defined(_WIN32)
        /// @brief  Jump buffer to used to enter the coroutine.
        sigjmp_buf coroutine_context;

        /// @brief  Jump buffer used to exit the coroutine.
        sigjmp_buf parent_context;

        /// @brief  The signal set of the program at coroutine creation saved as a member variable so it can be restored in the coroutine context.
        sigset_t parent_signal_set;
#else
        /// @brief  Fibre used to exit the coroutine.
        void* parent_stack;
#endif

        /// @brief  Atomic flag that is set by the signal handler and checked by the constructor to ensure creation stages procede in order.
        volatile sig_atomic_t signal_raised;

        /// @brief  Coroutine stack allocated on the heap stack using new.
        void* stack;

#if GTL_COROUTINE_HAVE_VALGRIND
        unsigned int valgrind_stack_id;
#endif

        /// @brief  Function to call from the coroutine context.
        lambda function;

    public:
        /// @brief Destructor ensures the coroutine is finished.
        ~coroutine() {
            // Ensure joined or throw.
            if (this->joinable()) {
                std::terminate();
            }
#if !defined(_WIN32)
            // Cleanup stack.
            if (this->stack) {
                std::free(this->stack);
            }
            // If we are testing with valgrind deregister the coroutine stack.
#if GTL_COROUTINE_HAVE_VALGRIND
            VALGRIND_STACK_DEREGISTER(this->valgrind_stack_id);
#endif
#else
            // Cleanup stack.
            if (this->stack) {
                DeleteFiber(this->stack);
            }
#endif
        }

        /// @brief  Default constructor does nothing.
        coroutine()
            : signal_raised(0)
            , stack(nullptr) {
        }

        /// @brief  Copy constructor is explicitly deleted.
        coroutine(const coroutine&) = delete;

        /// @brief  Move constructor cannot be default as the default leaves other in an invalid state.
        coroutine(coroutine&& other) noexcept
            : coroutine() {
            *this = std::move(other);
        }

        /// @brief  Copy assignment operator is explicitly deleted.
        coroutine& operator=(const coroutine&) = delete;

        /// @brief  Move assignment operator cannot be default as the default leaves other in an invalid state.
        coroutine& operator=(coroutine&& other) noexcept {
            // Ensure we're not moving on top of ourself.
            if (this == &other) {
                return *this;
            }

            // Swap all the member variables with those from other.
#if !defined(_WIN32)
            std::swap(this->coroutine_context, other.coroutine_context);
            std::swap(this->parent_context, other.parent_context);
            std::swap(this->parent_signal_set, other.parent_signal_set);
#else
            std::swap(this->parent_stack, other.parent_stack);
#endif
            std::swap(this->signal_raised, other.signal_raised);
            std::swap(this->stack, other.stack);
            std::swap(this->function, other.function);

            // Return this, other will be destructed and cleanup after itself.
            return *this;
        }

        /// @brief  Constructor creates a coroutine context, taking a function as an argument to call from the coroutine context.
        /// @param  coroutine_function Function to call from the coroutine context.
        /// @param  coroutine_arguments Function arguments to provide to the function at call time.
        template <typename function_type, typename... argument_types>
        coroutine(function_type&& coroutine_function, argument_types&&... coroutine_arguments)
#if !defined(_WIN32)
            : signal_raised(0)
            , stack(operator new(coroutine::stack_size + (coroutine::stack_alignment - 1))){
#else
            : stack(nullptr) {
#endif

#if !defined(_WIN32)
        // If we are testing with valgrind register the coroutine stack.
#if GTL_COROUTINE_HAVE_VALGRIND
                this->valgrind_stack_id = VALGRIND_STACK_REGISTER(this->stack, static_cast<unsigned char*>(this->stack) + coroutine::stack_size);
#endif

        // Use a lock guard so the mutex is unlocked automatically when we return from the construtor.
        std::lock_guard<std::mutex> signal_handler_lock(signal_handler_mutex);
        // Cast the lock guard to void to prevent unused variable warnings.
        static_cast<void>(signal_handler_lock);

        // Step 1:
        // Preserve the current signal mask and block an arbitrary worker signal.
        // coroutine::trigger_signal_identifier is used here, but any signal can be used for this (even an already used one).
        // This worker signal is later temporarily required for the trampoline step.
        sigset_t coroutine_signal_set = {};
        if (sigemptyset(&coroutine_signal_set) != 0) {
            std::terminate();
        }
        if (sigaddset(&coroutine_signal_set, coroutine::trigger_signal_identifier) != 0) {
            std::terminate();
        }

        sigset_t local_parent_signal_set = {};
        if (sigprocmask(SIG_BLOCK, &coroutine_signal_set, &local_parent_signal_set) != 0) {
            std::terminate();
        }

        // Step 2:
        // Preserve a possibly existing signal action for the worker signal and configure a trampoline function as the new temporary signal action.
        // The signal delivery is configured to occur on an alternate signal stack (see next step).
        struct sigaction coroutine_signal_action = {};
        coroutine_signal_action.sa_handler = signal_handler_trampoline;
        coroutine_signal_action.sa_flags = SA_ONSTACK;
        if (sigemptyset(&coroutine_signal_action.sa_mask) != 0) {
            std::terminate();
        }

        struct sigaction parent_signal_action = {};
        if (sigaction(coroutine::trigger_signal_identifier, &coroutine_signal_action, &parent_signal_action) != 0) {
            std::terminate();
        }

        // Step 3:
        // Preserve a possibly active alternate signal stack and configure the memory chunk starting at this->stack as the new temporary alternate signal stack of length size.
        stack_t signal_stack = {};
        signal_stack.ss_sp = reinterpret_cast<void*>((reinterpret_cast<std::uintptr_t>(this->stack) + (coroutine::stack_alignment - 1)) & ~std::uintptr_t(coroutine::stack_alignment - 1));
        signal_stack.ss_size = coroutine::stack_size;
        signal_stack.ss_flags = 0;
        stack_t parent_signal_stack = {};
        if (sigaltstack(&signal_stack, &parent_signal_stack) != 0) {
            std::terminate();
        }

        // Step 4:
        // Save parameters for the trampoline step in member variables.
        // Send the current process the worker signal, temporarily unblock it and this way allow it to be delivered on the signal stack.
        // This transfers execution control to the trampoline function.
        this->function = [coroutine_function, coroutine_arguments...]() {
            coroutine_function(coroutine_arguments...);
        };
        this->parent_signal_set = local_parent_signal_set;
        this->signal_raised = 0;

        // Store the currently executing coroutine in previous.
        coroutine* parent_coroutine = gtl::coroutine::current;
        // Save the new coroutine in current.
        gtl::coroutine::current = this;

        // Raise the signal.
        if (raise(coroutine::trigger_signal_identifier) != 0) {
            std::terminate();
        }

        // Valgrind seems to think the creation of alternative context is dodgy.
        // Therefore the only sensible solution is to disable valgrind error reporting!
#if GTL_COROUTINE_HAVE_VALGRIND
        VALGRIND_DISABLE_ERROR_REPORTING;
#endif

        // Unblock and wait for the signal by suspending the current thread.
        sigfillset(&coroutine_signal_set);
        sigdelset(&coroutine_signal_set, coroutine::trigger_signal_identifier);
        while (!this->signal_raised) {
            if (sigsuspend(&coroutine_signal_set) != -1) {
                std::terminate();
            }
        }

        // Step 6:
        // Restore the preserved alternate signal stack, preserved signal action and preserved signal mask for worker signal.
        // This way an existing application configuration for the worker signal is restored.
        if (sigaltstack(nullptr, &signal_stack) != 0) {
            std::terminate();
        }
        signal_stack.ss_flags = SS_DISABLE;
        if (sigaltstack(&signal_stack, nullptr) != 0) {
            std::terminate();
        }
        if (sigaltstack(nullptr, &signal_stack) != 0) {
            std::terminate();
        }
        if (!(parent_signal_stack.ss_flags & SS_DISABLE)) {
            if (sigaltstack(&parent_signal_stack, nullptr) != 0) {
                std::terminate();
            }
        }

        if (sigaction(coroutine::trigger_signal_identifier, &parent_signal_action, nullptr) != 0) {
            std::terminate();
        }
        if (sigprocmask(SIG_SETMASK, &parent_signal_set, nullptr) != 0) {
            std::terminate();
        }

        // Step 7:
        // Save the current machine context of the Create function.
        // This allows us to return to this point after the next trampoline step.
        if (sigsetjmp(this->parent_context, 0) == 0) {
            // Step 8:
            // Restore the previously saved machine context of the trampoline function to again transfer execution control onto the alternate stack.
            // This time without(!) signal handler scope.
            siglongjmp(this->coroutine_context, 1);
        }

        // Restore the currently running coroutine.
        gtl::coroutine::current = parent_coroutine;

        // Step 14:
        // Return to the calling application.
#else
            // Save parameters for the coroutine in member variables.
            this->function = [coroutine_function, coroutine_arguments...]() {
                coroutine_function(coroutine_arguments...);
            };

            // Create the fiber based coroutine.
            this->stack = CreateFiber(
                0,
                [](LPVOID) {
                    // The coroutine function call.
                    gtl::coroutine::current->function();
                    // Clear the signal raised flag to indicate the coroutine is finished.
                    gtl::coroutine::current->signal_raised = 0;
                    // Yield to another coroutine or the root.
                    gtl::coroutine::current->yield();
                },
                nullptr
            );

            // Check to see if the fiber failed to be created.
            if (this->stack == nullptr) {
                return;
            }

            // Set flag to indicate the coroutine is ready.
            this->signal_raised = 1;
#endif
}

private :
#if !defined(_WIN32)
    /// @brief  Signal handler, called by the os with a new stack when this class calls raise.
    /// @param  signal_identifier The identifying code of the raised signal.
    static void signal_handler_trampoline(int signal_identifier) {
        // Don't need to validate which signal it is as this routine only handles one.
        static_cast<void>(signal_identifier);

        // Step 5:
        // After the trampoline function asynchronously entered, save its machine context in the structure.
        // Then immediately return from it to terminate the signal handler scope.
        if (sigsetjmp(gtl::coroutine::current->coroutine_context, 0) == 0) {
            gtl::coroutine::current->signal_raised = 1;
            return;
        }

        // Step 9:
        // After reaching the trampoline function again, immediately bootstrap into a clean stack frame by calling a second function.
        coroutine::bootstrap();
    }

    /// @brief  Container function jumped to and from when joining and yielding from a coroutine.
    [[noreturn]] static void bootstrap() {
        // Re-enable valgrind error reporting.
#if GTL_COROUTINE_HAVE_VALGRIND
        VALGRIND_ENABLE_ERROR_REPORTING;
#endif

        // Beware this function cannot be a member function, because the coroutine could have been moved while we were away.
        // Moving the coroutine changes the "this" pointer, therefore the code "this->function()" would be invalid.

        // Step 10:
        // Set the new signal mask to be the same as the original signal mask which was active when the coroutine was created.
        // This is required because in the first trampoline step we usually had at least the worker signal blocked.
        if (sigprocmask(SIG_SETMASK, &gtl::coroutine::current->parent_signal_set, nullptr) != 0) {
            std::terminate();
        }

        // Step 11:
        // Load the passed startup information (the function) from the constructor into local (stack based) variables.
        // This is not required as the coroutine is an raii class.
        // lambda function = gtl::coroutine::current->function;

        // Step 12:
        // Save the current machine context for later restoring by the calling application.
        if (sigsetjmp(gtl::coroutine::current->coroutine_context, 0) == 0) {
            // Step 13:
            // Restore the previously saved machine context of the coroutine to transfer execution control back to it.
            siglongjmp(gtl::coroutine::current->parent_context, 1);
        }

        // The coroutine function call.
        gtl::coroutine::current->function();

        // Clear the signal raised flag to indicate the coroutine is finished.
        gtl::coroutine::current->signal_raised = 0;

        // Exit by jumping to the creator location.
        siglongjmp(gtl::coroutine::current->parent_context, 1);

        // Silence warning about function returning.
        std::abort();
    }
#endif

public:
    /// @brief  Get the unique identifier of the coroutine.
    /// @return The unique identider.
    id get_id() const {
        return id(reinterpret_cast<unsigned long long int>(this->stack));
    }

    /// @brief  Checks whether the coroutine is joinable, i.e. unfinished.
    /// @return True if the coroutine is unfinished, false otherwise.
    bool joinable() {
        return this->signal_raised;
    }

    /// @brief  Switches to the coroutine's execution context and continues execution, i.e. runs the coroutine.
    void join() {
        GTL_COROUTINE_ASSERT(this->joinable(), "Coroutine must be joinable to be joined.");
        // Store the currently running coroutine.
        coroutine* parent_coroutine = gtl::coroutine::current;
        // Set the now running coroutine.
        gtl::coroutine::current = this;
#if !defined(_WIN32)
        // Switch execution contexts.
        if (sigsetjmp(gtl::coroutine::current->parent_context, 0) == 0) {
            siglongjmp(gtl::coroutine::current->coroutine_context, 1);
        }
#else
            // If there is no parent coroutine then convert this thread to a fiber.
            if (!gtl::coroutine::thread_fiber) {
                gtl::coroutine::thread_fiber = ConvertThreadToFiber(nullptr);
            }
            // Save parent inside the coroutine to enable the yield function.
            gtl::coroutine::current->parent_stack = (parent_coroutine != nullptr) ? parent_coroutine->stack : gtl::coroutine::thread_fiber;
            // Switch execution contexts.
            SwitchToFiber(gtl::coroutine::current->stack);
            // Reset the parent stack.
            gtl::coroutine::current->parent_stack = nullptr;
            // If the current coroutine is null convert back to a thread.
            if (!parent_coroutine) {
                ConvertFiberToThread();
                gtl::coroutine::thread_fiber = nullptr;
            }
#endif
        // Upon return reset the currently running coroutine.
        gtl::coroutine::current = parent_coroutine;
    }

    /// @brief  Yield from the coroutine, i.e. force a return to the parent execution context.
    void yield() {
        GTL_COROUTINE_ASSERT(gtl::coroutine::current == this, "This coroutine must be running to yield.");
#if !defined(_WIN32)
        if (sigsetjmp(gtl::coroutine::current->coroutine_context, 0) == 0) {
            siglongjmp(gtl::coroutine::current->parent_context, 1);
        }
#else
            SwitchToFiber(gtl::coroutine::current->parent_stack);
#endif
    }
};
}

namespace gtl {
    /// @brief  The this_coroutine class cannot be instantiated and provides static functions to operate on the current coroutine.
    namespace this_coroutine {
        /// @brief  Get a pointer to the currently running coroutine if there is one.
        /// @return A pointer to the currently running coroutine or a nullptr if there isn't one.
        [[maybe_unused]] static coroutine* get_self() {
            return gtl::coroutine::current;
        }

        /// @brief  Get the unique identifier of the currently running coroutine if there is one.
        /// @return The unique identider of the currently running coroutine or a null id if there isn't one.
        [[maybe_unused]] static gtl::coroutine::id get_id() {
            if (get_self() == nullptr) {
                return coroutine::id();
            }
            return get_self()->get_id();
        }

        /// @brief  Yield from the currently running coroutine, i.e. force a return to the parent execution context.
        [[maybe_unused]] static void yield() {
            GTL_COROUTINE_ASSERT(get_self() != nullptr, "A coroutine must be running to yield.");
            get_self()->yield();
        }

        /// @brief  Sleep a coroutine for an amount of time, provided to match the std::thread api.
        /// @param  duration Length of time to sleep for.
        template <typename number_of_ticks_type, typename period_type>
        [[maybe_unused]] static void sleep_for(const std::chrono::duration<number_of_ticks_type, period_type>& duration) {
            GTL_COROUTINE_ASSERT(get_self() != nullptr, "A coroutine must be running to sleep.");
            std::this_thread::sleep_for(duration);
        }

        /// @brief  Sleep a coroutine until a specific time, provided to match the std::thread api.
        /// @param  time_point Time to sleep until.
        template <typename clock_type, typename duration_type>
        [[maybe_unused]] static void sleep_until(const std::chrono::time_point<clock_type, duration_type>& time_point) {
            GTL_COROUTINE_ASSERT(get_self() != nullptr, "A coroutine must be running to sleep.");
            std::this_thread::sleep_until(time_point);
        }
    }
}

// Undo the siglongjmp override.
#ifdef __GLIBC__
#undef siglongjmp
#endif

#undef GTL_COROUTINE_HAVE_VALGRIND
#undef GTL_COROUTINE_ASSERT

#endif // GTL_EXECUTION_COROUTINE_HPP