MovieSceneTaskScheduler.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/SparseBitSet.h"
#include "Containers/Map.h"
#include "Containers/Array.h"
#include "Tasks/Task.h"
#include "Containers/LockFreeList.h"
#include "Containers/StringView.h"
#include "EntitySystem/RelativePtr.h"
#include "EntitySystem/IMovieSceneTaskScheduler.h"
#include "EntitySystem/MovieSceneEntityManager.h"
#include "EntitySystem/MovieSceneMaybeAtomic.h"
#include "Misc/TransactionallySafeCriticalSection.h"
 
namespace UE::MovieScene
{
 
struct FTaskExecutionFlags;
class FEntitySystemScheduler;
 
using FTaskBitSet = TDynamicSparseBitSet<uint32, TDynamicSparseBitSetBucketStorage<uint16, 0>>; // Buckets of 512 task bits
 
struct FTaskPrerequisiteCache
{
    FTaskBitSet SystemWidePrerequisites;
 
    FTaskBitSet ForcedSystemWidePrerequisites;
 
    void Reset()
    {
        SystemWidePrerequisites = FTaskBitSet();
        ForcedSystemWidePrerequisites = FTaskBitSet();
    }
};
 
struct FScheduledTaskFuncionPtr
{
    enum class EType : uint8
    {
        None,
        Unbound,
        AllocationPtr,
        AllocationItem,
        PreLockedAllocationItem
    };
 
    EType Assign(UnboundTaskFunctionPtr InUnboundTask)
    {
        UnboundTask = InUnboundTask;
        return EType::Unbound;
    }
    EType Assign(AllocationFunctionPtr InAllocation)
    {
        Allocation = InAllocation;
        return EType::AllocationPtr;
    }
    EType Assign(AllocationItemFunctionPtr InAllocationItem)
    {
        AllocationItem = InAllocationItem;
        return EType::AllocationItem;
    }
    EType Assign(PreLockedAllocationItemFunctionPtr InPreLockedAllocationItem)
    {
        PreLockedAllocationItem = InPreLockedAllocationItem;
        return EType::PreLockedAllocationItem;
    }
 
    union
    {
        UnboundTaskFunctionPtr             UnboundTask;
        AllocationFunctionPtr              Allocation;
        AllocationItemFunctionPtr          AllocationItem;
        PreLockedAllocationItemFunctionPtr PreLockedAllocationItem;
    };
};
 
struct FScheduledTask
{
    explicit FScheduledTask(FEntityAllocationWriteContext InWriteContextOffset);
    ~FScheduledTask();
 
    FScheduledTask(FScheduledTask&& InTask);
 
    struct FLockedComponentData
    {
        TArray<FPreLockedDataPtr> PreLockedComponentData;
        uint16 AllocationIndex = MAX_uint16;
    };
 
    void Run(const FEntitySystemScheduler* Scheduler, FTaskExecutionFlags InFlags) const;
 
    void SetFunction(TaskFunctionPtr InFunction);
 
    FTaskBitSet ComputedSubsequents;
    FTaskBitSet ChildTasks;
 
    FScheduledTaskFuncionPtr TaskFunction;
 
    TSharedPtr<ITaskContext> TaskContext = nullptr;
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    FString DebugName;
#endif
 
    TStatId StatId;
    FEntityAllocationWriteContext WriteContextOffset;
 
    FLockedComponentData LockedComponentData;
 
    int32 NumPrerequisites = 0;
    mutable FEntitySystemMaybeAtomicInt32 WaitCount = 0;
    mutable FEntitySystemMaybeAtomicInt32 ChildCompleteCount = 0;
 
    FTaskID Parent;
 
    uint16 NumChildren = 0;
 
    FScheduledTaskFuncionPtr::EType TaskFunctionType;
 
    uint8 bForceGameThread : 1;
 
    uint8 bForceInline : 1;
};
 
class FEntitySystemScheduler : public IEntitySystemScheduler
{
public:
 
    explicit FEntitySystemScheduler(FEntityManager* InEntityManager);
 
    ~FEntitySystemScheduler();
 
    static bool IsCustomSchedulingEnabled();
 
public:
 
    void BeginConstruction();
 
    void BeginSystem(uint16 NodeID);
 
    bool HasAnyTasksToPropagateDownstream() const;
 
    void PropagatePrerequisite(uint16 ToNodeID);
 
    void EndSystem(uint16 NodeID);
 
    void EndConstruction();
 
public:
    /*~ Builder functionality */
 
    template<typename TaskType, typename ...TaskArgTypes>
    FTaskID AddTask(const FTaskParams& InParams, TaskArgTypes&&... Args)
    {
        struct FExecute
        {
            static void Execute(const ITaskContext* Context, FEntityAllocationWriteContext WriteContext)
            {
                static_cast<const TaskType*>(Context)->Run(WriteContext);
            }
        };
 
        TaskFunctionPtr Function(TInPlaceType<UnboundTaskFunctionPtr>(), FExecute::Execute);
        return AddTask(InParams, MakeShared<TaskType>(Forward<TaskArgTypes>(Args)...), Function);
    }
 
    FTaskID AddNullTask();
 
    FTaskID AddTask(const FTaskParams& InParams, TSharedPtr<ITaskContext> InTaskContext, TaskFunctionPtr InTaskFunction);
 
    FTaskID CreateForkedAllocationTask(const FTaskParams& InParams, TSharedPtr<ITaskContext> InTaskContext, TaskFunctionPtr InTaskFunction, TFunctionRef<void(FEntityAllocationIteratorItem,TArray<FPreLockedDataPtr>&)> InPreLockFunc, const FEntityComponentFilter& Filter, const FComponentMask& ReadDeps, const FComponentMask& WriteDeps);
 
    void AddPrerequisite(FTaskID Prerequisite, FTaskID Subsequent);
 
    void AddChildBack(FTaskID Parent, FTaskID Child);
 
    void AddChildFront(FTaskID Parent, FTaskID Child);
 
    void ShuffleTasks();
 
    /*~ End Builder functionality */
 
public:
 
    /*~ Execution functionality */
 
    const FEntityManager* GetEntityManager() const
    {
        return EntityManager;
    }
 
    FEntityAllocationWriteContext GetWriteContextOffset() const
    {
        return WriteContextBase;
    }
 
    void ExecuteTasks();
 
    void CompleteTask(const FScheduledTask* Task, FTaskExecutionFlags InFlags) const;
 
    void PrerequisiteCompleted(FTaskID TaskID, int32* OptRunInlineIndex) const;
    void PrerequisiteCompleted(const FScheduledTask* Task, int32* OptRunInlineIndex) const;
 
    void OnAllTasksFinished() const;
 
    /*~ End execution functionality */
 
public:
 
    FString ToString() const;
 
private:
    TArray<FScheduledTask> Tasks;
 
    FTaskPrerequisiteCache* CurrentPrerequisites = nullptr;
 
    FTaskPrerequisiteCache CurrentSubsequents;
 
    FTaskBitSet InitialTasks;
 
    struct FComponentDependencies
    {
        FTaskBitSet ReadTasks;
        FTaskID WriteTask;
    };
    TMap<TPair<int32, FComponentTypeID>, FComponentDependencies> ComponentDepedenciesByAllocation;
 
    TMap<uint16, FTaskPrerequisiteCache> AllPrerequisites;
 
    FEntityManager* EntityManager;
 
    mutable FEntitySystemMaybeAtomicInt32 NumTasksRemaining = 0;
 
    FEvent* GameThreadSignal = nullptr;
    mutable TLockFreePointerListFIFO<FScheduledTask, PLATFORM_CACHE_LINE_SIZE> GameThreadTaskList;
    FEntityAllocationWriteContext WriteContextBase = FEntityAllocationWriteContext::NewAllocation();
    uint32 SystemSerialIncrement = 0;
    EEntityThreadingModel ThreadingModel = EEntityThreadingModel::NoThreading;
};
 
 
} // namespace UE::MovieScene