ExclusiveLoadPackageTimeTracker.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "HAL/CriticalSection.h"
#include "HAL/IConsoleManager.h"
#include "HAL/Platform.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/Package.h"
#include "UObject/UnrealNames.h"
 
class FString;
 
#define WITH_LOADPACKAGE_TIME_TRACKER STATS
 
class FExclusiveLoadPackageTimeTracker
{
public:
    struct FScopedPackageTracker
    {
        FScopedPackageTracker(UPackage* InPackageToTrack)
            : PackageToTrack(InPackageToTrack)
        {
            FExclusiveLoadPackageTimeTracker::PushLoadPackage(PackageToTrack ? PackageToTrack->GetFName() : NAME_None);
        }
        FScopedPackageTracker(FName PackageNameToTrack)
            : PackageToTrack(nullptr)
        {
            FExclusiveLoadPackageTimeTracker::PushLoadPackage(PackageNameToTrack);
        }
        ~FScopedPackageTracker()
        {
            FExclusiveLoadPackageTimeTracker::PopLoadPackage(PackageToTrack);
        }
        UPackage* PackageToTrack;
    };
 
    struct FScopedPostLoadTracker
    {
        FScopedPostLoadTracker(UObject* InPostLoadObject)
        {
            if (FExclusiveLoadPackageTimeTracker::PushPostLoad(InPostLoadObject))
            {
                PostLoadObject = InPostLoadObject;
            }
            else
            {
                PostLoadObject = nullptr;
            }
        }
        ~FScopedPostLoadTracker()
        {
            if (PostLoadObject)
            {
                FExclusiveLoadPackageTimeTracker::PopPostLoad(PostLoadObject);
            }
        }
        UObject* PostLoadObject;
    };
 
    struct FScopedEndLoadTracker
    {
        FScopedEndLoadTracker() { FExclusiveLoadPackageTimeTracker::PushEndLoad(); }
        ~FScopedEndLoadTracker() { FExclusiveLoadPackageTimeTracker::PopEndLoad(); }
    };
 
    UE_FORCEINLINE_HINT static void PushLoadPackage(FName PackageName)
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        Get().InternalPushLoadPackage(PackageName);
#endif
    }
 
    UE_FORCEINLINE_HINT static void PopLoadPackage(UPackage* LoadedPackage)
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        Get().InternalPopLoadPackage(LoadedPackage, nullptr);
#endif
    }
 
    inline static bool PushPostLoad(UObject* PostLoadObject)
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        if (PostLoadObject && PostLoadObject->IsAsset())
        {
            Get().InternalPushLoadPackage(PostLoadObject->GetOutermost()->GetFName());
            return true;
        }
#endif
        return false;
    }
 
    UE_FORCEINLINE_HINT static void PopPostLoad(UObject* PostLoadObject)
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        Get().InternalPopLoadPackage(nullptr, PostLoadObject);
#endif
    }
 
    inline static void PushEndLoad()
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        FExclusiveLoadPackageTimeTracker& Instance = Get();
        Instance.InternalPushLoadPackage(Instance.EndLoadName);
#endif
    }
 
    UE_FORCEINLINE_HINT static void PopEndLoad()
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        Get().InternalPopLoadPackage(nullptr, nullptr);
#endif
    }
 
    UE_FORCEINLINE_HINT static void DumpReport(const TArray<FString>& Args)
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        Get().InternalDumpReport(Args);
#endif
    }
 
    UE_FORCEINLINE_HINT static void ResetReport()
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        Get().InternalResetReport();
#endif
    }
 
    inline static double GetExclusiveLoadTime(FName PackageName)
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        return Get().InternalGetExclusiveLoadTime(PackageName);
#else
        return 0;
#endif
    }
 
    inline static double GetInclusiveLoadTime(FName PackageName)
    {
#if WITH_LOADPACKAGE_TIME_TRACKER
        return Get().InternalGetInclusiveLoadTime(PackageName);
#else
        return 0;
#endif
    }
 
 
#if WITH_LOADPACKAGE_TIME_TRACKER // The rest of the class is only available if WITH_LOADPACKAGE_TIME_TRACKER
 
private:
 
    struct FLoadTime
    {
        FName TimeName;
        FName AssetClass;
        double ExclusiveTime;
        double InclusiveTime;
        double LastStartTime;
        double OriginalStartTime;
 
        FLoadTime()
            : ExclusiveTime(0), InclusiveTime(0), LastStartTime(0), OriginalStartTime(0)
        {}
 
        FLoadTime(FName InName, double InStartTime)
            : TimeName(InName), ExclusiveTime(0), InclusiveTime(0), LastStartTime(InStartTime), OriginalStartTime(InStartTime)
        {}
 
        FLoadTime(FName InName, FName InAssetClass, double InExclusive, double InInclusive)
            : TimeName(InName), ExclusiveTime(InExclusive), InclusiveTime(InInclusive), LastStartTime(0), OriginalStartTime(0)
        {}
    };
 
    inline static FExclusiveLoadPackageTimeTracker& Get()
    {
        if (TrackerInstance)
            return *TrackerInstance;
        else
            return Construct();
    }
 
    FExclusiveLoadPackageTimeTracker();
    COREUOBJECT_API static FExclusiveLoadPackageTimeTracker& Construct();
 
    COREUOBJECT_API void InternalPushLoadPackage(FName PackageName);
 
    COREUOBJECT_API void InternalPopLoadPackage(UPackage* LoadedPackage, UObject* LoadedAsset);
 
    COREUOBJECT_API void InternalDumpReport(const TArray<FString>& Args) const;
 
    COREUOBJECT_API void InternalResetReport();
 
    COREUOBJECT_API double InternalGetExclusiveLoadTime(FName PackageName) const;
 
    COREUOBJECT_API double InternalGetInclusiveLoadTime(FName PackageName) const;
 
    bool IsPackageLoadTime(const FLoadTime& Time) const;
 
    void DumpReportCommandHandler(const TArray<FString>& Args);
 
    void ResetReportCommandHandler(const TArray<FString>& Args);
    
    TArray<FLoadTime> TimeStack;
 
    mutable FCriticalSection TimesCritical;
 
    TMap<FName, FLoadTime> LoadTimes;
 
    double TrackerOverhead;
 
    const FName EndLoadName;
    const FName UnknownAssetName;
 
    const FAutoConsoleCommand DumpReportCommand;
 
    const FAutoConsoleCommand ResetReportCommand;
 
    static FExclusiveLoadPackageTimeTracker* TrackerInstance;
 
#endif // WITH_LOADPACKAGE_TIME_TRACKER
};