ExecutionContext.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/Forward.hpp"
 
#include <asio/defer.hpp>
#include <asio/dispatch.hpp>
#include <asio/io_context.hpp>
#include <asio/post.hpp>
#include <asio/strand.hpp>
 
#include <asio/any_io_executor.hpp>
#include <asio/execution/execute.hpp>
 
namespace CeresEngine {
 
    class ExecutionContext : public asio::execution_context {
    public:
        using ID = id;
 
        template<typename T> class Service : public service {
        public:
            static inline const ID id;
            using service::service;
 
        public:
            [[nodiscard]] ExecutionContext& getExecutionContext() noexcept;
 
            [[nodiscard]] AnyExecutor getExecutor() noexcept;
        };
 
    public:
        virtual ~ExecutionContext() noexcept = default;
 
    public:
        template<typename T> [[nodiscard]] bool hasService() noexcept { return asio::has_service<T>(*this); }
 
        template<typename T> [[nodiscard]] T& getService() noexcept { return asio::use_service<T>(*this); }
 
        template<typename T> [[nodiscard]] T* getServiceIf() noexcept { return hasService<T>() ? &getService<T>() : nullptr; }
 
    public:
        using executor_type = AnyExecutor;
 
        [[nodiscard]] virtual AnyExecutor getExecutor() noexcept = 0;
 
        executor_type get_executor() noexcept;
 
    public:
        [[nodiscard]] static ExecutionContext* getCurrent() noexcept;
 
        [[nodiscard]] bool isActive() const noexcept;
 
        [[nodiscard]] static ExecutionContext& get() noexcept {
            ExecutionContext* executionContext = getCurrent();
            CE_ASSERT(executionContext != nullptr);
            return *executionContext;
        }
 
    protected:
        class Scope {
            friend class ExecutionContext;
 
        private:
            static thread_local const Scope* top;
 
            ExecutionContext* const mExecutionContext;
 
            const Scope* const mPrevious;
 
        public:
            explicit Scope(ExecutionContext* executionContext) noexcept;
 
            ~Scope() noexcept;
 
            Scope(const Scope&) noexcept = delete;
            Scope& operator=(const Scope&) noexcept = delete;
        };
    };
 
    using ExecutorExecutionContext = asio::execution::context_t;
    template<typename T> using ExecutorExecutionContextAs = asio::execution::context_as_t<T>;
    using ExecutorBlocking = asio::execution::blocking_t;
    using ExecutorMapping = asio::execution::mapping_t;
    using ExecutorOccupancy = asio::execution::occupancy_t;
    using ExecutorOutstandingWork = asio::execution::outstanding_work_t;
    using ExecutorBulkGuarantee = asio::execution::bulk_guarantee_t;
    using ExecutorRelationship = asio::execution::relationship_t;
    template<typename T> using ExecutorAllocator = asio::execution::allocator_t<T>;
 
    struct ExecutorPriority {
        Int32 raw = 0;
 
        constexpr ExecutorPriority() noexcept = default;
        explicit constexpr ExecutorPriority(const Int32 raw) noexcept : raw(raw) {}
 
        [[nodiscard]] friend constexpr ExecutorPriority operator+(const Int32 lhs, const ExecutorPriority& rhs) noexcept { return ExecutorPriority(lhs + rhs.raw); }
        [[nodiscard]] friend constexpr ExecutorPriority operator+(const ExecutorPriority& lhs, const Int32 rhs) noexcept { return ExecutorPriority(lhs.raw + rhs); }
 
        [[nodiscard]] friend constexpr ExecutorPriority operator-(const Int32 lhs, const ExecutorPriority& rhs) noexcept { return ExecutorPriority(lhs - rhs.raw); }
        [[nodiscard]] friend constexpr ExecutorPriority operator-(const ExecutorPriority& lhs, const Int32 rhs) noexcept { return ExecutorPriority(lhs.raw - rhs); }
 
        [[nodiscard]] friend constexpr Int32 operator-(const ExecutorPriority& lhs, const ExecutorPriority& rhs) noexcept { return lhs.raw - rhs.raw; }
 
        [[nodiscard]] friend constexpr bool operator==(const ExecutorPriority& lhs, const ExecutorPriority& rhs) noexcept { return lhs.raw == rhs.raw; }
        [[nodiscard]] friend constexpr bool operator!=(const ExecutorPriority& lhs, const ExecutorPriority& rhs) noexcept { return !(rhs == lhs); }
 
        [[nodiscard]] friend constexpr bool operator<(const ExecutorPriority& lhs, const ExecutorPriority& rhs) noexcept { return lhs.raw < rhs.raw; }
        [[nodiscard]] friend constexpr bool operator>(const ExecutorPriority& lhs, const ExecutorPriority& rhs) noexcept { return rhs < lhs; }
        [[nodiscard]] friend constexpr bool operator<=(const ExecutorPriority& lhs, const ExecutorPriority& rhs) noexcept { return !(rhs < lhs); }
        [[nodiscard]] friend constexpr bool operator>=(const ExecutorPriority& lhs, const ExecutorPriority& rhs) noexcept { return !(lhs < rhs); }
 
        static const ExecutorPriority Lowest;
 
        static const ExecutorPriority Low;
 
        static const ExecutorPriority Normal;
 
        static const ExecutorPriority High;
 
        static const ExecutorPriority Highest;
 
        [[nodiscard]] static constexpr ExecutorPriority interpolate(const double priority) { return interpolate(priority, Lowest, Highest); }
 
        [[nodiscard]] static constexpr ExecutorPriority interpolate(const double priority, const ExecutorPriority& lowest, const ExecutorPriority& highest) {
            CE_ASSERT(lowest.raw < highest.raw);
            return ExecutorPriority(Int32(std::lerp(priority, double(lowest.raw), double(highest.raw))));
        }
 
    public: // ASIO executor interface:
        template<typename T> static constexpr bool is_applicable_property_v = asio::execution::is_executor<T>::value;
        static constexpr bool is_requirable = true;
        static constexpr bool is_preferable = true;
        using polymorphic_query_result_type = ExecutorPriority;
    };
 
    inline constexpr ExecutorPriority ExecutorPriority::Lowest{std::numeric_limits<Int32>::lowest()};
    inline constexpr ExecutorPriority ExecutorPriority::Low{std::numeric_limits<Int32>::lowest() / 2};
    inline constexpr ExecutorPriority ExecutorPriority::Normal{0};
    inline constexpr ExecutorPriority ExecutorPriority::High{std::numeric_limits<Int32>::max() / 2};
    inline constexpr ExecutorPriority ExecutorPriority::Highest{std::numeric_limits<Int32>::max()};
 
    template<typename Property> using ExecutorPreferOnly = asio::execution::prefer_only<Property>;
 
    template<typename... Properties>
    using AnyExecutorBase = asio::execution::any_executor<
        // clang-format off
//            ExecutorExecutionContextAs<asio::execution_context&>,
//            ExecutorContextAsProperty<ExecutionContext&>,
            Properties...,
//            ExecutorBlocking::never_t,
            ExecutorPreferOnly<ExecutorPriority>,
            ExecutorPreferOnly<ExecutorBlocking::possibly_t>,
            ExecutorPreferOnly<ExecutorBlocking::never_t>,
            ExecutorPreferOnly<ExecutorOutstandingWork::tracked_t>,
            ExecutorPreferOnly<ExecutorOutstandingWork::untracked_t>,
            ExecutorPreferOnly<ExecutorRelationship::fork_t>,
            ExecutorPreferOnly<ExecutorRelationship::continuation_t>,
            ExecutorPreferOnly<ExecutorBulkGuarantee::parallel_t>,
            ExecutorPreferOnly<ExecutorBulkGuarantee::sequenced_t>,
            ExecutorPreferOnly<ExecutorBulkGuarantee::unsequenced_t>
        // clang-format on
        >;
 
    template<typename... Properties> class TAnyExecutor : private AnyExecutorBase<Properties...> {
    private:
        using super = AnyExecutorBase<Properties...>;
 
    public:
        TAnyExecutor() noexcept = default;
 
        TAnyExecutor(const TAnyExecutor& e) noexcept = default;
 
        TAnyExecutor& operator=(const TAnyExecutor& e) noexcept = default;
 
        TAnyExecutor(TAnyExecutor&& e) noexcept = default;
 
        TAnyExecutor& operator=(TAnyExecutor&& e) noexcept = default;
 
        template<typename Executor>
        TAnyExecutor(Executor executor) requires(!std::is_same_v<Executor, AnyExecutor> && !std::is_base_of_v<AnyExecutor, Executor>)
                : super(std::move(executor)) {}
 
        TAnyExecutor(nullptr_t) noexcept : super(nullptr) {}
 
        TAnyExecutor& operator=(nullptr_t) {
            super() = nullptr;
            return *this;
        }
 
        ~TAnyExecutor() = default;
 
        void swap(TAnyExecutor& other) noexcept { base().swap(other.base()); }
 
        //        using super::context;
 
        //        [[nodiscard]] ExecutionContext& getExecutionContext() const noexcept { return static_cast<ExecutionContext&>(context()); }
 
        using super::execute;
 
        template<typename F> void operator()(F&& f) const {
            asio::execution::execute(*this, [f = std::forward<F>(f)]() mutable { std::forward<F>(f)(); });
        }
 
        template<typename Property>
        [[nodiscard]] decltype(auto) query(const Property& p) const requires asio::traits::query_member<const super&, const Property&>::is_valid {
            return base().query(p);
        }
 
        template<typename Property>
        [[nodiscard]] TAnyExecutor require(const Property& p) const requires asio::traits::require_member<const super&, const Property&>::is_valid {
            return base().require(p);
        }
 
        template<typename Property>
        [[nodiscard]] TAnyExecutor prefer(const Property& p) const requires asio::traits::prefer_member<const super&, const Property&>::is_valid {
            return base().prefer(p);
        }
 
        template<typename T> [[nodiscard]] bool is() const noexcept { return this->target_type() == typeid(T); }
        template<typename T> [[nodiscard]] T& as() const noexcept { return *this->template target<T>(); }
        template<typename T> [[nodiscard]] T* being() const noexcept { return is<T>() ? &this->template target<T>() : nullptr; }
 
    public:
        friend bool operator==(const TAnyExecutor& lhs, const TAnyExecutor& rhs) noexcept { return lhs.base() == rhs.base(); }
        friend bool operator==(const TAnyExecutor& lhs, std::nullptr_t) noexcept { return lhs.base() == nullptr; }
        friend bool operator==(std::nullptr_t, const TAnyExecutor& rhs) noexcept { return nullptr == rhs.base(); }
 
        friend bool operator!=(const TAnyExecutor& lhs, const TAnyExecutor& rhs) noexcept { return lhs.base() != rhs.base(); }
        friend bool operator!=(const TAnyExecutor& lhs, std::nullptr_t) noexcept { return lhs.base() != nullptr; }
        friend bool operator!=(std::nullptr_t, const TAnyExecutor& rhs) noexcept { return nullptr != rhs.base(); }
 
    private:
        [[nodiscard]] super& base() noexcept { return *this; }
        [[nodiscard]] const super& base() const noexcept { return *this; }
    };
 
    using AnyExecutor = TAnyExecutor<>;
    using AnyIOExecutor = TAnyExecutor<ExecutorExecutionContextAs<asio::execution_context&>, ExecutorBlocking::never_t>;
 
    template<typename T> ExecutionContext& ExecutionContext::Service<T>::getExecutionContext() noexcept { return static_cast<ExecutionContext&>(context()); }
    template<typename T> TAnyExecutor<> ExecutionContext::Service<T>::getExecutor() noexcept { return asio::get_associated_executor(context()); }
 
    template<typename Executor> using TStrand = asio::strand<Executor>;
 
    using Strand = TStrand<AnyExecutor>;
 
    namespace traits {
        using asio::execution::is_executor;
 
        template<typename T> constexpr bool is_executor_v = is_executor<T>::value;
 
        template<typename T>
        concept executor = is_executor_v<T>;
 
        // -----------------------------------------------------------------------------------------
 
        template<class T> struct is_execution_context : asio::is_convertible<T&, ExecutionContext&> {};
 
        template<typename T> constexpr bool is_execution_context_v = is_execution_context<T>::value;
 
        template<typename T>
        concept execution_context = is_execution_context_v<T>;
 
        // -----------------------------------------------------------------------------------------
 
        template<class T> struct is_executor_or_execution_context : std::conjunction<is_executor<T>, is_execution_context<T>> {};
 
        template<typename T> constexpr bool is_executor_or_execution_context_v = is_executor_or_execution_context<T>::value;
 
        template<typename T>
        concept executor_or_execution_context = is_executor_or_execution_context_v<T>;
    } // namespace traits
 
    // ---------------------------------------------------------------------------------------------
 
    template<traits::executor Executor, typename F> decltype(auto) defer(Executor executor, F&& func) {
        // NOTE: If no executor is specified, defer to the current executor.
        return asio::defer(executor, std::forward<F>(func));
    }
 
    template<typename F> decltype(auto) defer(ExecutionContext& executionContext, F&& func) {
        // NOTE: If no executor is specified, defer to the current executor.
        return asio::defer(executionContext.getExecutor(), std::forward<F>(func));
    }
 
    template<typename F> decltype(auto) defer(F&& func) {
        // NOTE: If no executor is specified, defer to the current executor.
        return asio::defer(ExecutionContext::get(), std::forward<F>(func));
    }
 
    // ---------------------------------------------------------------------------------------------
 
    //    template<traits::executor Executor, typename F> decltype(auto) dispatch(Executor executor, F&& func) {
    //        // NOTE: If no executor is specified, dispatch to the current executor.
    //        return asio::dispatch(executor, std::forward<F>(func));
    //    }
    //
    //    template<typename F> decltype(auto) dispatch(ExecutionContext& executionContext, F&& func) {
    //        // NOTE: If no executor is specified, dispatch to the current executor.
    //        return asio::dispatch(executionContext.getExecutor(), std::forward<F>(func));
    //    }
    //
    //    template<typename F> decltype(auto) dispatch(F&& func) {
    //        // NOTE: If no executor is specified, dispatch to the current executor.
    //        return asio::dispatch(ExecutionContext::get(), std::forward<F>(func));
    //    }
    //
    //    // ---------------------------------------------------------------------------------------------
    //
    //    template<traits::executor Executor, typename F> decltype(auto) post(Executor executor, F&& func) {
    //        // NOTE: If no executor is specified, post to the current executor.
    //        return asio::post(executor, std::forward<F>(func));
    //    }
    //
    //    template<typename F> decltype(auto) post(ExecutionContext& executionContext, F&& func) {
    //        // NOTE: If no executor is specified, post to the current executor.
    //        return asio::post(executionContext.getExecutor(), std::forward<F>(func));
    //    }
    //
    //    template<typename F> decltype(auto) post(F&& func) {
    //        // NOTE: If no executor is specified, post to the current executor.
    //        return asio::post(ExecutionContext::get(), std::forward<F>(func));
    //    }
    //
    //    // ---------------------------------------------------------------------------------------------
    //
    //    template<traits::executor Executor, typename F> decltype(auto) execute(Executor executor, F&& func) {
    //        // NOTE: If no executor is specified, execute to the current executor.
    //        return asio::execution::execute(executor, std::forward<F>(func));
    //    }
    //
    //    template<typename F> decltype(auto) execute(ExecutionContext& executionContext, F&& func) {
    //        // NOTE: If no executor is specified, execute to the current executor.
    //        return asio::execution::execute(executionContext.getExecutor(), std::forward<F>(func));
    //    }
    //
    //    template<typename F> decltype(auto) execute(F&& func) {
    //        // NOTE: If no executor is specified, execute to the current executor.
    //        return asio::execution::execute(ExecutionContext::get(), std::forward<F>(func));
    //    }
 
    using asio::dispatch;
    using asio::post;
    using asio::execution::execute;
 
    // ---------------------------------------------------------------------------------------------
 
    template<traits::executor Executor> auto with(Executor executor) {
        return async<void>([executor = std::move(executor)](auto&& promise) {
            return execute(std::move(executor), [promise = std::forward<decltype(promise)>(promise)]() mutable {
                promise.set_value();
            });
        });
    }
 
    inline auto with(ExecutionContext& context) {
        return with(context.getExecutor());
    }
 
    template<traits::executor Executor, typename Func> auto with(Executor executor, Func&& func) {
        return with(std::move(executor)).then(std::forward<Func>(func)); //
    }
 
    template<typename Func> auto with(ExecutionContext& context, Func&& func) {
        return with(context).then(std::forward<Func>(func)); //
    }
 
    using ExecutorWorkGuard = asio::executor_work_guard<AnyExecutor>;
 
    using asio::can_prefer;
    using asio::can_prefer_v;
    using asio::prefer;
 
    using asio::can_query;
    using asio::can_query_v;
    using asio::query;
 
    using asio::can_require;
    using asio::can_require_v;
    using asio::require;
 
    constexpr std::size_t hardware_concurrency() noexcept {
        // Cache the value because calculating it may be expensive
        if(std::is_constant_evaluated()) {
            return 1;
        } else {
            // Return at least 1 core
            return (std::max)(std::size_t(1), std::size_t(std::thread::hardware_concurrency()));
        }
    }
 
    // ---------------------------------------------------------------------------------------------
 
    class InlineExecutor {
    public:
        [[nodiscard]] friend constexpr bool operator==(const InlineExecutor& lhs, const InlineExecutor& rhs) noexcept { return true; }
 
        [[nodiscard]] friend constexpr bool operator!=(const InlineExecutor& lhs, const InlineExecutor& rhs) noexcept { return !(lhs == rhs); }
 
    private:
        friend struct asio_query_fn::impl;
        friend struct ExecutorMapping::mapping_t<0>::mapping_t;
        friend struct ExecutorBlocking::blocking_t<0>::blocking_t;
        friend struct ExecutorRelationship::relationship_t<0>::relationship_t;
        friend struct ExecutorOutstandingWork::outstanding_work_t<0>::outstanding_work_t;
        friend struct ExecutorBulkGuarantee::bulk_guarantee_t<0>::bulk_guarantee_t;
        friend struct ExecutorOccupancy::occupancy_t<0>::occupancy_t;
 
        [[nodiscard]] static constexpr ExecutorMapping::other_t query(ExecutorMapping) noexcept { return ExecutorMapping::other; }
 
        [[nodiscard]] static constexpr ExecutorBlocking::always_t query(ExecutorBlocking) noexcept { return ExecutorBlocking::always; }
 
        [[nodiscard]] static constexpr ExecutorRelationship::continuation_t query(ExecutorRelationship) noexcept { return ExecutorRelationship::continuation; }
 
        [[nodiscard]] static constexpr ExecutorOutstandingWork::untracked_t query(ExecutorOutstandingWork) noexcept {
            return ExecutorOutstandingWork::untracked;
        }
 
        [[nodiscard]] static constexpr ExecutorBulkGuarantee::sequenced_t query(ExecutorBulkGuarantee) noexcept { return ExecutorBulkGuarantee::sequenced; }
 
        [[nodiscard]] static constexpr std::size_t query(ExecutorOccupancy) noexcept { return 1; }
 
    private:
        friend struct asio_execution_execute_fn::impl;
 
        template<typename Function> static constexpr void execute(Function&& f) { std::move(f)(); }
    };
 
    inline constexpr auto make_inline_executor() { return InlineExecutor(); }
 
    namespace traits {
        template<class T> struct is_inline_executor : std::conjunction<std::is_same<std::decay_t<T>, InlineExecutor>> {};
 
        template<typename T> constexpr bool is_inline_executor_v = is_inline_executor<T>::value;
 
        template<typename T>
        concept inline_executor = is_inline_executor_v<T>;
    } // namespace traits
 
    // ---------------------------------------------------------------------------------------------
 
    class ThreadExecutor {
    public:
        [[nodiscard]] friend constexpr bool operator==(const ThreadExecutor& lhs, const ThreadExecutor& rhs) noexcept { return true; }
 
        [[nodiscard]] friend constexpr bool operator!=(const ThreadExecutor& lhs, const ThreadExecutor& rhs) noexcept { return !(lhs == rhs); }
 
    private:
        friend struct asio_query_fn::impl;
        friend struct asio::execution::detail::mapping_t<0>;
        friend struct asio::execution::detail::blocking_t<0>;
        friend struct asio::execution::detail::relationship_t<0>;
        friend struct asio::execution::detail::outstanding_work_t<0>;
        friend struct asio::execution::detail::bulk_guarantee_t<0>;
        friend struct asio::execution::detail::occupancy_t<0>;
 
        [[nodiscard]] static constexpr ExecutorMapping::new_thread_t query(ExecutorMapping) noexcept { return ExecutorMapping::new_thread; }
 
        [[nodiscard]] static constexpr ExecutorBlocking::never_t query(ExecutorBlocking) noexcept { return ExecutorBlocking::never; }
 
        [[nodiscard]] static constexpr ExecutorRelationship::continuation_t query(ExecutorRelationship) noexcept { return ExecutorRelationship::continuation; }
 
        [[nodiscard]] static constexpr ExecutorOutstandingWork::untracked_t query(ExecutorOutstandingWork) noexcept {
            return ExecutorOutstandingWork::untracked;
        }
 
        [[nodiscard]] static constexpr ExecutorBulkGuarantee::parallel_t query(ExecutorBulkGuarantee) noexcept { return ExecutorBulkGuarantee::parallel; }
 
        [[nodiscard]] static constexpr std::size_t query(ExecutorOccupancy) noexcept { return hardware_concurrency(); }
 
    private:
        friend struct asio_execution_execute_fn::impl;
 
        template<typename Function> static void execute(Function&& f) { (void)std::async(std::launch::async, std::move(f)); }
    };
 
    inline auto make_thread_executor() { return ThreadExecutor(); }
 
    namespace traits {
        template<class T> struct is_thread_executor : std::conjunction<std::is_same<std::decay_t<T>, ThreadExecutor>> {};
 
        template<typename T> constexpr bool is_thread_executor_v = is_thread_executor<T>::value;
 
        template<typename T>
        concept thread_executor = is_thread_executor_v<T>;
    } // namespace traits
 
    // ---------------------------------------------------------------------------------------------
 
    using DefaultExecutor = ThreadExecutor;
 
    inline auto make_default_executor() { return DefaultExecutor(); }
 
    namespace traits {
        template<class T> struct is_default_executor : std::conjunction<std::is_same<std::decay_t<T>, DefaultExecutor>> {};
 
        template<typename T> constexpr bool is_default_executor_v = is_default_executor<T>::value;
 
        template<typename T>
        concept default_executor = is_default_executor_v<T>;
    } // namespace traits
 
} // namespace CeresEngine