ThreadPool.hpp

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <list>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <span>
#include <thread>
#include <vector>
 
// Project includes
#include "ThreadData.hpp"
#include <dfx-runtime-api/Task.hpp>
#include <dfx-utilities/sync-queues/PriorityStableQueue.hpp>
 
namespace dfx::Runtime
{
class ThreadPool
{
public:
    explicit ThreadPool(std::size_t threadCount = 1);

    ~ThreadPool();

    void addThread(std::size_t count = 1);

    void removeThread(std::size_t count = 1);

    std::size_t threadCount() const noexcept { std::lock_guard lock(_mutexThreads); return _threads.size(); }
 
public:
    void pushTask(Api::TaskPtr task);

    void pushTasks(std::span<Api::TaskPtr> tasks);

    template<Api::DerivedFromTask T, typename ... Args>
    requires std::is_constructible_v<T, Args...>
    void emplaceTask(Args && ... args)
    { pushTask(std::make_unique<T>(std::forward<Args>(args)...)); }
 
public:
    using MaybeThreadData = std::optional<std::reference_wrapper<ThreadData>>;
    using MaybeCThreadData = std::optional<std::reference_wrapper<ThreadData const>>;

    MaybeThreadData threadData();

    MaybeCThreadData threadData() const;
 
private:
    void _work(std::stop_token stopToken);
 
private:
    Utils::PriorityStableQueue<Api::TaskPtr> _queue;
 
private:
    // Use a list instead of a map so interators and references
    // aren't invalidated when inserting / removing elements
    std::list<ThreadData>     _threadDatas;
    mutable std::shared_mutex _mutexThreadData;
 
private:
    mutable std::mutex        _mutexThreads;
    // The threads have to be delete first in the dtor
    std::vector<std::jthread> _threads;
};
} // !namespace dfx::Runtime