AsyncPackageLoader.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ArrayView.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Misc/PackagePath.h"
#include "Stats/Stats.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectArray.h"
#include "UObject/UObjectGlobals.h"
 
class FLinkerInstancingContext;
class FPackagePath;
class FThreadSafeCounter;
class UPackage;
struct FGuid;
template <typename FuncType> class TFunctionRef;
namespace Verse { struct VPackage; }
 
DECLARE_STATS_GROUP_VERBOSE(TEXT("Async Load"), STATGROUP_AsyncLoad, STATCAT_Advanced);
DECLARE_CYCLE_STAT(TEXT("Async Loading Time"),STAT_AsyncLoadingTime,STATGROUP_AsyncLoad);
 
DECLARE_STATS_GROUP(TEXT("Async Load Game Thread"), STATGROUP_AsyncLoadGameThread, STATCAT_Advanced);
 
DECLARE_CYCLE_STAT(TEXT("PostLoadObjects GT"), STAT_FAsyncPackage_PostLoadObjectsGameThread, STATGROUP_AsyncLoadGameThread);
DECLARE_CYCLE_STAT(TEXT("TickAsyncLoading GT"), STAT_FAsyncPackage_TickAsyncLoadingGameThread, STATGROUP_AsyncLoadGameThread);
DECLARE_CYCLE_STAT(TEXT("Flush Async Loading GT"), STAT_FAsyncPackage_FlushAsyncLoadingGameThread, STATGROUP_AsyncLoadGameThread);
DECLARE_CYCLE_STAT(TEXT("Flush All Async Loads GT"), STAT_FAsyncPackage_FlushAllAsyncLoadingGameThread, STATGROUP_AsyncLoadGameThread);
DECLARE_CYCLE_STAT_WITH_FLAGS(TEXT("PostLoadInstances GT"), STAT_FAsyncPackage_PostLoadInstancesGameThread, STATGROUP_AsyncLoadGameThread, EStatFlags::Verbose);
DECLARE_CYCLE_STAT_WITH_FLAGS(TEXT("CreateClusters GT"), STAT_FAsyncPackage_CreateClustersGameThread, STATGROUP_AsyncLoadGameThread, EStatFlags::Verbose);
 
enum class ENotifyRegistrationType;
enum class ENotifyRegistrationPhase;
 
extern const FName PrestreamPackageClassNameLoad;
 
extern bool IsGarbageCollectionLocked();
 
bool IsNativeCodePackage(UPackage* Package);
 
bool CanPostLoadOnAsyncLoadingThread(UObject* Object);
 
template <typename T>
void ClearFlagsAndDissolveClustersFromLoadedObjects(T& LoadedObjects)
{
    const EObjectFlags ObjectLoadFlags = RF_NeedLoad | RF_NeedPostLoad | RF_NeedPostLoadSubobjects | RF_WasLoaded;
    for (UObject* ObjRef : LoadedObjects)
    {
        if (ObjRef)
        {
            ObjRef->AtomicallyClearFlags(ObjectLoadFlags);
            if (ObjRef->HasAnyInternalFlags(EInternalObjectFlags::ClusterRoot))
            {
                GUObjectClusters.DissolveCluster(ObjRef);
            }
        }
    }
}
 
class FPackageIndex;
class IAsyncPackageLoader;
class LinkerInstancingContext;
 
struct FAsyncLoadingThreadSettings
{
    bool bAsyncLoadingThreadEnabled;
    bool bAsyncPostLoadEnabled;
    bool bLooseFileLoadingEnabled;
 
    FAsyncLoadingThreadSettings();
 
    COREUOBJECT_API static FAsyncLoadingThreadSettings& Get();
};
 
class IAsyncPackageLoader
{
public:
    virtual ~IAsyncPackageLoader() {}
 
    virtual void InitializeLoading() = 0;
 
    virtual void ShutdownLoading() = 0;
 
    virtual void StartThread() = 0;
 
    virtual bool ShouldAlwaysLoadPackageAsync(const FPackagePath& PackagePath) = 0;
 
    virtual int32 LoadPackage(
            const FPackagePath& PackagePath,
            FName CustomPackageName,
            FLoadPackageAsyncDelegate InCompletionDelegate,
            EPackageFlags InPackageFlags,
            int32 InPIEInstanceID,
            int32 InPackagePriority,
            const FLinkerInstancingContext* InInstancingContext,
            uint32 InLoadFlags) = 0;
 
    virtual int32 LoadPackage(const FPackagePath& PackagePath, FLoadPackageAsyncOptionalParams OptionalParams)
    {
        checkf(false, TEXT("Not Implemented"));
        return INDEX_NONE;
    };
 
    virtual EAsyncPackageState::Type ProcessLoading(bool bUseTimeLimit, bool bUseFullTimeLimit, double TimeLimit) = 0;
    
    virtual EAsyncPackageState::Type ProcessLoadingUntilComplete(TFunctionRef<bool()> CompletionPredicate, double TimeLimit) = 0;
 
    virtual void CancelLoading() = 0;
 
    virtual void SuspendLoading() = 0;
 
    virtual void ResumeLoading() = 0;
 
    virtual void FlushLoading(TConstArrayView<int32> RequestIds) = 0;
 
    virtual int32 GetNumQueuedPackages() = 0;
 
    virtual int32 GetNumAsyncPackages() = 0;
 
    virtual float GetAsyncLoadPercentage(const FName& PackageName) = 0;
 
    virtual bool IsAsyncLoadingSuspended() = 0;
 
    virtual bool IsInAsyncLoadThread() = 0;
 
    virtual bool IsMultithreaded() = 0;
 
    virtual bool IsAsyncLoadingPackages() = 0;
 
    virtual void NotifyConstructedDuringAsyncLoading(UObject* Object, bool bSubObject) = 0;
 
    virtual void NotifyUnreachableObjects(const TArrayView<FUObjectItem*>& UnreachableObjects) = 0;
 
    virtual void NotifyRegistrationEvent(FName PackageName, FName Name, ENotifyRegistrationType NotifyRegistrationType, ENotifyRegistrationPhase NotifyRegistrationPhase, UObject* (*InRegister)(), bool InbDynamic, UObject* FinishedObject) = 0;
 
    virtual void NotifyScriptVersePackage(Verse::VPackage* Package) {}
 
    virtual void NotifyRegistrationComplete() = 0;
 
    virtual ELoaderType GetLoaderType() const = 0;
 
protected:
    static int32 GetNextRequestId();
 
private:
    static FThreadSafeCounter NextPackageRequestId;
};
 
// Stats for ChartCreation.cpp
extern COREUOBJECT_API double GFlushAsyncLoadingTime;
extern COREUOBJECT_API uint32 GFlushAsyncLoadingCount;
extern COREUOBJECT_API uint32 GSyncLoadCount;
 
extern COREUOBJECT_API void ResetAsyncLoadingStats();
 
// Time limit
extern COREUOBJECT_API int32 GWarnIfTimeLimitExceeded;
extern COREUOBJECT_API float GTimeLimitExceededMultiplier;
extern COREUOBJECT_API float GTimeLimitExceededMinTime;
 
void IsTimeLimitExceededPrint(
    double InTickStartTime,
    double CurrentTime,
    double LastTestTime,
    double InTimeLimit,
    const TCHAR* InLastTypeOfWorkPerformed = nullptr,
    UObject* InLastObjectWorkWasPerformedOn = nullptr);