Class ThreadPool

include/tev/ThreadPool.h:37–196

namespace tev {

class ThreadPool {
public:
    ThreadPool();
    ThreadPool(size_t maxNumThreads, bool force = false);
    virtual ~ThreadPool();

    static ThreadPool& global() {
        static ThreadPool pool;
        return pool;
    }

    template <std::invocable F> auto enqueueTask(F&& f, int priority, bool stopToken = false) {
        using return_type = std::invoke_result_t<F>;

        const auto task = std::make_shared<std::packaged_task<return_type()>>(std::forward<F>(f));
        auto res = task->get_future();

        if (mShuttingDown) {
            return res;
        }

        {
            const std::scoped_lock lock{mTaskQueueMutex};
            mTaskQueue.push({
                .fun = [task]() { (*task)(); },
                .priority = priority,
                .stopToken = stopToken,
            });
        }

        ++mNumTasksInSystem;
        mTaskQueueSemaphore.signal();

        return res;
    }

    auto enqueueStopToken() {
        return enqueueTask([] {}, std::numeric_limits<int>::max(), true);
    }

    inline auto enqueueCoroutine(int priority) noexcept {
        class Awaiter {
        public:
            Awaiter(ThreadPool* pool, int priority) : mPool{pool}, mPriority{priority} {}

            bool await_ready() const noexcept { return false; }

            // Suspend and enqueue coroutine continuation onto the threadpool
            void await_suspend(std::coroutine_handle<> coroutine) noexcept { mPool->enqueueTask(coroutine, mPriority); }

            void await_resume() const noexcept {}

        private:
            ThreadPool* mPool;
            int mPriority;
        };

        return Awaiter{this, priority};