Win32ThreadPool.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/Threading/DispatchQueue.hpp"
#include "CeresEngine/Foundation/Threading/ThreadPool.hpp"
 
#include <threadpoolapiset.h>
 
namespace CeresEngine {
 
    class Win32ThreadPool final : public virtual DispatchQueue {
    private:
        TP_CALLBACK_ENVIRON mCallbackEnvironments[3];
        PTP_POOL mThreadPool;
 
    public:
        explicit Win32ThreadPool(DispatchQueueType type);
        ~Win32ThreadPool() noexcept final;
 
    public:
        class Executor;
 
    private: // Executor interface
        void onWorkStarted() noexcept;
 
        void onWorkFinished() noexcept;
 
        void schedule(UniqueFunction<void()> function, ExecutorBlocking blockingProperty, ExecutorPriority priority);
 
        [[nodiscard]] PTP_CALLBACK_ENVIRON getCallbackEnvironment(ExecutorPriority priority) noexcept;
 
    public:
        [[nodiscard]] AnyExecutor getExecutor() noexcept final;
 
        void suspend() final;
 
        void resume() final;
 
        [[nodiscard]] UPtr<DispatchQueue> createSubQueue(DispatchQueueType type, StringView name = "") final;
    };
 
    class Win32ThreadPool::Executor {
        friend class Win32ThreadPool;
 
    private:
        Win32ThreadPool* mExecutionContext;
 
        ExecutorBlocking mBlockingProperty = ExecutorBlocking::never;
 
        ExecutorPriority mPriority = ExecutorPriority::Normal;
 
    private:
        explicit Executor(Win32ThreadPool* const executionContext, const ExecutorBlocking blockingProperty = ExecutorBlocking::never,
            const ExecutorPriority priority = ExecutorPriority::Normal)
                : mExecutionContext(executionContext), mBlockingProperty(blockingProperty), mPriority(priority) {}
 
    public:
        Executor(const Executor&) = default;
        Executor& operator=(const Executor&) = default;
        Executor(Executor&&) = default;
        Executor& operator=(Executor&&) = default;
 
    public:
        [[nodiscard]] Win32ThreadPool& context() const noexcept { return *mExecutionContext; }
 
        void on_work_started() const noexcept {
            CE_ASSERT(mExecutionContext != nullptr);
            mExecutionContext->onWorkStarted();
        }
 
        void on_work_finished() const noexcept {
            CE_ASSERT(mExecutionContext != nullptr);
            mExecutionContext->onWorkFinished();
        }
 
    public:
        [[nodiscard]] friend bool operator==(const Executor&, const Executor&) noexcept { return true; }
 
        [[nodiscard]] friend bool operator!=(const Executor&, const Executor&) noexcept { return false; }
 
    private:
        friend struct asio_query_fn::impl;
        friend struct asio::execution::detail::context_t<0>;
        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]] Win32ThreadPool& query(ExecutorExecutionContext) const noexcept { return *mExecutionContext; }
 
        [[nodiscard]] static constexpr ExecutorMapping query(ExecutorMapping) noexcept { return ExecutorMapping::other; }
 
        [[nodiscard]] ExecutorBlocking query(ExecutorBlocking) const noexcept { return mBlockingProperty; }
 
        [[nodiscard]] static constexpr ExecutorRelationship query(ExecutorRelationship) noexcept { return ExecutorRelationship::continuation; }
 
        [[nodiscard]] static constexpr ExecutorOutstandingWork query(ExecutorOutstandingWork) noexcept { return ExecutorOutstandingWork::tracked; }
 
        [[nodiscard]] static constexpr ExecutorBulkGuarantee query(ExecutorBulkGuarantee) noexcept { return ExecutorBulkGuarantee::sequenced; }
 
        [[nodiscard]] std::size_t query(ExecutorOccupancy) const noexcept { return std::thread::hardware_concurrency(); }
 
        template<typename OtherAllocator> [[nodiscard]] std::allocator<void> query(ExecutorAllocator<OtherAllocator>) const noexcept {
            static std::allocator<void> allocator;
            return allocator;
        }
 
        [[nodiscard]] std::allocator<void> query(ExecutorAllocator<void>) const noexcept {
            static std::allocator<void> allocator;
            return allocator;
        }
 
    private: // Prefer
        friend struct asio_require_fn::impl;
        friend struct asio_prefer_fn::impl;
 
        [[nodiscard]] Executor require(const ExecutorBlocking blocking) const { return Executor(mExecutionContext, blocking, mPriority); }
 
        [[nodiscard]] Executor require(const ExecutorPriority newPriority) const { return Executor(mExecutionContext, mBlockingProperty, newPriority); }
 
    private:
        friend struct asio_execution_execute_fn::impl;
 
        template<typename Function> void execute(ASIO_MOVE_ARG(Function) f) const {
            CE_ASSERT(mExecutionContext != nullptr);
            mExecutionContext->schedule(std::forward<Function>(f), mBlockingProperty, mPriority);
        }
    };
 
    inline AnyExecutor Win32ThreadPool::getExecutor() noexcept { return Executor(this); }
 
} // namespace CeresEngine