1. Epic GamesDeveloper
  3. Async

Async

API > API/Runtime > API/Runtime/Core

Filters

Classes

  Type Name Description
Public struct FAcquireLock Use to acquire a lock on construction.  
Public class FAsyncGraphTaskBase Base class for asynchronous functions that are executed in the Task Graph system.  
Public class FAsyncReadFileHandleNull An IAsyncReadFileHandle that returns only failed results, used when a function has failed but needs to return a non-null IAsyncReadFileHandle.  
Public class FAsyncReadRequestNull IAsyncReadRequest returned from FAsyncReadFileHandleNull; guaranteed to be a cancelled readrequest with no size or bytes when the Callback is called.  
Public class FAsyncTask    
Public class FAsyncTaskBase FAsyncTask - template task for jobs queued to thread pools  
Public struct FAsyncThreadIndex Helper struct used to generate unique ids for the stats.  
Public class FAutoConsoleTaskPriority    
Public class FAutoDeleteAsyncTask FAutoDeleteAsyncTask - template task for jobs that delete themselves when complete  
Public class FBaseGraphTask Base class for all tasks.  
Public class FCompletionList List of tasks that can be "joined" into one task which can be waited on or used as a prerequisite.  
Public class FCustomStatIDGraphTaskBase Class that generalizes functionality of storing and exposing custom stat id.  
Public struct FDeferLock Use with dynamic locks to defer locking on construction.  
Public class FDelegateGraphTask Task class for more full featured delegate based tasks.  
Public class FExternalMutex A mutex which takes it state from an external source and uses only its 2 LSBs.  
Public struct FFunctionGraphTask    
Public class FFutureState Base class for the internal state of asynchronous return values (futures).  
Public class FGraphEvent A FGraphEvent is a list of tasks waiting for something.  
Public class FInheritedContextBase This class extends the inherited context (see private members for what the inherited context is) to cover async execution.  
Public class FInheritedContextScope Restores an inherited contex for the current scope.  
Public class FManualResetEvent A type of event that remains notified until manually reset.  
Public class FMutex A one-byte mutex that is not fair and does not support recursive locking.  
Public class FNonAbandonableTask Stub class to use a base class for tasks that cannot be abandoned  
Public class FNullGraphTask FNullGraphTask is a task that does nothing.  
Public class FRecursiveMutex An eight-byte mutex that is not fair and supports recursive locking.  
Public struct FRenderThreadStatics    
Public class FReturnGraphTask FReturnGraphTask is a task used to return flow control from a named thread back to the original caller of ProcessThreadUntilRequestReturn  
Public class FSimpleDelegateGraphTask Task class for simple delegate based tasks.  
Public struct FTaskBlockAllocationTag    
Public struct FTaskGraphBlockAllocationTag    
Public class FTaskGraphInterface Interface to the task graph system  
Public struct FTaskTimingEventScope    
Public class FTriggerEventGraphTask FTriggerEventGraphTask is a task that triggers an event  
Public struct FWaitingScope    
Public struct FWaitState    
Public struct FWakeState    
Public class FWordMutex A mutex that is the size of a pointer and does not depend on ParkingLot.  
Public class IAsyncProgress Interface for checking the progress of asynchronous tasks.  
Public class IAsyncReadFileHandle    
Public class IAsyncReadRequest    
Public class IAsyncTask Interface for asynchronous tasks.  
Public class IMappedFileHandle    
Public class IMappedFileRegion    
Public class TAsyncGraphTask Template for asynchronous functions that are executed in the Task Graph system.  
Public class TAsyncQueuedWork Template for asynchronous functions that are executed in the queued thread pool.  
Public class TAsyncResult Template for asynchronous return values.  
Public class TAsyncRunnable Template for asynchronous functions that are executed in a separate thread.  
Public class TDynamicUniqueLock A mutex ownership wrapper that allows dynamic locking, unlocking, and deferred locking.  
Public class TEventCount A type of event that avoids missed notifications by maintaining a notification count.  
Public class TEventCountToken A token used to wait on TEventCount.  
Public class TFunctionGraphTaskImpl Task class for lambda based tasks.  
Public class TFuture Template for unshared futures.  
Public class TFutureBase TFuture Abstract base template for futures and shared futures.  
Public class TFutureState Implements the internal state of asynchronous return values (futures).  
Public class TGraphTask The user defined task type can take arguments to a constructor.  
Public class TLocalWorkQueue    
Public class TPromise Template for promises.  
Public class TPromiseBase TPromise  
Public class TSharedFuture TSharedFuture Template for shared futures.  
Public class TUniqueLock A basic mutex ownership wrapper that locks on construction and unlocks on destruction.  
Public class TYCombinator    

Typedefs

Name Description
FAsyncFileCallBack  
FEventCount  
FEventCountToken  
FGraphEventArray Convenience typedef for a an array a graph events
FGraphEventRef Convenience typedef for a reference counted pointer to a graph event
FId  

Enums

  Type Name Description
Public enum EAsyncExecution Enumerates available asynchronous execution methods.  
Public enum EAsyncTaskState Enumerates possible states of slow running tasks.  
Public enum ENamedThreads::Type Forward declaration for ENamedThreads  
Public enum EParallelForFlags Flags controlling the ParallelFor's behavior.  
Public enum ESubsequentsMode::Type    

Functions

  Type Name Description
Public function FGraphEventRef

AnyTaskCompleted ( const FGraphEventArray& GraphEvents
)

 Returns a graph event that gets completed as soon as any of the given tasks gets completed.
Public function TFuture< decltype(Forward< CallableType >(Callable)())>

Async ( EAsyncExecution Execution,
CallableType&& Callable,
TUniqueFunction< void()> CompletionCallback
)

 Execute a given function asynchronously.
Public function TFuture< decltype(Forward< CallableType >(Callable)())>

AsyncPool ( FQueuedThreadPool& ThreadPool,
CallableType&& Callable,
TUniqueFunction< void()> CompletionCallback,
EQueuedWorkPriority InQueuedWorkPriority
)

 Execute a given function asynchronously on the specified thread pool.
Public function void

AsyncTask ( ENamedThreads::Type Thread,
TUniqueFunction< void()> Function
)

 Convenience function for executing code asynchronously on the Task Graph.
Public function TFuture< decltype(Forward< CallableType >(Callable)())>

AsyncThread ( CallableType&& Callable,
uint32 StackSize,
EThreadPriority ThreadPri,
TUniqueFunction< void()> CompletionCallback
)

 Execute a given function asynchronously using a separate thread.
Public function int32

ENamedThreads::GetQueueIndex ( Type ThreadAndIndex
)

  
Public function Type  
Public function Type  
Public function int32  
Public function Type

ENamedThreads::GetThreadIndex ( Type ThreadAndIndex
)

  
Public function int32  
Public function Type

ENamedThreads::SetPriorities ( Type ThreadAndIndex,
int32 PriorityIndex,
bool bHiPri
)

  
Public function Type

ENamedThreads::SetPriorities ( Type ThreadAndIndex,
Type ThreadPriority,
Type TaskPriority
)

  
Public function void  
Public function void  
Public function Type

ENamedThreads::SetTaskPriority ( Type ThreadAndIndex,
Type TaskPriority
)

  
Public function Type

ENamedThreads::SetThreadPriority ( Type ThreadAndIndex,
Type ThreadPriority
)

  
Public function void

FutureDetail::SetPromiseValue ( TPromise< void >& Promise,
Func& Function,
TFuture< ParamType >&& Param
)

  
Public function void

FutureDetail::SetPromiseValue ( TPromise< ResultType >& Promise,
Func& Function,
TFuture< ParamType >&& Param
)

 Template for setting a promise value from a continuation.
Public function TArray< TaskTrace::FId >

GetTraceIds ( const FGraphEventArray& Tasks
)

 Returns trace IDs of given tasks
Public function TPromise< ResultType >

MakeFulfilledPromise ( ArgTypes&&... Args
)

 Helper to create and immediately fulfill a promise
Public function auto

MakeYCombinator ( LAMBDA&& Lambda
)

  
Public function bool  
Public function EParallelForFlags  
Public function EParallelForFlags &  
Public function EParallelForFlags  
Public function EParallelForFlags &  
Public function EParallelForFlags  
Public function EParallelForFlags &  
Public function EParallelForFlags  
Public function void

ParallelFor ( const TCHAR* DebugName,
int32 Num,
int32 MinBatchSize,
TFunctionRef< void(int32)> Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph for unbalanced tasks Offers better work distribution among threads at the cost of a little bit more synchronization.
Public function void

ParallelFor ( int32 Num,
TFunctionRef< void(int32)> Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph for unbalanced tasks Offers better work distribution among threads at the cost of a little bit more synchronization.
Public function void

ParallelFor ( int32 Num,
TFunctionRef< void(int32)> Body,
bool bForceSingleThread,
bool bPumpRenderingThread
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForImpl::CallBody ( const FunctionType& Body,
const TArrayView< ContextType >& Contexts,
int32 TaskIndex,
int32 Index
)

 Helper to call body with context reference.
Public function void

ParallelForImpl::CallBody ( const FunctionType& Body,
const TArrayView< TYPE_OF_NULLPTR >&,
int32,
int32 Index
)

 Helper specialization for "no context", which changes the assumed body call signature.
Public function int32  
Public function void

ParallelForImpl::ParallelForInternal ( const TCHAR* DebugName,
int32 Num,
int32 MinBatchSize,
BodyType Body,
PreWorkType CurrentThreadWorkToDoBeforeHelping,
EParallelForFlags Flags,
const TArrayView< ContextType >& Contexts
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForTemplate ( int32 Num,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForTemplate ( const TCHAR* DebugName,
int32 Num,
int32 MinBatchSize,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForWithExistingTaskContext ( TArrayView< ContextType > Contexts,
int32 Num,
int32 MinBatchSize,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph.
Public function void

ParallelForWithExistingTaskContext ( const TCHAR* DebugName,
TArrayView< ContextType > Contexts,
int32 Num,
int32 MinBatchSize,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph.
Public function void

ParallelForWithPreWork ( int32 Num,
TFunctionRef< void(int32)> Body,
TFunctionRef< void()> CurrentThreadWorkToDoBeforeHelping,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForWithPreWork ( int32 Num,
TFunctionRef< void(int32)> Body,
TFunctionRef< void()> CurrentThreadWorkToDoBeforeHelping,
bool bForceSingleThread,
bool bPumpRenderingThread
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForWithPreWork ( const TCHAR* DebugName,
int32 Num,
int32 MinBatchSize,
TFunctionRef< void(int32)> Body,
TFunctionRef< void()> CurrentThreadWorkToDoBeforeHelping,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForWithPreWorkWithExistingTaskContext ( const TCHAR* DebugName,
TArrayView< ContextType > Contexts,
int32 Num,
int32 MinBatchSize,
BodyType&& Body,
PreWorkType&& CurrentThreadWorkToDoBeforeHelping,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForWithPreWorkWithTaskContext ( const TCHAR* DebugName,
TArray< ContextType, ContextAllocatorType >& OutContexts,
int32 Num,
int32 MinBatchSize,
BodyType&& Body,
PreWorkType&& CurrentThreadWorkToDoBeforeHelping,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForWithPreWorkWithTaskContext ( const TCHAR* DebugName,
TArray< ContextType, ContextAllocatorType >& OutContexts,
int32 Num,
int32 MinBatchSize,
ContextConstructorType&& ContextConstructor,
BodyType&& Body,
PreWorkType&& CurrentThreadWorkToDoBeforeHelping,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph
Public function void

ParallelForWithTaskContext ( const TCHAR* DebugName,
TArray< ContextType, ContextAllocatorType >& OutContexts,
int32 Num,
int32 MinBatchSize,
const ContextConstructorType& ContextConstructor,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph.
Public function void

ParallelForWithTaskContext ( TArray< ContextType, ContextAllocatorType >& OutContexts,
int32 Num,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph.
Public function void

ParallelForWithTaskContext ( TArray< ContextType, ContextAllocatorType >& OutContexts,
int32 Num,
const ContextConstructorType& ContextConstructor,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph.
Public function void

ParallelForWithTaskContext ( const TCHAR* DebugName,
TArray< ContextType, ContextAllocatorType >& OutContexts,
int32 Num,
const ContextConstructorType& ContextConstructor,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph.
Public function void

ParallelForWithTaskContext ( const TCHAR* DebugName,
TArray< ContextType, ContextAllocatorType >& OutContexts,
int32 Num,
int32 MinBatchSize,
const FunctionType& Body,
EParallelForFlags Flags
)

 General purpose parallel for that uses the taskgraph.
Public function void

SetPromise ( TPromise< void >& Promise,
CallableType&& Callable
)

  
Public function void

SetPromise ( TPromise< ResultType >& Promise,
CallableType&& Callable
)

 Template for setting a promise value from a callable.
Public function void  
Public function void

TaskTrace::Created ( FId TaskId,
uint64 TaskSize
)

  
Public function void  
Public function void  
Public function FId NOOP implementation.
Public function void  
Public function void

TaskTrace::Launched ( FId TaskId,
const TCHAR* DebugName,
bool bTracked,
ENamedThreads::Type ThreadToExecuteOn,
uint64 TaskSize
)

  
Public function void  
Public function void

TaskTrace::Started ( FId TaskId
)

  
Public function void

TaskTrace::SubsequentAdded ( FId TaskId,
FId SubsequentId
)

  
Public function    
Public function FWaitState

UE::ParkingLot::Wait ( const void* Address,
CanWaitType&& CanWait,
BeforeWaitType&& BeforeWait
)

 Queue the calling thread to wait if CanWait returns true.
Public function FWaitState

UE::ParkingLot::WaitFor ( const void* Address,
CanWaitType&& CanWait,
BeforeWaitType&& BeforeWait,
FMonotonicTimeSpan WaitTime
)

 Queue the calling thread to wait if CanWait returns true.
Public function FWaitState

UE::ParkingLot::WaitUntil ( const void* Address,
CanWaitType&& CanWait,
BeforeWaitType&& BeforeWait,
FMonotonicTimePoint WaitTime
)

 Queue the calling thread to wait if CanWait returns true.
Public function void

UE::ParkingLot::WakeOne ( const void* Address,
OnWakeStateType&& OnWakeState
)

 Wake one thread from the queue of threads waiting on the address.
Public function int32

WaitForAnyTaskCompleted ( const FGraphEventArray& GraphEvents,
FTimespan Timeout
)

 Blocks the current thread until any of the given tasks is completed.

Variables

  Type Name Description
Public variable UE::FAcquireLock AcquireLock  
Public variable UE::FDeferLock DeferLock  
Public variable int32 GParallelForBackgroundYieldingTimeoutMs  
Public variable const FId InvalidId  
Public variable   STATCAT_Advanced  
Public variable uint32 TaskTraceVersion  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page