TaskSystem.h

#pragma once
 
#include <Foundation/Containers/DynamicArray.h>
#include <Foundation/Containers/List.h>
#include <Foundation/Threading/Implementation/Task.h>
#include <Foundation/Threading/Mutex.h>
#include <Foundation/Types/SharedPtr.h>
 
class PL_FOUNDATION_DLL plTaskSystem
{
public:
 
public:
  static plTaskGroupID StartSingleTask(const plSharedPtr<plTask>& pTask, plTaskPriority::Enum priority,
    plOnTaskGroupFinishedCallback callback = plOnTaskGroupFinishedCallback()); // [tested]
 
  static plTaskGroupID StartSingleTask(const plSharedPtr<plTask>& pTask, plTaskPriority::Enum priority, plTaskGroupID dependency,
    plOnTaskGroupFinishedCallback callback = plOnTaskGroupFinishedCallback()); // [tested]
 
  static void FinishFrameTasks(); // [tested]
 
  static plResult CancelTask(const plSharedPtr<plTask>& pTask, plOnTaskRunning::Enum onTaskRunning = plOnTaskRunning::WaitTillFinished); // [tested]
 
  struct TaskData
  {
    plSharedPtr<plTask> m_pTask;
    plTaskGroup* m_pBelongsToGroup = nullptr;
    plUInt32 m_uiInvocation = 0;
  };
 
private:
  static TaskData GetNextTask(plTaskPriority::Enum FirstPriority, plTaskPriority::Enum LastPriority, bool bOnlyTasksThatNeverWait,
    const plTaskGroupID& WaitingForGroup, plAtomicInteger32* pWorkerState);
 
  static bool ExecuteTask(plTaskPriority::Enum FirstPriority, plTaskPriority::Enum LastPriority, bool bOnlyTasksThatNeverWait,
    const plTaskGroupID& WaitingForGroup, plAtomicInteger32* pWorkerState);
 
  static void TaskHasFinished(plSharedPtr<plTask>&& pTask, plTaskGroup* pGroup);
 
  static void ReprioritizeFrameTasks();
 
  static void ExecuteSomeFrameTasks(plTime smoothFrameTime);
 
 
  static bool HelpExecutingTasks(const plTaskGroupID& WaitingForGroup);
 
 
 
public:
  static plTaskGroupID CreateTaskGroup(
    plTaskPriority::Enum priority, plOnTaskGroupFinishedCallback callback = plOnTaskGroupFinishedCallback()); // [tested]
 
  static void AddTaskToGroup(plTaskGroupID group, const plSharedPtr<plTask>& pTask); // [tested]
 
  static void AddTaskGroupDependency(plTaskGroupID group, plTaskGroupID dependsOn); // [tested]
 
  static void AddTaskGroupDependencyBatch(plArrayPtr<const plTaskGroupDependency> batch);
 
  static void StartTaskGroup(plTaskGroupID group); // [tested]
 
  static void StartTaskGroupBatch(plArrayPtr<const plTaskGroupID> batch);
 
  static bool IsTaskGroupFinished(plTaskGroupID group); // [tested]
 
  static plResult CancelGroup(plTaskGroupID group, plOnTaskRunning::Enum onTaskRunning = plOnTaskRunning::WaitTillFinished); // [tested]
 
  static void WaitForGroup(plTaskGroupID group); // [tested]
 
  static void WaitForCondition(plDelegate<bool()> condition);
 
private:
  static void ScheduleGroupTasks(plTaskGroup* pGroup, bool bHighPriority);
 
  static void DependencyHasFinished(plTaskGroup* pGroup);
 
 
 
public:
  static void SetWorkerThreadCount(plInt32 iShortTasks = -1, plInt32 iLongTasks = -1); // [tested]
 
  static plUInt32 GetWorkerThreadCount(plWorkerThreadType::Enum type);
 
  static plUInt32 GetNumAllocatedWorkerThreads(plWorkerThreadType::Enum type);
 
  static plWorkerThreadType::Enum GetCurrentThreadWorkerType();
 
  static double GetThreadUtilization(plWorkerThreadType::Enum type, plUInt32 uiThreadIndex, plUInt32* pNumTasksExecuted = nullptr);
 
  static void WakeUpThreads(plWorkerThreadType::Enum type, plUInt32 uiNumThreads);
 
private:
  friend class plTaskWorkerThread;
 
  static void AllocateThreads(plWorkerThreadType::Enum type, plUInt32 uiAddThreads);
 
  static void StopWorkerThreads();
 
  static void DetermineTasksToExecuteOnThread(plTaskPriority::Enum& out_FirstPriority, plTaskPriority::Enum& out_LastPriority);
 
private:
  static plUniquePtr<plTaskSystemThreadState> s_pThreadState;
 
 
 
public:
  static void ParallelForIndexed(plUInt32 uiStartIndex, plUInt32 uiNumItems, plParallelForIndexedFunction32 taskCallback,
    const char* szTaskName = nullptr, plTaskNesting taskNesting = plTaskNesting::Never, const plParallelForParams& params = plParallelForParams());
 
  static void ParallelForIndexed(plUInt64 uiStartIndex, plUInt64 uiNumItems, plParallelForIndexedFunction64 taskCallback,
    const char* szTaskName = nullptr, plTaskNesting taskNesting = plTaskNesting::Never, const plParallelForParams& params = plParallelForParams());
 
  template <typename ElemType, typename Callback>
  static void ParallelFor(
    plArrayPtr<ElemType> taskItems, Callback taskCallback, const char* szTaskName = nullptr, const plParallelForParams& params = plParallelForParams());
  template <typename ElemType, typename Callback>
  static void ParallelForSingle(
    plArrayPtr<ElemType> taskItems, Callback taskCallback, const char* szTaskName = nullptr, const plParallelForParams& params = plParallelForParams());
  template <typename ElemType, typename Callback>
  static void ParallelForSingleIndex(
    plArrayPtr<ElemType> taskItems, Callback taskCallback, const char* szTaskName = nullptr, const plParallelForParams& params = plParallelForParams());
 
private:
  template <typename ElemType>
  static void ParallelForInternal(
    plArrayPtr<ElemType> taskItems, plParallelForFunction<ElemType> taskCallback, const char* taskName, const plParallelForParams& params);
 
 
 
public:
  static void WriteStateSnapshotToDGML(plDGMLGraph& ref_graph);
 
  static void WriteStateSnapshotToFile(const char* szPath = nullptr);
 
private:
 
 
public:
  static void SetTargetFrameTime(plTime targetFrameTime = plTime::MakeFromSeconds(1.0 / 40.0) /* 40 FPS -> 25 ms */);
 
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Foundation, TaskSystem);
 
  static void Startup();
  static void Shutdown();
 
private:
  static plMutex s_TaskSystemMutex;
 
  static plUniquePtr<plTaskSystemState> s_pState;
 
};
 
#include <Foundation/Threading/Implementation/ParallelFor_inl.h>