HealthSnapshot.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "HealthSnapshot.generated.h"
 
class FPerformanceTrackingChart;
 
UCLASS(MinimalAPI)
class UHealthSnapshotBlueprintLibrary : public UBlueprintFunctionLibrary
{
 
    GENERATED_UCLASS_BODY()
 
    
    UFUNCTION(Exec, BlueprintCallable, Category = "Performance | HealthSnapshot")
    static ENGINE_API void StartPerformanceSnapshots();
 
    UFUNCTION(Exec, BlueprintCallable, Category = "Performance | HealthSnapshot")
    static ENGINE_API void StopPerformanceSnapshots();
 
 
    UFUNCTION(Exec, BlueprintCallable, Category = "Performance | HealthSnapshot")
    static ENGINE_API void LogPerformanceSnapshot(const FString SnapshotTitle, bool bResetStats=true);
 
    /* The performance chart we register with the engine for tracking */
    static ENGINE_API TSharedPtr<FPerformanceTrackingChart> PerformanceChart;
};
 
class FHealthSnapshot
{
public:
 
    ENGINE_API FHealthSnapshot(const TCHAR* Title);
 
    ENGINE_API FHealthSnapshot(const TCHAR* Title, const FPerformanceTrackingChart* GameplayFPSChart);
 
    virtual ~FHealthSnapshot() {}
 
    ENGINE_API void Dump(FOutputDevice& Ar);
 
protected:
 
    ENGINE_API virtual void CaptureMemoryStats();
 
    ENGINE_API virtual void CapturePerformanceStats(const FPerformanceTrackingChart* GameplayFPSChart);
 
    /* Dump a text blob describing all stats captured by the snapshot to the given output device with the given log category. */
    ENGINE_API virtual void DumpStats(FOutputDevice& Ar, FName CategoryName);
 
public:
 
    // Helper class that can describe memory in a system. Some systems may not provide Used/Peak values.
    template<typename T>
    struct FMemoryStat
    {
        FMemoryStat()
            : Size(T())
            , Used(T())
            , Peak(T())
        {}
 
        T Size;
        T Used;
        T Peak;
    };
 
    struct FThreadStat
    {
        FThreadStat()
            : PercentFramesBound(0)
            , HitchesPerMinute(0)
            , AvgTime(0)
        {}
 
        float PercentFramesBound;
        float HitchesPerMinute;
        float AvgTime;
    };
 
    template <typename T>
    struct FMmaStat
    {
        FMmaStat()
            : Min()
            , Max()
            , Avg()
        {}
 
        T Min;
        T Max;
        T Avg;
    };
 
    // General "how much memory is used"
    FMemoryStat<float> CPUMemoryMB;
    FMemoryStat<float> StreamingMemoryMB;
    // System level info
    FMemoryStat<float> PhysicalMemoryMB;
    float LLMTotalMemoryMB;
    FMmaStat<uint64> PhysicalMemory; // more detailed physical memory stats obtained more frequently
    FMmaStat<uint64> VirtualMemory;
    TArray<typename FPlatformMemoryStats::FPlatformSpecificStat> PlatformMemoryStats;
 
    double MeasuredPerfTime; // Duration of time the following performance values came from
    FThreadStat GameThread;
    FThreadStat RenderThread;
    FThreadStat RHIThread;
    FThreadStat GPU;
    double HitchesPerMinute;
    double AvgHitchTime;
    double MVP;
    double AvgFPS;
    FMmaStat<int> DrawCalls;
    FMmaStat<int> PrimitivesDrawn;
    FMmaStat<double> FrameTime;
    FMmaStat<double> DynamicResolution;
 
    FString Title;
};