TaskManager.h

#pragma once
 
#include "Base.h"
 
#include <functional>
#include <memory>
#include <string_view>
 
namespace Cogs
{
  namespace Core
  {
    using TaskQueueId = uint16_t;
 
    struct TaskId
    {
      uint32_t taskHandle = static_cast<uint32_t>(-1);
      uint16_t generation = 0;
      TaskQueueId queueId = 0;
 
      [[nodiscard]] bool isValid() const { return taskHandle != static_cast<uint32_t>(-1); }
 
      [[nodiscard]] bool operator ==(const TaskId& rhs) const   { return taskHandle == rhs.taskHandle; }
    };
 
    static constexpr TaskId NoTask = { static_cast<uint32_t>(-1), 0, 0 };
 
    using TaskFunction = std::function<void ()>;
    using TaskFunctionRef = const TaskFunction&;
 
    struct QueueState
    {
      float load = 0.f;
      float tasksPerSecond = 0.f;
      float tasksPerFrame = 0.f;
    };
 
    struct QueueWorkerState
    {
      float utilization = 0.f;
      float tasksPerSecond = 0.f;
      float tasksPerFrame = 0.f;
    };
 
    class COGSCORE_DLL_API TaskManager
    {
    public:
      TaskManager(Context* context);
 
      ~TaskManager();
 
      void updateState(Context* context);
 
      size_t getQueueCount() const;
 
#ifdef EMSCRIPTEN
      // Under emscripten, we want to maintain control over thread spawning, so only the
      // TaskManager is allowed to create queues (which spwans threads).
      // Thus, createQueue is made private to avoid anyone accidentally creating a queue.
    private:
#endif
      [[nodiscard]] TaskQueueId createQueue(std::string_view name, const size_t numThreads);
#ifdef EMSCRIPTEN
    public:
#endif
 
      const std::string& getQueueName(TaskQueueId queue) const;
 
      void getQueueState(QueueState& queueState, std::vector<QueueWorkerState>& workerStates, TaskQueueId queue) const;
 
      [[nodiscard]] size_t getQueueConcurrency(TaskQueueId queue);
 
      [[nodiscard]] bool onMainThread() const;
 
      [[nodiscard]] TaskId createGroup(TaskQueueId queue = GlobalQueue);
 
      [[nodiscard]] TaskId create(TaskQueueId queue, TaskFunctionRef func);
 
      [[nodiscard]] TaskId createChild(const TaskId & parentTask, TaskFunctionRef func);
 
      void enqueue(const TaskId & taskId);
 
      TaskId enqueueChild(const TaskId & parentTask, TaskFunctionRef func);
 
      TaskId enqueue(TaskQueueId queue, TaskFunctionRef func);
 
      void destroy(const TaskId & taskId);
 
      [[nodiscard]] bool isActive(const TaskId& taskId);
 
      void wait(const TaskId & taskId);
 
      void waitAll(TaskQueueId queueId);
 
      void waitAll();
 
      static constexpr TaskQueueId GlobalQueue = 0U;
 
      static constexpr TaskQueueId ResourceQueue = 1U;
 
    private:
      class TaskQueue* getQueue(TaskQueueId queueId);
 
    private:
      std::unique_ptr<class TaskQueues> taskQueues;
    };
  }
}