TaskGraphInterfaces.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    TaskGraphInterfaces.h: TaskGraph library
=============================================================================*/
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "Templates/Function.h"
#include "Delegates/Delegate.h"
#include "HAL/ThreadSafeCounter.h"
#include "Containers/LockFreeList.h"
#include "Stats/Stats.h"
#include "HAL/IConsoleManager.h"
#include "HAL/Event.h"
#include "HAL/LowLevelMemTracker.h"
#include "Templates/RefCounting.h"
#include "Containers/LockFreeFixedSizeAllocator.h"
#include "Experimental/ConcurrentLinearAllocator.h"
#include "Misc/MemStack.h"
#include "Misc/Timeout.h"
#include "Templates/Atomic.h"
#include "Templates/Models.h"
#include "ProfilingDebugging/MetadataTrace.h"
 
#include "Async/Fundamental/Task.h"
 
#include "Async/TaskGraphFwd.h"
#include "Async/TaskTrace.h"
#include "Tasks/TaskPrivate.h"
#include "Async/InheritedContext.h"
 
#if !defined(STATS)
#error "STATS must be defined as either zero or one."
#endif
 
// what level of checking to perform...normally checkSlow but could be ensure or check
#define checkThreadGraph checkSlow
 
//#define checkThreadGraph(x) ((x)||((*(char*)3) = 0))
 
DECLARE_STATS_GROUP(TEXT("Task Graph Tasks"), STATGROUP_TaskGraphTasks, STATCAT_Advanced);
 
DECLARE_CYCLE_STAT_EXTERN(TEXT("FReturnGraphTask"), STAT_FReturnGraphTask, STATGROUP_TaskGraphTasks, CORE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("FTriggerEventGraphTask"), STAT_FTriggerEventGraphTask, STATGROUP_TaskGraphTasks, CORE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("ParallelFor"), STAT_ParallelFor, STATGROUP_TaskGraphTasks, CORE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("ParallelForTask"), STAT_ParallelForTask, STATGROUP_TaskGraphTasks, CORE_API);
 
namespace ENamedThreads
{
    enum Type : int32
    {
        UnusedAnchor = -1,
        RHIThread,
        GameThread,
        // The render thread is sometimes the game thread and is sometimes the actual rendering thread
        ActualRenderingThread = GameThread + 1,
        // CAUTION ThreadedRenderingThread must be the last named thread, insert new named threads before it
 
        AnyThread = 0xff, 
 
        MainQueue =         0x000,
        LocalQueue =        0x100,
 
        NumQueues =         2,
        ThreadIndexMask =   0xff,
        QueueIndexMask =    0x100,
        QueueIndexShift =   8,
 
        NormalTaskPriority =    0x000,
        HighTaskPriority =      0x200,
 
        NumTaskPriorities =     2,
        TaskPriorityMask =      0x200,
        TaskPriorityShift =     9,
 
        NormalThreadPriority = 0x000,
        HighThreadPriority = 0x400,
        BackgroundThreadPriority = 0x800,
 
        NumThreadPriorities = 3,
        ThreadPriorityMask = 0xC00,
        ThreadPriorityShift = 10,
 
        GameThread_Local = GameThread | LocalQueue,
        ActualRenderingThread_Local = ActualRenderingThread | LocalQueue,
 
        AnyHiPriThreadNormalTask = AnyThread | HighThreadPriority | NormalTaskPriority,
        AnyHiPriThreadHiPriTask = AnyThread | HighThreadPriority | HighTaskPriority,
 
        AnyNormalThreadNormalTask = AnyThread | NormalThreadPriority | NormalTaskPriority,
        AnyNormalThreadHiPriTask = AnyThread | NormalThreadPriority | HighTaskPriority,
 
        AnyBackgroundThreadNormalTask = AnyThread | BackgroundThreadPriority | NormalTaskPriority,
        AnyBackgroundHiPriTask = AnyThread | BackgroundThreadPriority | HighTaskPriority,
    };
 
    struct FRenderThreadStatics
    {
    private:
        // These are private to prevent direct access by anything except the friend functions below
        static CORE_API TAtomic<Type> RenderThread;
        static CORE_API TAtomic<Type> RenderThread_Local;
 
        friend Type GetRenderThread();
        friend Type GetRenderThread_Local();
        friend void SetRenderThread(Type Thread);
        friend void SetRenderThread_Local(Type Thread);
    };
 
    UE_FORCEINLINE_HINT Type GetRenderThread()
    {
        return FRenderThreadStatics::RenderThread.Load(EMemoryOrder::Relaxed);
    }
 
    UE_FORCEINLINE_HINT Type GetRenderThread_Local()
    {
        return FRenderThreadStatics::RenderThread_Local.Load(EMemoryOrder::Relaxed);
    }
 
    UE_FORCEINLINE_HINT void SetRenderThread(Type Thread)
    {
        FRenderThreadStatics::RenderThread.Store(Thread, EMemoryOrder::Relaxed);
    }
 
    UE_FORCEINLINE_HINT void SetRenderThread_Local(Type Thread)
    {
        FRenderThreadStatics::RenderThread_Local.Store(Thread, EMemoryOrder::Relaxed);
    }
 
    // these allow external things to make custom decisions based on what sorts of task threads we are running now.
    // this are bools to allow runtime tuning.
    extern CORE_API int32 bHasBackgroundThreads; 
    extern CORE_API int32 bHasHighPriorityThreads;
 
    UE_FORCEINLINE_HINT Type GetThreadIndex(Type ThreadAndIndex)
    {
        return ((ThreadAndIndex & ThreadIndexMask) == AnyThread) ? AnyThread : Type(ThreadAndIndex & ThreadIndexMask);
    }
 
    UE_FORCEINLINE_HINT int32 GetQueueIndex(Type ThreadAndIndex)
    {
        return (ThreadAndIndex & QueueIndexMask) >> QueueIndexShift;
    }
 
    UE_FORCEINLINE_HINT int32 GetTaskPriority(Type ThreadAndIndex)
    {
        return (ThreadAndIndex & TaskPriorityMask) >> TaskPriorityShift;
    }
 
    inline int32 GetThreadPriorityIndex(Type ThreadAndIndex)
    {
        int32 Result = (ThreadAndIndex & ThreadPriorityMask) >> ThreadPriorityShift;
        check(Result >= 0 && Result < NumThreadPriorities);
        return Result;
    }
 
    inline Type SetPriorities(Type ThreadAndIndex, Type ThreadPriority, Type TaskPriority)
    {
        check(
            !(ThreadAndIndex & ~ThreadIndexMask) &&  // not a thread index
            !(ThreadPriority & ~ThreadPriorityMask) && // not a thread priority
            (ThreadPriority & ThreadPriorityMask) != ThreadPriorityMask && // not a valid thread priority
            !(TaskPriority & ~TaskPriorityMask) // not a task priority
            );
        return Type(ThreadAndIndex | ThreadPriority | TaskPriority);
    }
 
    inline Type SetPriorities(Type ThreadAndIndex, int32 PriorityIndex, bool bHiPri)
    {
        check(
            !(ThreadAndIndex & ~ThreadIndexMask) && // not a thread index
            PriorityIndex >= 0 && PriorityIndex < NumThreadPriorities // not a valid thread priority
            );
        return Type(ThreadAndIndex | (PriorityIndex << ThreadPriorityShift) | (bHiPri ? HighTaskPriority : NormalTaskPriority));
    }
 
    inline Type SetThreadPriority(Type ThreadAndIndex, Type ThreadPriority)
    {
        check(
            !(ThreadAndIndex & ~ThreadIndexMask) &&  // not a thread index
            !(ThreadPriority & ~ThreadPriorityMask) && // not a thread priority
            (ThreadPriority & ThreadPriorityMask) != ThreadPriorityMask // not a valid thread priority
            );
        return Type(ThreadAndIndex | ThreadPriority);
    }
 
    inline Type SetTaskPriority(Type ThreadAndIndex, Type TaskPriority)
    {
        check(
            !(ThreadAndIndex & ~ThreadIndexMask) &&  // not a thread index
            !(TaskPriority & ~TaskPriorityMask) // not a task priority
            );
        return Type(ThreadAndIndex | TaskPriority);
    }
}
 
DECLARE_INTRINSIC_TYPE_LAYOUT(ENamedThreads::Type);
 
class FAutoConsoleTaskPriority
{
    FString RawSetting;
    FString FullHelpText;
    FAutoConsoleVariableRef Variable;
    ENamedThreads::Type ThreadPriority;
    ENamedThreads::Type TaskPriority;
    ENamedThreads::Type TaskPriorityIfForcedToNormalThreadPriority;
 
    static FString CreateFullHelpText(const TCHAR* Name, const TCHAR* OriginalHelp);
    static FString ConfigStringFromPriorities(ENamedThreads::Type InThreadPriority, ENamedThreads::Type InTaskPriority, ENamedThreads::Type InTaskPriorityBackup);
    void OnSettingChanged(IConsoleVariable* Variable);
 
public:
    CORE_API FAutoConsoleTaskPriority(const TCHAR* Name, const TCHAR* Help, ENamedThreads::Type DefaultThreadPriority, ENamedThreads::Type DefaultTaskPriority, ENamedThreads::Type DefaultTaskPriorityIfForcedToNormalThreadPriority = ENamedThreads::UnusedAnchor);
 
    inline ENamedThreads::Type Get(ENamedThreads::Type Thread = ENamedThreads::AnyThread)
    {
        // if we don't have the high priority thread that was asked for, or we are downgrading thread priority due to power saving
        // then use a normal thread priority with the backup task priority
        if (ThreadPriority == ENamedThreads::HighThreadPriority && !ENamedThreads::bHasHighPriorityThreads)
        {
            return ENamedThreads::SetTaskPriority(Thread, TaskPriorityIfForcedToNormalThreadPriority);
        }
        // if we don't have the background priority thread that was asked for, then use a normal thread priority with the backup task priority
        if (ThreadPriority == ENamedThreads::BackgroundThreadPriority && !ENamedThreads::bHasBackgroundThreads)
        {
            return ENamedThreads::SetTaskPriority(Thread, TaskPriorityIfForcedToNormalThreadPriority);
        }
        return ENamedThreads::SetPriorities(Thread, ThreadPriority, TaskPriority);
    }
};
 
 
namespace ESubsequentsMode
{
    enum Type
    {
        TrackSubsequents,
        FireAndForget
    };
}
 
typedef TArray<FGraphEventRef, TInlineAllocator<4> > FGraphEventArray;
 
CORE_API TArray<TaskTrace::FId> GetTraceIds(const FGraphEventArray& Tasks);
 
class FTaskGraphInterface
{
    friend class FBaseGraphTask;
    friend UE::Tasks::Private::FTaskBase;
 
    virtual void QueueTask(class FBaseGraphTask* Task, bool bWakeUpWorker, ENamedThreads::Type ThreadToExecuteOn, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread) = 0;
 
public:
 
    virtual ~FTaskGraphInterface()
    {
    }
 
    // Startup, shutdown and singleton API
 
    static CORE_API void Startup(int32 NumThreads);
    static CORE_API void Shutdown();
    static CORE_API bool IsRunning();
    static CORE_API FTaskGraphInterface& Get();
 
    static bool IsMultithread();
 
    virtual ENamedThreads::Type GetCurrentThreadIfKnown(bool bLocalQueue = false) = 0;
 
    virtual bool IsCurrentThreadKnown() = 0;
 
    virtual int32 GetNumWorkerThreads() = 0;
 
    virtual int32 GetNumForegroundThreads() = 0;
 
    virtual int32 GetNumBackgroundThreads() = 0;
 
    virtual bool IsThreadProcessingTasks(ENamedThreads::Type ThreadToCheck) = 0;
 
    // External Thread API
 
    virtual void AttachToThread(ENamedThreads::Type CurrentThread)=0;
 
    virtual uint64 ProcessThreadUntilIdle(ENamedThreads::Type CurrentThread)=0;
 
    virtual void ProcessThreadUntilRequestReturn(ENamedThreads::Type CurrentThread)=0;
 
    virtual void RequestReturn(ENamedThreads::Type CurrentThread)=0;
 
    virtual void WaitUntilTasksComplete(const FGraphEventArray& Tasks, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)=0;
    
 
    enum class EProcessTasksOperation : int8
    {
        ProcessAllOtherTasks,
 
        ProcessOneOtherTask,
 
        ProcessNamedThreadTasks,
 
        WaitUntilComplete,
 
        StopProcessing,
    };
 
    typedef TFunction<EProcessTasksOperation(int32 /*NumTasksRemaining*/)> FProcessTasksUpdateCallback;
 
    virtual bool ProcessUntilTasksComplete(const FGraphEventArray& Tasks, ENamedThreads::Type CurrentThreadIfKnown, const FProcessTasksUpdateCallback& IdleWorkUpdate = {}) = 0;
 
    virtual void TriggerEventWhenTasksComplete(FEvent* InEvent, const FGraphEventArray& Tasks, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread, ENamedThreads::Type TriggerThread = ENamedThreads::AnyHiPriThreadHiPriTask)=0;
 
    void WaitUntilTaskCompletes(const FGraphEventRef& Task, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
    {
        WaitUntilTasksComplete({ Task }, CurrentThreadIfKnown);
    }
 
    void WaitUntilTaskCompletes(FGraphEventRef&& Task, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
    {
        WaitUntilTasksComplete({ MoveTemp(Task) }, CurrentThreadIfKnown);
    }
 
    void TriggerEventWhenTaskCompletes(FEvent* InEvent, const FGraphEventRef& Task, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread, ENamedThreads::Type TriggerThread = ENamedThreads::AnyHiPriThreadHiPriTask)
    {
        FGraphEventArray Prerequistes;
        Prerequistes.Add(Task);
        TriggerEventWhenTasksComplete(InEvent, Prerequistes, CurrentThreadIfKnown, TriggerThread);
    }
 
    virtual FBaseGraphTask* FindWork(ENamedThreads::Type ThreadInNeed) = 0;
 
    virtual void StallForTuning(int32 Index, bool Stall) = 0;
 
    virtual void AddShutdownCallback(TFunction<void()>& Callback) = 0;
 
    virtual void WakeNamedThread(ENamedThreads::Type ThreadToWake) = 0;
 
    static void BroadcastSlow_OnlyUseForSpecialPurposes(bool bDoTaskThreads, bool bDoBackgroundThreads, TFunction<void(ENamedThreads::Type CurrentThread)>& Callback);
};
 
struct FTaskGraphBlockAllocationTag : FDefaultBlockAllocationTag
{
    static constexpr uint32 BlockSize = 64 * 1024;
    static constexpr bool AllowOversizedBlocks = false;
    static constexpr bool RequiresAccurateSize = false;
    static constexpr bool InlineBlockAllocation = true;
    static constexpr const char* TagName = "TaskGraphLinear";
 
    using Allocator = TBlockAllocationCache<BlockSize, FAlignedAllocator>;
};
 
class FBaseGraphTask : public UE::Tasks::Private::FTaskBase
{
public:
    // These functions handle integration with FTaskBase and the named thread executor and should not be called directly
    explicit FBaseGraphTask(const FGraphEventArray* InPrerequisites)
        : FTaskBase(/*InitRefCount=*/ 1, false /* bUnlockPrerequisites */)
    {
        if (InPrerequisites != nullptr)
        {
            AddPrerequisites(*InPrerequisites, false /* bLockPrerequisite */);
        }
 
        UnlockPrerequisites();
    }
 
    void Init(const TCHAR* InDebugName, UE::Tasks::ETaskPriority InPriority, UE::Tasks::EExtendedTaskPriority InExtendedPriority, UE::Tasks::ETaskFlags InTaskFlags = UE::Tasks::ETaskFlags::None)
    {
        FTaskBase::Init(InDebugName, InPriority, InExtendedPriority, InTaskFlags);
    }
 
    inline void Execute(TArray<FBaseGraphTask*>& NewTasks, ENamedThreads::Type CurrentThread, bool bDeleteOnCompletion)
    {   // only called for named thread tasks, normal tasks are executed using `FTaskBase` API directly (see `TGraphTask`)
        checkSlow(NewTasks.Num() == 0);
        checkSlow(bDeleteOnCompletion);
        checkSlow(IsNamedThreadTask());
        verify(TryExecuteTask());
        ReleaseInternalReference(); // named tasks are executed by named threads, outside of the scheduler
    }
 
 
    FGraphEventRef GetCompletionEvent()
    {
        return this;
    }
 
    void DontCompleteUntil(FGraphEventRef NestedTask)
    {
        if (!NestedTask)
        {
            return;
        }
 
        if (IsTaskEvent())
        {   // TaskEvent can't have nested tasks, add it as a prerequisite instead to retain backward compatibility
            AddPrerequisites(*NestedTask);
        }
        else
        {
            checkSlow(UE::Tasks::Private::GetCurrentTask() == this); // a nested task can be added only from inside of parent's execution
            AddNested(*NestedTask);
        }
    }
 
    bool IsComplete() const
    {
        return IsCompleted();
    }
 
    static FGraphEventRef CreateGraphEvent();
 
    bool IsTaskEvent() const
    {
        return GetExtendedPriority() == UE::Tasks::EExtendedTaskPriority::TaskEvent;
    }
 
    void Unlock(ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
    {
        if (IsTaskEvent())
        {
            // An event is not "in the system" until it's triggered, and should be kept alive only by external references. Once it's triggered it's in the system 
            // and can outlive external references, so we need to keep it alive by holding an internal reference. It will be released when the event is signaled
            AddRef();
        }
        TryLaunch(0);
    }
 
    void DispatchSubsequents(ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
    {
        Unlock(CurrentThreadIfKnown);
    }
 
    UE_DEPRECATED(5.6, "Call AddPrerequisites separately if you need to add new tasks before dispatch")
    void DispatchSubsequents(TArray<FBaseGraphTask*>& NewTasks, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
    {
        check(NewTasks.Num() == 0); // the feature is not used
        DispatchSubsequents();
    }
 
    void SetDebugName(const TCHAR* InDebugName)
    {   // incompatible with the new API that requires debug name during task construction and doesn't allow to set it later. "debug name" feature was added
        // to the old API recently, is used only in a couple of places and will be fixed manually by switching to the new API
    }
 
    void Wait(ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
    {
        // local queue have to be handled by the original TaskGraph implementation. Tasks System doesn't support local queues
        if (ENamedThreads::GetQueueIndex(CurrentThreadIfKnown) != ENamedThreads::MainQueue)
        {
            return FTaskGraphInterface::Get().WaitUntilTaskCompletes(this, CurrentThreadIfKnown);
        }
 
        FTaskBase::WaitWithNamedThreadsSupport();
    }
 
    ENamedThreads::Type GetThreadToExecuteOn() const
    {
        return UE::Tasks::Private::TranslatePriority(GetPriority(), GetExtendedPriority());
    }
};
 
template<typename TTask>
class TGraphTask final : public TConcurrentLinearObject<TGraphTask<TTask>, FTaskGraphBlockAllocationTag>, public FBaseGraphTask
{
public:
    class FConstructor
    {
    public:
        UE_NONCOPYABLE(FConstructor);
 
        template<typename...T>
        inline FGraphEventRef ConstructAndDispatchWhenReady(T&&... Args)
        {
            FGraphEventRef Ref{ ConstructAndHoldImpl(Forward<T>(Args)...) };
            Ref->TryLaunch(sizeof(TGraphTask));
            return Ref;
        }
 
        template<typename...T>
        inline TGraphTask* ConstructAndHold(T&&... Args)
        {
            TGraphTask* Task = ConstructAndHoldImpl(Forward<T>(Args)...);
            TaskTrace::Created(Task->GetTraceId(), sizeof(*Task));
            return Task;
        }
 
        FConstructor(const FGraphEventArray* InPrerequisites)
            : Prerequisites(InPrerequisites)
        {
        }
 
    private:
        template<typename...T>
        inline TGraphTask* ConstructAndHoldImpl(T&&... Args)
        {
            TGraphTask* Task = new TGraphTask(Prerequisites);
            TTask* TaskObject = new(&Task->TaskStorage) TTask(Forward<T>(Args)...);
 
            UE::Tasks::ETaskPriority Pri;
            UE::Tasks::EExtendedTaskPriority ExtPri;
            UE::Tasks::Private::TranslatePriority(TaskObject->GetDesiredThread(), Pri, ExtPri);
 
            Task->Init(Pri, ExtPri);
 
            return Task;
        }
 
    private:
        const FGraphEventArray* Prerequisites;
    };
 
    static FConstructor CreateTask(const FGraphEventArray* Prerequisites = nullptr, ENamedThreads::Type CurrentThreadIfKnown = ENamedThreads::AnyThread)
    {
        return FConstructor(Prerequisites);
    }
 
private:
    explicit TGraphTask(const FGraphEventArray* InPrerequisites)
        : FBaseGraphTask(InPrerequisites)
    {
    }
 
    void Init(UE::Tasks::ETaskPriority InPriority, UE::Tasks::EExtendedTaskPriority InExtendedPriority)
    {
        FBaseGraphTask::Init(TEXT("GraphTask"), InPriority, InExtendedPriority);
    }
 
    struct CGetStatIdProvider
    {
        template <typename TaskType>
        auto Requires(TaskType& Task) -> decltype(
            Task.GetStatId()
        );
    };
 
    virtual void ExecuteTask() override final
    {
        FGraphEventRef GraphEventRef{ this };
        TTask* TaskObject = TaskStorage.GetTypedPtr();
        // Only use this scope when GetStatId() is actually implemented on TaskObject for backward compat, sometimes it's not.
        if constexpr (TModels_V<CGetStatIdProvider, TTask>)
        {
            FScopeCycleCounter Scope(TaskObject->GetStatId(), true);
            TaskObject->DoTask(TaskObject->GetDesiredThread(), GraphEventRef);
        }
        else
        {
            TaskObject->DoTask(TaskObject->GetDesiredThread(), GraphEventRef);
        }
        DestructItem(TaskObject);
    }
 
private:
    TTypeCompatibleBytes<TTask> TaskStorage;
};
 
// an adaptation of FBaseGraphTask to be used as a standalone FGraphEvent
class FGraphEventImpl : public FBaseGraphTask
{
public:
    FGraphEventImpl()
        : FBaseGraphTask(nullptr)
    {
        TaskTrace::Created(GetTraceId(), sizeof(*this));
        Init(TEXT("GraphEvent"), UE::Tasks::ETaskPriority::Normal, UE::Tasks::EExtendedTaskPriority::TaskEvent);
    }
 
    static void* operator new(size_t Size);
    static void operator delete(void* Ptr);
 
private:
    virtual void ExecuteTask() override final
    {
        checkNoEntry(); // graph events are never executed
    }
};
 
using FGraphEventImplAllocator = TLockFreeFixedSizeAllocator_TLSCache<sizeof(FGraphEventImpl), PLATFORM_CACHE_LINE_SIZE>;
CORE_API FGraphEventImplAllocator& GetGraphEventImplAllocator();
 
inline void* FGraphEventImpl::operator new(size_t Size)
{
    return GetGraphEventImplAllocator().Allocate();
}
 
inline void FGraphEventImpl::operator delete(void* Ptr)
{
    GetGraphEventImplAllocator().Free(Ptr);
}
 
inline FGraphEventRef FBaseGraphTask::CreateGraphEvent()
{
    FGraphEventImpl* GraphEvent = new FGraphEventImpl;
    return FGraphEventRef{ GraphEvent, /*bAddRef = */ false };
}
 
// Blocks the current thread until any of the given tasks is completed.
// Is slightly more efficient than `AnyTaskCompleted()->Wait()` and supports timeout while `FGraphEvent::Wait()` doesn't.
// Returns the index of the first completed task, or `INDEX_NONE` on timeout.
CORE_API int32 WaitForAnyTaskCompleted(const FGraphEventArray& GraphEvents, FTimespan Timeout = FTimespan::MaxValue());
 
// Returns a graph event that gets completed as soon as any of the given tasks gets completed
CORE_API FGraphEventRef AnyTaskCompleted(const FGraphEventArray& GraphEvents);
 
class FReturnGraphTask
{
public:
 
    FReturnGraphTask(ENamedThreads::Type InThreadToReturnFrom)
        : ThreadToReturnFrom(InThreadToReturnFrom)
    {
        checkThreadGraph(ThreadToReturnFrom != ENamedThreads::AnyThread); // doesn't make any sense to return from any thread
    }
 
    UE_FORCEINLINE_HINT TStatId GetStatId() const
    {
        return GET_STATID(STAT_FReturnGraphTask);
    }
 
    ENamedThreads::Type GetDesiredThread()
    {
        return ThreadToReturnFrom;
    }
 
    static ESubsequentsMode::Type GetSubsequentsMode() { return ESubsequentsMode::TrackSubsequents; }
 
    void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
        checkThreadGraph(ENamedThreads::GetThreadIndex(ThreadToReturnFrom) == ENamedThreads::GetThreadIndex(CurrentThread)); // we somehow are executing on the wrong thread.
        FTaskGraphInterface::Get().RequestReturn(ThreadToReturnFrom);
    }
 
private:
    ENamedThreads::Type ThreadToReturnFrom;
};
 
class FCustomStatIDGraphTaskBase
{
public:
    FCustomStatIDGraphTaskBase(const TStatId& StatId)
    {
#if STATS || ENABLE_STATNAMEDEVENTS
        StatID = StatId;
#endif
    }
 
    inline TStatId GetStatId() const
    {
#if STATS|| ENABLE_STATNAMEDEVENTS
        return StatID;
#else
        return TStatId();
#endif
    }
 
private:
#if STATS|| ENABLE_STATNAMEDEVENTS
    TStatId StatID;
#endif
 
};
 
class FNullGraphTask : public FCustomStatIDGraphTaskBase
{
public:
    FNullGraphTask(const TStatId& StatId, ENamedThreads::Type InDesiredThread)
        : FCustomStatIDGraphTaskBase(StatId)
        , DesiredThread(InDesiredThread)
    {
    }
 
    ENamedThreads::Type GetDesiredThread()
    {
        return DesiredThread;
    }
 
    static ESubsequentsMode::Type GetSubsequentsMode() { return ESubsequentsMode::TrackSubsequents; }
 
    void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
    }
private:
    ENamedThreads::Type DesiredThread;
};
 
class FTriggerEventGraphTask
{
public:
    FTriggerEventGraphTask(FEvent* InEvent, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyHiPriThreadHiPriTask)
        : Event(InEvent) 
        , DesiredThread(InDesiredThread)
    {
        check(Event);
    }
 
    UE_FORCEINLINE_HINT TStatId GetStatId() const
    {
        return GET_STATID(STAT_FTriggerEventGraphTask);
    }
 
    ENamedThreads::Type GetDesiredThread()
    {
        return DesiredThread;
    }
 
    static ESubsequentsMode::Type GetSubsequentsMode() { return ESubsequentsMode::TrackSubsequents; }
 
    void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
        Event->Trigger();
    }
private:
    FEvent* Event;
    ENamedThreads::Type DesiredThread;
};
 
class FSimpleDelegateGraphTask : public FCustomStatIDGraphTaskBase
{
public:
    DECLARE_DELEGATE(FDelegate);
 
    FDelegate                           TaskDelegate;
    const ENamedThreads::Type           DesiredThread;
public:
    ENamedThreads::Type GetDesiredThread()
    {
        return DesiredThread;
    }
    static ESubsequentsMode::Type GetSubsequentsMode() { return ESubsequentsMode::TrackSubsequents; }
 
    void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
        TaskDelegate.ExecuteIfBound();
    }
    FSimpleDelegateGraphTask(const FDelegate& InTaskDeletegate, const TStatId StatId, ENamedThreads::Type InDesiredThread)
        : FCustomStatIDGraphTaskBase(StatId)
        , TaskDelegate(InTaskDeletegate)
        , DesiredThread(InDesiredThread)
    {
    }
 
    static FGraphEventRef CreateAndDispatchWhenReady(const FDelegate& InTaskDeletegate, const TStatId InStatId, const FGraphEventArray* InPrerequisites = NULL, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        return TGraphTask<FSimpleDelegateGraphTask>::CreateTask(InPrerequisites).ConstructAndDispatchWhenReady<const FDelegate&>(InTaskDeletegate, InStatId, InDesiredThread);
    }
    static FGraphEventRef CreateAndDispatchWhenReady(const FDelegate& InTaskDeletegate, const TStatId&& InStatId, const FGraphEventRef& InPrerequisite, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        FGraphEventArray Prerequisites;
        check(InPrerequisite.GetReference());
        Prerequisites.Add(InPrerequisite);
        return CreateAndDispatchWhenReady(InTaskDeletegate, InStatId, &Prerequisites, InDesiredThread);
    }
};
 
class FDelegateGraphTask : public FCustomStatIDGraphTaskBase
{
public:
    DECLARE_DELEGATE_TwoParams( FDelegate,ENamedThreads::Type, const  FGraphEventRef& );
 
    FDelegate                           TaskDelegate;
    const ENamedThreads::Type           DesiredThread;
public:
    ENamedThreads::Type GetDesiredThread()
    {
        return DesiredThread;
    }
    static ESubsequentsMode::Type GetSubsequentsMode() 
    { 
        return ESubsequentsMode::TrackSubsequents; 
    }
    void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
        TaskDelegate.ExecuteIfBound(CurrentThread, MyCompletionGraphEvent);
    }
    FDelegateGraphTask(const FDelegate& InTaskDeletegate, const TStatId InStatId, ENamedThreads::Type InDesiredThread)
        : FCustomStatIDGraphTaskBase(InStatId)
        , TaskDelegate(InTaskDeletegate)
        , DesiredThread(InDesiredThread)
    {
    }
 
    static FGraphEventRef CreateAndDispatchWhenReady(const FDelegate& InTaskDeletegate, const TStatId InStatId, const FGraphEventArray* InPrerequisites = NULL, ENamedThreads::Type InCurrentThreadIfKnown = ENamedThreads::AnyThread, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        return TGraphTask<FDelegateGraphTask>::CreateTask(InPrerequisites, InCurrentThreadIfKnown).ConstructAndDispatchWhenReady<const FDelegate&>(InTaskDeletegate, InStatId, InDesiredThread);
    }
    static FGraphEventRef CreateAndDispatchWhenReady(const FDelegate& InTaskDeletegate, const TStatId InStatId, const FGraphEventRef& InPrerequisite, ENamedThreads::Type InCurrentThreadIfKnown = ENamedThreads::AnyThread, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        FGraphEventArray Prerequisites;
        check(InPrerequisite.GetReference());
        Prerequisites.Add(InPrerequisite);
        return CreateAndDispatchWhenReady(InTaskDeletegate, InStatId, &Prerequisites, InCurrentThreadIfKnown, InDesiredThread);
    }
};
 
template<typename Signature, ESubsequentsMode::Type SubsequentsMode>
class TFunctionGraphTaskImpl : public FCustomStatIDGraphTaskBase
{
private:
    TUniqueFunction<Signature> Function;
    const ENamedThreads::Type DesiredThread;
 
public:
    TFunctionGraphTaskImpl(TUniqueFunction<Signature>&& InFunction, TStatId StatId, ENamedThreads::Type InDesiredThread)
        : FCustomStatIDGraphTaskBase(StatId),
        Function(MoveTemp(InFunction)),
        DesiredThread(InDesiredThread)
    {}
 
    ENamedThreads::Type GetDesiredThread() const
    {
        return DesiredThread;
    }
 
    static ESubsequentsMode::Type GetSubsequentsMode()
    {
        return SubsequentsMode;
    }
 
    UE_FORCEINLINE_HINT void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
        DoTaskImpl(Function, CurrentThread, MyCompletionGraphEvent);
    }
 
private:
    UE_FORCEINLINE_HINT static void DoTaskImpl(TUniqueFunction<void()>& Function, ENamedThreads::Type CurrentThread,
        const FGraphEventRef& MyCompletionGraphEvent)
    {
        Function();
    }
 
    UE_FORCEINLINE_HINT static void DoTaskImpl(TUniqueFunction<void(const FGraphEventRef&)>& Function,
        ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
        Function(MyCompletionGraphEvent);
    }
 
    UE_FORCEINLINE_HINT static void DoTaskImpl(TUniqueFunction<void(ENamedThreads::Type, const FGraphEventRef&)>& Function,
        ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
    {
        Function(CurrentThread, MyCompletionGraphEvent);
    }
};
 
struct FFunctionGraphTask
{
public:
    static FGraphEventRef CreateAndDispatchWhenReady(TUniqueFunction<void()> InFunction, TStatId InStatId = TStatId{}, const FGraphEventArray* InPrerequisites = nullptr, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        return TGraphTask<TFunctionGraphTaskImpl<void(), ESubsequentsMode::TrackSubsequents>>::CreateTask(InPrerequisites).ConstructAndDispatchWhenReady(MoveTemp(InFunction), InStatId, InDesiredThread);
    }
 
    static FGraphEventRef CreateAndDispatchWhenReady(TUniqueFunction<void(ENamedThreads::Type, const FGraphEventRef&)> InFunction, TStatId InStatId = TStatId{}, const FGraphEventArray* InPrerequisites = nullptr, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        return TGraphTask<TFunctionGraphTaskImpl<void(ENamedThreads::Type, const FGraphEventRef&), ESubsequentsMode::TrackSubsequents>>::CreateTask(InPrerequisites).ConstructAndDispatchWhenReady(MoveTemp(InFunction), InStatId, InDesiredThread);
    }
 
    static FGraphEventRef CreateAndDispatchWhenReady(TUniqueFunction<void()> InFunction, TStatId InStatId, const FGraphEventRef& InPrerequisite, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        FGraphEventArray Prerequisites;
        check(InPrerequisite.GetReference());
        Prerequisites.Add(InPrerequisite);
        return CreateAndDispatchWhenReady(MoveTemp(InFunction), InStatId, &Prerequisites, InDesiredThread);
    }
 
    static FGraphEventRef CreateAndDispatchWhenReady(TUniqueFunction<void(ENamedThreads::Type, const FGraphEventRef&)> InFunction, TStatId InStatId, const FGraphEventRef& InPrerequisite, ENamedThreads::Type InDesiredThread = ENamedThreads::AnyThread)
    {
        FGraphEventArray Prerequisites;
        check(InPrerequisite.GetReference());
        Prerequisites.Add(InPrerequisite);
        return CreateAndDispatchWhenReady(MoveTemp(InFunction), InStatId, &Prerequisites, InDesiredThread);
    }
};