TaskSystemDeclarations.h

#pragma once
 
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Threading/ConditionVariable.h>
#include <Foundation/Time/Time.h>
#include <Foundation/Types/Delegate.h>
#include <Foundation/Types/SharedPtr.h>
#include <Foundation/Types/UniquePtr.h>
 
class plTask;
class plTaskGroup;
class plTaskWorkerThread;
class plTaskSystemState;
class plTaskSystemThreadState;
class plDGMLGraph;
class plAllocator;
 
struct plTaskPriority
{
  // clang-format off
  enum Enum : plUInt8
  {
    EarlyThisFrame,           
    ThisFrame,                
    LateThisFrame,            
    EarlyNextFrame,           
    NextFrame,                
    LateNextFrame,            
 
    In2Frames,                
    In3Frames,                
    In4Frames,                
    In5Frames,                
    In6Frames,                
    In7Frames,                
    In8Frames,                
    In9Frames,                
 
    LongRunningHighPriority,  
    LongRunning,              
    FileAccessHighPriority,   
    FileAccess,               
    ThisFrameMainThread,      
    SomeFrameMainThread,      
 
    ENUM_COUNT
  };
  // clang-format on
};
 
struct plOnTaskRunning
{
  enum Enum : plUInt8
  {
    WaitTillFinished,
    ReturnWithoutBlocking
  };
};
 
struct plWorkerThreadType
{
  enum Enum : plUInt8
  {
    Unknown,    
    MainThread, 
    ShortTasks,
    LongTasks,
    FileAccess,
    ENUM_COUNT
  };
 
  static const char* GetThreadTypeName(plWorkerThreadType::Enum threadType);
};
 
class PL_FOUNDATION_DLL plTaskGroupID
{
public:
  PL_ALWAYS_INLINE plTaskGroupID() = default;
  PL_ALWAYS_INLINE ~plTaskGroupID() = default;
 
  PL_ALWAYS_INLINE bool IsValid() const { return m_pTaskGroup != nullptr; }
 
  PL_ALWAYS_INLINE void Invalidate() { m_pTaskGroup = nullptr; }
 
  PL_ALWAYS_INLINE bool operator==(const plTaskGroupID& other) const
  {
    return m_pTaskGroup == other.m_pTaskGroup && m_uiGroupCounter == other.m_uiGroupCounter;
  }
  PL_ALWAYS_INLINE bool operator!=(const plTaskGroupID& other) const
  {
    return m_pTaskGroup != other.m_pTaskGroup || m_uiGroupCounter != other.m_uiGroupCounter;
  }
  PL_ALWAYS_INLINE bool operator<(const plTaskGroupID& other) const
  {
    return m_pTaskGroup < other.m_pTaskGroup || (m_pTaskGroup == other.m_pTaskGroup && m_uiGroupCounter < other.m_uiGroupCounter);
  }
 
private:
  friend class plTaskSystem;
  friend class plTaskGroup;
 
  // the counter is used to determine whether this group id references the 'same' group, as m_pTaskGroup.
  // if m_pTaskGroup->m_uiGroupCounter is different to this->m_uiGroupCounter, then the group ID is not valid anymore.
  plUInt32 m_uiGroupCounter = 0;
 
  // points to the actual task group object
  plTaskGroup* m_pTaskGroup = nullptr;
};
 
using plOnTaskGroupFinishedCallback = plDelegate<void(plTaskGroupID)>;
 
using plOnTaskFinishedCallback = plDelegate<void(const plSharedPtr<plTask>&)>;
 
struct plTaskGroupDependency
{
  PL_DECLARE_POD_TYPE();
 
  plTaskGroupID m_TaskGroup;
  plTaskGroupID m_DependsOn;
};
 
enum class plTaskNesting
{
  Maybe,
  Never,
};
 
struct PL_FOUNDATION_DLL plParallelForParams
{
  plParallelForParams() = default; // do not remove, needed for Clang
 
  plUInt32 m_uiBinSize = 1;
 
  plUInt32 m_uiMaxTasksPerThread = 2;
 
  plTaskNesting m_NestingMode = plTaskNesting::Never;
 
  plAllocator* m_pTaskAllocator = nullptr;
 
  void DetermineThreading(plUInt64 uiNumItemsToExecute, plUInt32& out_uiNumTasksToRun, plUInt64& out_uiNumItemsPerTask) const;
};
 
using plParallelForIndexedFunction32 = plDelegate<void(plUInt32, plUInt32), 48>;
using plParallelForIndexedFunction64 = plDelegate<void(plUInt64, plUInt64), 48>;
 
template <typename ElemType>
using plParallelForFunction = plDelegate<void(plUInt32, plArrayPtr<ElemType>), 48>;
 
enum class plTaskWorkerState
{
  Active = 0,
  Idle = 1,
  Blocked = 2,
};