AsyncLoading.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    AsyncLoading.h: Unreal async loading definitions.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/ThreadSafeCounter.h"
#include "UObject/ObjectResource.h"
#include "UObject/GCObject.h"
#include "Serialization/AsyncPackage.h"
#include "UObject/Package.h"
#include "Templates/Casts.h"
#include "UObject/ObjectRedirector.h"
#include "UObject/UObjectThreadContext.h"
#include "UObject/LinkerInstancingContext.h"
#include "Templates/RefCounting.h"
#include "Serialization/AsyncPackageLoader.h"
 
#include "Async/AsyncFileHandle.h"
 
struct FAsyncPackage;
struct FFlushRequest;
class FAsyncLoadingThread;
 
 
enum class EAsyncPackageLoadingState : uint8
{
    NewPackage,
    WaitingForSummary,
    StartImportPackages,
    WaitingForImportPackages,
    SetupImports,
    SetupExports,
    ProcessNewImportsAndExports,
    WaitingForPostLoad,
    ReadyForPostLoad,
    PostLoad_Etc,
    PackageComplete,
};
 
struct FUnsafeWeakAsyncPackagePtr
{
    FAsyncPackage* Package;
    FUnsafeWeakAsyncPackagePtr(FAsyncPackage* InPackage = nullptr)
        : Package(InPackage)
    {
    }
    FORCEINLINE FAsyncPackage& GetPackage() const
    {
        check(Package);
        return *Package;
    }
    FORCEINLINE friend uint32 GetTypeHash(const FUnsafeWeakAsyncPackagePtr& WeakPtr)
    {
        return GetTypeHash(WeakPtr.Package);
    }
    FORCEINLINE bool operator==(const FUnsafeWeakAsyncPackagePtr& Other) const
    {
        return Package == Other.Package;
    }
    FName HumanReadableStringForDebugging() const;
};
 
struct FWeakAsyncPackagePtr
{
    FName PackageName;
    int32 SerialNumber;
    FWeakAsyncPackagePtr(FAsyncPackage* Package = nullptr);
    FAsyncPackage& GetPackage() const;
    FORCEINLINE friend uint32 GetTypeHash(const FWeakAsyncPackagePtr& WeakPtr)
    {
        return GetTypeHash(WeakPtr.PackageName);
    }
    FORCEINLINE bool operator==(const FWeakAsyncPackagePtr& Other) const
    {
        return SerialNumber == Other.SerialNumber;
    }
    FName HumanReadableStringForDebugging() const
    {
        return PackageName;
    }
};
 
#define VERIFY_WEAK_ASYNC_PACKAGE_PTRS (0) //(DO_CHECK)
 
#if VERIFY_WEAK_ASYNC_PACKAGE_PTRS
typedef FWeakAsyncPackagePtr FCheckedWeakAsyncPackagePtr;
#else
typedef FUnsafeWeakAsyncPackagePtr FCheckedWeakAsyncPackagePtr;
#endif
 
enum class EEventLoadNode
{
    Package_LoadSummary,
    Package_SetupImports,
    Package_ExportsSerialized,
    Package_NumPhases,
 
    ImportOrExport_Create = 0,
    ImportOrExport_Serialize,
    Import_NumPhases,
 
    Export_StartIO = Import_NumPhases,
    Export_NumPhases,
 
    MAX_NumPhases = Package_NumPhases,
    Invalid_Value = -1
};
 
#define USE_IMPLICIT_ARCS (1) // saves time and memory by not actually adding the arcs that are always present, they are:
 
// Import: EEventLoadNode::ImportOrExport_Create -> EEventLoadNode::ImportOrExport_Serialize: can't consider this import serialized until we hook it up after creation
// Import: EEventLoadNode::ImportOrExport_Serialize -> EEventLoadNode::Package_ExportsSerialized: can't consider the package done with event driven loading until all imports are serialized
 
// Export: EEventLoadNode::ImportOrExport_Create -> EEventLoadNode::Export_StartIO: can't do the IO request until it is created
// Export: EEventLoadNode::Export_StartIO -> EEventLoadNode::ImportOrExport_Serialize: can't serialize until the IO request is ready
// Import: EEventLoadNode::ImportOrExport_Serialize -> EEventLoadNode::Package_ExportsSerialized: can't consider the package done with event driven loading until all exports are serialized
 
struct FEventLoadNodePtr
{
    FCheckedWeakAsyncPackagePtr WaitingPackage;
    FPackageIndex ImportOrExportIndex;  // IsNull()==true for PACKAGE_ Phases
    EEventLoadNode Phase;
 
    FEventLoadNodePtr()
        : Phase(EEventLoadNode::Invalid_Value)
    {
    }
    FORCEINLINE friend uint32 GetTypeHash(const FEventLoadNodePtr& NodePtr)
    {
        return GetTypeHash(NodePtr.WaitingPackage) ^ (GetTypeHash(NodePtr.ImportOrExportIndex) << 13) ^ (uint32(NodePtr.Phase) << 27);
    }
 
#if 0
    FORCEINLINE bool operator<(const FEventLoadNodePtr& Other) const // not a total order
    {
        return WaitingPackage.SerialNumber < Other.WaitingPackage.SerialNumber;
    }
#endif
    FORCEINLINE bool operator==(const FEventLoadNodePtr& Other) const
    {
        return WaitingPackage == Other.WaitingPackage && 
            ImportOrExportIndex == Other.ImportOrExportIndex && 
            Phase == Other.Phase;
    }
#if USE_IMPLICIT_ARCS
    FORCEINLINE int32 NumImplicitArcs()
    {
        return ImportOrExportIndex.IsNull() ? 0 : 1; // only import and export nodes have implicit arcs, and every one of them has exactly one
    }
    FORCEINLINE FEventLoadNodePtr GetImplicitArc()
    {
        check(!ImportOrExportIndex.IsNull()); // package nodes don't have implicit arcs
        FEventLoadNodePtr Result;
        Result.WaitingPackage = WaitingPackage;
        if (Phase == EEventLoadNode::ImportOrExport_Serialize)
        {
            Result.Phase = EEventLoadNode::Package_ExportsSerialized;
            check(Result.ImportOrExportIndex.IsNull());
        }
        else
        {
            Result.ImportOrExportIndex = ImportOrExportIndex;
            if (Phase == EEventLoadNode::ImportOrExport_Create)
            {
                Result.Phase = ImportOrExportIndex.IsImport() ? EEventLoadNode::ImportOrExport_Serialize : EEventLoadNode::Export_StartIO;
            }
            else
            {
                check(Phase == EEventLoadNode::Export_StartIO);
                Result.Phase = EEventLoadNode::ImportOrExport_Serialize;
            }
        }
        return Result;
    }
 
#endif
 
    FString HumanReadableStringForDebugging() const;
};
 
struct FEventLoadNode
{
#if USE_IMPLICIT_ARCS
    typedef TArray<FEventLoadNodePtr> TNodesWaitingForMeArray;
#else
    typedef TArray<FEventLoadNodePtr, TInlineAllocator<1> > TNodesWaitingForMeArray;
#endif
 
    TNodesWaitingForMeArray NodesWaitingForMe;
    int32 NumPrerequistes;
    bool bFired;
    bool bAddedToGraph;
    FORCEINLINE FEventLoadNode()
        : NumPrerequistes(0)
        , bFired(false)
        , bAddedToGraph(false)
    {
    }
};
 
struct FEventLoadNodeArray
{
    FEventLoadNode PackageNodes[int(EEventLoadNode::Package_NumPhases)];
    FEventLoadNode* Array;
    int32 TotalNumberOfImportExportNodes;
    int32 TotalNumberOfNodesAdded;
    int32 NumImports;
    int32 NumExports;
    int32 OffsetToImports;
    int32 OffsetToExports;
 
    FEventLoadNodeArray()
        : Array(nullptr)
        , TotalNumberOfImportExportNodes(0)
        , TotalNumberOfNodesAdded(0)
        , NumImports(0)
        , NumExports(0)
        , OffsetToImports(0)
        , OffsetToExports(0)
    {
    }
 
 
    bool AddNode(FEventLoadNodePtr Node)
    {
        FEventLoadNode& NodeRef(PtrToNode(Node));
        check(!NodeRef.bAddedToGraph);
        NodeRef.bAddedToGraph = true;
        return (++TotalNumberOfNodesAdded) == 1; // first add, the caller will add this to a list of things with outstanding nodes
    }
    bool RemoveNode(FEventLoadNodePtr Node)
    {
        FEventLoadNode& NodeRef(PtrToNode(Node));
        check(NodeRef.bAddedToGraph);
        NodeRef.bAddedToGraph = false;
        return (--TotalNumberOfNodesAdded) == 0; // first add, the caller will add this to a list of things with outstanding nodes
    }
    FORCEINLINE FEventLoadNode& GetNode(FEventLoadNodePtr Node, bool bCheckAdded = true)
    {
        FEventLoadNode& NodeRef(PtrToNode(Node));
        check(!bCheckAdded || NodeRef.bAddedToGraph);
        return NodeRef;
    }
 
    void Init(int32 InNumImports, int32 InNumExports);
    void Shutdown();
    void GetAddedNodes(TArray<FEventLoadNodePtr>& OutAddedNodes, FAsyncPackage* Owner);
private:
    FORCEINLINE FEventLoadNode& PtrToNode(FEventLoadNodePtr Node)
    {
        int32 Index;
        if (Node.ImportOrExportIndex.IsNull())
        {
            Index = int32(Node.Phase);
            check(Index < int32(EEventLoadNode::Package_NumPhases) && Index >= 0);
            return PackageNodes[Index];
        }
        check(TotalNumberOfImportExportNodes); // otherwise Init was not called yet
        if (Node.ImportOrExportIndex.IsImport())
        {
            check(int32(Node.Phase) < int32(EEventLoadNode::Import_NumPhases));
            Index = OffsetToImports + Node.ImportOrExportIndex.ToImport() * int32(EEventLoadNode::Import_NumPhases) + int32(Node.Phase);
            check(Index >= OffsetToImports && Index < OffsetToExports);
        }
        else
        {
            check(int32(Node.Phase) < int32(EEventLoadNode::Export_NumPhases));
            Index = OffsetToExports + Node.ImportOrExportIndex.ToExport() * int32(EEventLoadNode::Export_NumPhases) + int32(Node.Phase);
            check(Index >= OffsetToExports);
        }
        check(Array && Index < TotalNumberOfImportExportNodes && Index >= 0);
        return Array[Index];
    }
 
};
 
struct FEventLoadGraph
{
    TSet<FCheckedWeakAsyncPackagePtr> PackagesWithNodes;
    TArray<int32> IndicesToFire;
 
    FEventLoadNodeArray& GetArray(FEventLoadNodePtr& Node);
 
    FEventLoadNode& GetNode(FEventLoadNodePtr& NodeToGet);
 
    void AddNode(FEventLoadNodePtr& NewNode, bool bHoldForLater = false, int32 NumImplicitPrereqs = 0);
    void DoneAddingPrerequistesFireIfNone(FEventLoadNodePtr& NewNode, bool bWasHeldForLater = false);
    void AddArc(FEventLoadNodePtr& PrereqisiteNode, FEventLoadNodePtr& DependentNode);
    void RemoveNode(FEventLoadNodePtr& NodeToRemove);
    void NodeWillBeFiredExternally(FEventLoadNodePtr& NodeThatWasFired);
    void CheckForCycles(bool bDoSlowTests = (!UE_BUILD_SHIPPING && !UE_BUILD_TEST));
    bool CheckForCyclesInner(const TMultiMap<FEventLoadNodePtr, FEventLoadNodePtr>& Arcs, TSet<FEventLoadNodePtr>& Visited, TSet<FEventLoadNodePtr>& Stack, const FEventLoadNodePtr& Visit);
};
 
struct FAsyncLoadEventArgs
{
    double TickStartTime;
    const TCHAR* OutLastTypeOfWorkPerformed;
    UObject* OutLastObjectWorkWasPerformedOn;
    float TimeLimit;
    bool bUseTimeLimit;
    bool bUseFullTimeLimit;
 
    FAsyncLoadEventArgs()
        : TickStartTime(0.0)
        , OutLastTypeOfWorkPerformed(nullptr)
        , OutLastObjectWorkWasPerformedOn(nullptr)
        , TimeLimit(0.0f)
        , bUseTimeLimit(false)
        , bUseFullTimeLimit(true)
    {
    }
};
 
class FImportOrImportIndexArray : public TArray<int32>
{
public:
    void HeapPop(int32& OutItem, EAllowShrinking AllowShrinking = EAllowShrinking::Default);
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("HeapPop")
    FORCEINLINE void HeapPop(int32& OutItem, bool bAllowShrinking)
    {
        HeapPop(OutItem, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
};
 
struct FAsyncPackage : public FGCObject
{
    friend struct FScopedAsyncPackageEvent;
    friend struct FAsyncPackageScope;
    FAsyncPackage(FAsyncLoadingThread& InThread, const FAsyncPackageDesc& InDesc, struct FEDLBootNotificationManager& InEDLBootNotificationManager);
    ~FAsyncPackage();
 
    EAsyncPackageState::Type TickAsyncPackage(bool bUseTimeLimit, bool bInbUseFullTimeLimit, float& InOutTimeLimit);
    
    void MarkRequestIDsAsComplete();
 
    FORCEINLINE float GetLoadPercentage() const
    {
        return LoadPercentage;
    }
 
    double GetLoadStartTime() const;
 
    void ResetLoader();
 
    void DetachLinker();
 
    void FlushObjectLinkerCache();
 
    FORCEINLINE const FName& GetPackageName() const
    {
        return Desc.Name;
    }
 
    FORCEINLINE const FPackagePath& GetPackagePath() const
    {
        return Desc.PackagePath;
    }
 
    void AddCompletionCallback(TUniquePtr<FLoadPackageAsyncDelegate>&& Callback, bool bInternal);
 
    FORCEINLINE int32 GetDependencyRefCount() const
    {
        return DependencyRefCount.GetValue();
    }
 
    FORCEINLINE UPackage* GetLinkerRoot() const
    {
        return LinkerRoot;
    }
 
    FORCEINLINE bool HasFinishedLoading() const
    {
        return bLoadHasFinished;
    }
 
    FORCEINLINE int32 GetRequestID() const
    {
        return Desc.RequestID;
    }
 
    FORCEINLINE TAsyncLoadPriority GetPriority() const
    {
        return Desc.Priority;
    }
 
    FORCEINLINE void SetPriority(TAsyncLoadPriority InPriority)
    {
        Desc.Priority = InPriority;
    }
 
    FORCEINLINE bool HasLoadFailed() const
    {
        return bLoadHasFailed;
    }
 
    void ThreadedLoadingHasFinished()
    {
        bThreadedLoadingFinished = true;
    }
 
    bool HasThreadedLoadingFinished() const
    {
        return bThreadedLoadingFinished;
    }
 
    void AddRequestID(int32 Id);
 
    void Cancel();
 
    void SetDependencyRootPackage(FAsyncPackage* InDependencyRootPackage)
    {
        DependencyRootPackage = InDependencyRootPackage;
    }
 
    bool IsBeingProcessedRecursively() const
    {
        return ReentryCount > 0;
    }
 
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    virtual FString GetReferencerName() const override
    { 
        return FString::Printf(TEXT("FAsyncPackage %s"), *GetPackageName().ToString()); 
    }
 
    void AddObjectReference(UObject* InObject);
 
    void EmptyReferencedObjects();
 
    UPackage* GetLoadedPackage();
 
#if WITH_EDITOR
    void GetLoadedAssetsAndPackages(TSet<FWeakObjectPtr>& AssetList, TSet<UPackage*>& PackageList);
#endif
 
    bool AreAllDependenciesFullyLoaded(TSet<UPackage*>& VisitedPackages);
 
    bool HasClusterObjects() const
    {
        return DeferredClusterObjects.Num() > 0;
    }
 
    EAsyncPackageState::Type CreateClusters(double InTickStartTime, bool bInUseTimeLimit, double InOutTimeLimit);
 
    bool IsDependencyOf(int32 RequestID);
 
private:
 
    friend class FLinkerLoad;
 
    static bool AreAllDependenciesFullyLoadedInternal(FAsyncPackage* Package, TSet<UPackage*>& VisitedPackages, FString& OutError);
 
    struct FCompletionCallback
    {
        bool bIsInternal;
        bool bCalled;
        TUniquePtr<FLoadPackageAsyncDelegate> Callback;
 
        FCompletionCallback()
            : bIsInternal(false)
            , bCalled(false)
        {
        }
        FCompletionCallback(bool bInInternal, TUniquePtr<FLoadPackageAsyncDelegate>&& InCallback)
            : bIsInternal(bInInternal)
            , bCalled(false)
            , Callback(MoveTemp(InCallback))
        {
        }
    };
 
    void AddDependentRequestsTo(FAsyncPackage* InDependency);
 
    void AddDependentRequests(TArrayView<int32 const> Requests);
 
    bool IsFullyLoadedObj(UObject* Obj);
 
    FAsyncPackageDesc Desc;
    FLinkerLoad*                Linker;
    UPackage*               LinkerRoot;
    TArray<FCompletionCallback> CompletionCallbacks;
    TMap<FName, FAsyncPackage*> PendingImportedPackages;
    TArray<FAsyncPackage*> ReferencedImports;
    FAsyncPackage* DependencyRootPackage;
    FThreadSafeCounter  DependencyRefCount;
    int32                           LoadImportIndex;
    int32                           ImportIndex;
    int32                           ExportIndex;
    int32                           PreLoadIndex;
    int32                           PreLoadSortIndex;
    int32                           FinishExternalReadDependenciesIndex;
    int32                           PostLoadIndex;
    int32                       DeferredPostLoadIndex;
    int32                       PostLoadInstanceIndex;
    int32                       DeferredFinalizeIndex;
    int32                       DeferredClusterIndex;
    float                       TimeLimit;
    bool                        bUseTimeLimit;
    bool                        bUseFullTimeLimit;
    bool                        bTimeLimitExceeded;
    bool                        bLoadHasFailed;
    bool                        bLoadHasFinished;
    bool                        bThreadedLoadingFinished; 
    bool                        bCreatedLinkerRoot;
    double                      TickStartTime;
    UObject*                    LastObjectWorkWasPerformedOn;
    const TCHAR*                LastTypeOfWorkPerformed;
    double                      LoadStartTime;
    float                       LoadPercentage;
    TArray<UObject*> DeferredPostLoadObjects;
    TArray<TObjectPtr<UObject>> DeferredFinalizeObjects;
    TArray<TObjectPtr<UObject>> PackageObjLoaded;
    TArray<FLinkerLoad*> DelayedLinkerClosePackages;
    TArray<UObject*> DeferredClusterObjects;
 
    TArray<int32> RequestIDs;
 
    FRWLock DependentRequestsLock;
    TSet<int32> DependentRequests;
 
#if WITH_METADATA
    TOptional<int32> MetaDataIndex;
#endif // WITH_METADATA
    std::atomic<int32> ReentryCount;
    TSet<TObjectPtr<UObject>> ReferencedObjects;
    FCriticalSection ReferencedObjectsCritical;
    FAsyncLoadingThread& AsyncLoadingThread;
    FEDLBootNotificationManager& EDLBootNotificationManager;
    TSet<TObjectPtr<UPackage>> ImportedPackages;
 
public:
    
 
    EAsyncPackageLoadingState AsyncPackageLoadingState;
    int32 SerialNumber;
 
    FImportOrImportIndexArray ImportsThatAreNowCreated;
    FImportOrImportIndexArray ImportsThatAreNowSerialized;
    FImportOrImportIndexArray ExportsThatCanBeCreated;
    FImportOrImportIndexArray ExportsThatCanHaveIOStarted;
    FImportOrImportIndexArray ExportsThatCanBeSerialized;
    TArray<IAsyncReadRequest*> ReadyPrecacheRequests;
 
    struct FExportIORequest
    {
        int64 Offset;
        int64 BytesToRead;
        int32 FirstExportCovered;
        int32 LastExportCovered;
        TArray<int32> ExportsToRead;
 
        FExportIORequest()
            : Offset(-1)
            , BytesToRead(-1)
            , FirstExportCovered(-1)
            , LastExportCovered(-1)
        {
        }
    };
 
    TMap<IAsyncReadRequest*, FAsyncPackage::FExportIORequest> PrecacheRequests;
    TMap<int32, IAsyncReadRequest*> ExportIndexToPrecacheRequest;
    int64 CurrentBlockOffset;
    int64 CurrentBlockBytes;
    TSet<int32> ExportsInThisBlock;
 
    TMap<TPair<FName, FPackageIndex>, FPackageIndex> ObjectNameWithOuterToExport;
 
    TSet<FWeakAsyncPackagePtr> PackagesIMayBeWaitingForBeforePostload; // these need to be reexamined and perhaps deleted or collapsed
 
    TSet<FWeakAsyncPackagePtr> PackagesIAmWaitingForBeforePostload;    // These are linked with PackagesIAmWaitingForBeforePostload, so we can be sure the other package will let us know
    TSet<FWeakAsyncPackagePtr> OtherPackagesWaitingForMeBeforePostload;
 
    TArray<FCheckedWeakAsyncPackagePtr> PackagesWaitingToLinkImports;
 
    int32 ImportAddNodeIndex;
    int32 ExportAddNodeIndex;
 
    bool bProcessImportsAndExportsInFlight;
    bool bProcessPostloadWaitInFlight;
    bool bAllExportsSerialized;
 
    void Event_CreateLinker();
    void Event_FinishLinker();
    void Event_StartImportPackages();
    void Event_SetupImports();
    void Event_SetupExports();
    void Event_ProcessImportsAndExports();
    void Event_ExportsDone();
    void Event_ProcessPostloadWait();
    void Event_StartPostload();
 
    void MarkNewObjectForLoadIfItIsAnExport(UObject *Object);
    bool AnyImportsAndExportWorkOutstanding();
    void ConditionalQueueProcessImportsAndExports(bool bRequeueForTimeout = false);
    void ConditionalQueueProcessPostloadWait();
 
 
    EAsyncPackageState::Type LoadImports_Event();
    EAsyncPackageState::Type SetupImports_Event();
    EAsyncPackageState::Type SetupExports_Event();
    EAsyncPackageState::Type ProcessImportsAndExports_Event();
 
    FObjectImport* FindExistingImport(int32 LocalImportIndex);
    void LinkImport(int32 LocalImportIndex);
    void EventDrivenCreateExport(int32 LocalExportIndex);
    void StartPrecacheRequest();
    void EventDrivenSerializeExport(int32 LocalExportIndex);
    int64 PrecacheRequestReady(IAsyncReadRequest * Req);
    void MakeNextPrecacheRequestCurrent();
    void FlushPrecacheBuffer();
    void EventDrivenLoadingComplete();
 
    void DumpDependencies(const TCHAR* Label, UObject* Obj);
    void DumpDependencies(const TCHAR* Label, FLinkerLoad* DumpLinker, FPackageIndex Index);
 
    UObject* EventDrivenIndexToObject(FPackageIndex Index, bool bCheckSerialized, FPackageIndex DumpIndex = FPackageIndex());
    template<class T>
    T* CastEventDrivenIndexToObject(FPackageIndex Index, bool bCheckSerialized, FPackageIndex DumpIndex = FPackageIndex())
    {
        UObject* Result = EventDrivenIndexToObject(Index, bCheckSerialized, DumpIndex);
        if (!Result)
        {
            return nullptr;
        }
        return CastChecked<T>(Result);
    }
 
    FEventLoadNodeArray EventNodeArray; 
 
    FEventLoadNodePtr AddNode(EEventLoadNode Phase, FPackageIndex ImportOrExportIndex = FPackageIndex(), bool bHoldForLater = false, int32 NumImplicitPrereqs = 0);
    void DoneAddingPrerequistesFireIfNone(EEventLoadNode Phase, FPackageIndex ImportOrExportIndex = FPackageIndex(), bool bWasHeldForLater = false);
    void RemoveNode(EEventLoadNode Phase, FPackageIndex ImportOrExportIndex = FPackageIndex());
    void NodeWillBeFiredExternally(EEventLoadNode Phase, FPackageIndex ImportOrExportIndex = FPackageIndex());
    void AddArc(FEventLoadNodePtr& PrereqisiteNode, FEventLoadNodePtr& DependentNode);
    void RemoveAllNodes();
    void FireNode(FEventLoadNodePtr& NodeToFire);
 
    FString GetDebuggingPath(FPackageIndex Idx);
 
    void SetTimeLimit(FAsyncLoadEventArgs& Args, const TCHAR* WorkType)
    {
        Args.OutLastTypeOfWorkPerformed = WorkType;
        Args.OutLastObjectWorkWasPerformedOn = LinkerRoot;
        TickStartTime = Args.TickStartTime;
        LastTypeOfWorkPerformed = WorkType;
        LastObjectWorkWasPerformedOn = LinkerRoot;
        TimeLimit = Args.TimeLimit;
        bUseTimeLimit = Args.bUseTimeLimit;
        bUseFullTimeLimit = Args.bUseFullTimeLimit;
    }
 
    FAsyncLoadingThread& GetOwnerThread()
    {
        return AsyncLoadingThread;
    }
 
#if PERF_TRACK_DETAILED_ASYNC_STATS
    int32                           TickCount;
    int32                           TickLoopCount;
 
    int32                           CreateLinkerCount;
    int32                           FinishLinkerCount;
    int32                           CreateImportsCount;
    int32                           CreateExportsCount;
    int32                           PreLoadObjectsCount;
    int32                           PostLoadObjectsCount;
    int32                           FinishObjectsCount;
 
    double                      TickTime;
    double                      CreateLinkerTime;
    double                      FinishLinkerTime;
    double                      CreateImportsTime;
    double                      CreateExportsTime;
    double                      PreLoadObjectsTime;
    double                      PostLoadObjectsTime;
    double                      FinishObjectsTime;
 
#endif
 
    void CallCompletionCallbacks(bool bInternalOnly, EAsyncLoadingResult::Type LoadingResult);
 
    EAsyncPackageState::Type PostLoadDeferredObjects(double InTickStartTime, bool bInUseTimeLimit, double InOutTimeLimit);
 
    void CloseDelayedLinkers();
 
private:
    bool GiveUpTimeSlice();
    bool IsTimeLimitExceeded();
 
    void BeginAsyncLoad();
    void EndAsyncLoad();
    EAsyncPackageState::Type CreateLinker();
    EAsyncPackageState::Type FinishLinker();
    EAsyncPackageState::Type LoadImports();
    EAsyncPackageState::Type CreateImports();
 
#if WITH_METADATA
    EAsyncPackageState::Type CreateMetaData();
#endif // WITH_METADATA
    EAsyncPackageState::Type CreateExports();
    EAsyncPackageState::Type PreLoadObjects();
    EAsyncPackageState::Type PostLoadObjects();
    EAsyncPackageState::Type FinishObjects();
 
    EAsyncPackageState::Type FinishExternalReadDependencies();
 
    void ImportPreLoadedAsyncCallback(const FName& PackageName, UPackage* LoadedPackage, EAsyncLoadingResult::Type Result);
 
    void AddDependencyTree(FAsyncPackage& ImportedPackage, TSet<FAsyncPackage*>& SearchedPackages);
 
    bool AddUniqueLinkerDependencyPackage(FAsyncPackage& PendingImport);
 
    void AddImportDependency(const FName& PendingImport, const FName& PackageToLoad, FLinkerInstancingContext InstancingContext);
 
    void FreeReferencedImports();
 
    void UpdateLoadPercentage();
 
#if PERF_TRACK_DETAILED_ASYNC_STATS
    void TrackCreateExportTimeForClass(const UClass* Class, double Time);
 
    void TrackPostLoadTimeForClass(const UClass* Class, double Time);
#endif // PERF_TRACK_DETAILED_ASYNC_STATS
 
public:
 
    FUObjectSerializeContext* GetSerializeContext();
};
 
struct FScopedAsyncPackageEvent
{
    FAsyncPackage* Package;
    FAsyncPackage* PreviousPackage;
    IAsyncPackageLoader* PreviousAsyncPackageLoader;
    
    FScopedAsyncPackageEvent(FAsyncPackage* InPackage);
    ~FScopedAsyncPackageEvent();
};