InterchangeTaskSystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/Future.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/Ticker.h"
#include "HAL/CriticalSection.h"
#include "Misc/ScopeLock.h"
 
#define INTERCHANGE_INVALID_TASK_ID 0xFFFFFFFFFFFFFFFF
 
DECLARE_MULTICAST_DELEGATE(FOnInterchangeTaskSystemTick)
 
namespace UE::Interchange
{
    //Forward declare to add it has friend
    class FInterchangeTaskSystem;
 
    enum class EInterchangeTaskStatus : uint8
    {
        Waiting, //Task is queue for execution when prerequisite are terminate and resource are available
        Executing, //Task is being executing
        Done //Task was execute and is now terminate
    };
 
    enum class EInterchangeTaskThread : uint8
    {
        GameThread, //Task will be tick in a ticker in the engine tick on the game thread. This is a safe place to manipulate UObject
        AsyncThread //Task will be call on asynchronous thread, code running inside those task must be thread safe.
    };
 
    class FInterchangeTaskBase
    {
    public:
        FInterchangeTaskBase()
        {}
 
        virtual ~FInterchangeTaskBase()
        {
            if (GetTaskStatus() == EInterchangeTaskStatus::Executing)
            {
                if (Future.IsValid())
                {
                    Future.Get();
                }
            }
        }
 
        uint64 GetTaskId() const
        {
            return TaskId;
        }
 
        virtual EInterchangeTaskThread GetTaskThread() const
        {
            return EInterchangeTaskThread::GameThread;
        }
 
        const TArray<uint64>& GetPrerequisiteTasks() const
        {
            return PrerequisiteTasks;
        }
 
        EInterchangeTaskStatus GetTaskStatus() const
        {
            FScopeLock TaskStatusLock(&TaskStatusCriticalSection);
            return TaskStatus;
        }
 
        virtual void Execute() = 0;
 
        INTERCHANGECORE_API void Wait() const;
    protected:
 
        //Only friend FInterchangeTaskSystem can set a new status
        INTERCHANGECORE_API bool SetTaskStatus(EInterchangeTaskStatus NewTaskStatus);
 
        INTERCHANGECORE_API void SetPrerequisites(const TArray<uint64>& InPrerequisiteTasks);
 
    private:
 
        mutable FCriticalSection TaskStatusCriticalSection;
        uint64 TaskId = INTERCHANGE_INVALID_TASK_ID;
        EInterchangeTaskStatus TaskStatus = EInterchangeTaskStatus::Waiting;
        TArray<uint64> PrerequisiteTasks;
 
        //If a task is asynchronous the future will be set.
        //The future will contain the task id when it will be ready.
        TFuture<uint64> Future;
 
        friend FInterchangeTaskSystem;
    };
 
    class FInterchangeTaskLambda : public FInterchangeTaskBase
    {
    private:
        EInterchangeTaskThread TaskThread = EInterchangeTaskThread::GameThread;
        TFunction<void()> ExecuteLambda;
        
 
    public:
        FInterchangeTaskLambda(EInterchangeTaskThread InTaskThread, TFunction<void()> InExecuteLambda)
            : TaskThread(InTaskThread)
            , ExecuteLambda(MoveTemp(InExecuteLambda))
        {
        }
 
        virtual EInterchangeTaskThread GetTaskThread() const override
        {
            return TaskThread;
        }
 
        virtual void Execute()
        {
            ExecuteLambda();
        }
    };
 
    class FInterchangeTaskSystem
    {
    public:
        FInterchangeTaskSystem();
 
        //The interchange task system is a singleton
        static INTERCHANGECORE_API FInterchangeTaskSystem& Get();
 
        INTERCHANGECORE_API uint64 AddTask(TSharedPtr<FInterchangeTaskBase, ESPMode::ThreadSafe> Task, TArray<uint64>& TaskPrerequisites);
 
        INTERCHANGECORE_API uint64 AddTask(TSharedPtr<FInterchangeTaskBase, ESPMode::ThreadSafe> Task);
 
        INTERCHANGECORE_API EInterchangeTaskStatus GetTaskStatus(const uint64 TaskId) const;
 
        INTERCHANGECORE_API void CancelTask(const uint64 TaskId, const bool bCancelPrerequisites);
 
        INTERCHANGECORE_API void WaitUntilTasksComplete(const TArray<uint64>& TasksToComplete);
 
        FOnInterchangeTaskSystemTick& OnTaskSystemTickDelegate()
        {
            return OnTaskSystemTick;
        }
 
    private:
 
        static bool bIsCreatingSingleton;
 
        FOnInterchangeTaskSystemTick OnTaskSystemTick;
 
        //Internal cancel request with no lock, lock is handle by the caller (CancelTask)
        void InternalAddCancelRequestNoLock(const uint64 TaskId, bool bCancelPrerequisites);
 
        void Tick();
 
        //The ticker we use to tick in the engine tick
        FTSTicker::FDelegateHandle  TickTickerHandle;
 
        // Store the tasks per id
        TMap<uint64, TSharedPtr<FInterchangeTaskBase, ESPMode::ThreadSafe>> TaskPerIdMap;
        mutable FCriticalSection TaskPerIdMapCriticalSection;
 
        //When a task is done, we add it here and release the task. Prerequisite are search in the list and here.
        //A clean up is done when the TaskPerIdMap is empty.
        TSet<uint64> ReleaseAndDoneTasks;
 
        //The priority value is a counter that is increment for each task added to the system to create the task id
        //The lower task id are execute earlier if possible.
        uint64 PriorityValue = 0;
        FCriticalSection PriorityValueCriticalSection;
 
        TArray<uint64> CancelTaskRequests;
        FCriticalSection CancelTaskRequestsCriticalSection;
    };
} //namespace UE::Interchange