ChartCreation.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "ProfilingDebugging/Histogram.h"
#include "Scalability.h"
#include "Delegates/IDelegateInstance.h"
 
 
// What kind of hitch was detected (if any)
enum class EFrameHitchType : uint8
{
    // We didn't hitch
    NoHitch,
 
    // We hitched but couldn't isolate which unit caused it
    UnknownUnit,
 
    // Hitched and it was likely caused by the game thread
    GameThread,
 
    // Hitched and it was likely caused by the render thread
    RenderThread,
 
    // Hitched and it was likely caused by the RHI thread
    RHIThread,
 
    // Hitched and it was likely caused by the GPU
    GPU
};
 
 
// IPerformanceDataConsumer
 
// This is an interface for any consumer of per-frame performance data
// such as FPS charts, PerfCounters, analytics, etc...
 
class IPerformanceDataConsumer
{
public:
    struct FFrameData
    {
        // Estimate of how long the last frame was (this is either TrueDeltaSeconds or TrueDeltaSeconds - IdleSeconds, depending on the cvar t.FPSChart.ExcludeIdleTime)
        double DeltaSeconds;
 
        // Time elapsed since the last time the performance tracking system ran
        double TrueDeltaSeconds;
 
        // How long did we burn idling until this frame (FApp::GetIdleTime) (e.g., when running faster than a frame rate target on a dedicated server)
        double IdleSeconds;
 
        // How long did we burn idling beyond what we requested this frame (FApp::GetIdleTimeOvershoot). WaitTime we requested for the frame = IdleSeconds - IdleOvershootSeconds.
        double IdleOvershootSeconds;
 
        // Duration of each of the major functional units (GPU time is frequently inferred rather than actual)
        double GameThreadTimeSeconds;
        double RenderThreadTimeSeconds;
        double RHIThreadTimeSeconds;
        double GPUTimeSeconds;
        double GameDriverTickFlushTimeSeconds;
        double DemoDriverTickFlushTimeSeconds;
 
        double DynamicResolutionScreenPercentage;
 
        double FlushAsyncLoadingTime;
        uint32 FlushAsyncLoadingCount;
        uint32 SyncLoadCount;
 
        int32 NumAsyncPackages;
 
        // Should this frame be considered for histogram generation (controlled by t.FPSChart.MaxFrameDeltaSecsBeforeDiscarding)
        bool bBinThisFrame;
 
        // Was this frame bound in one of the major functional units (only set if bBinThisFrame is true and the frame was longer than FEnginePerformanceTargets::GetTargetFrameTimeThresholdMS) 
        bool bGameThreadBound;
        bool bRenderThreadBound;
        bool bRHIThreadBound;
        bool bGPUBound;
 
        // Did we hitch?
        EFrameHitchType HitchStatus;
 
        // If a hitch, how was it bound
        //@TODO: This uses different logic to the three bools above but probably shouldn't (though it also ignores the MaxFrameDeltaSecsBeforeDiscarding)
 
        FFrameData()
            : DeltaSeconds(0.0)
            , TrueDeltaSeconds(0.0)
            , IdleSeconds(0.0)
            , IdleOvershootSeconds(0.0)
            , GameThreadTimeSeconds(0.0)
            , RenderThreadTimeSeconds(0.0)
            , RHIThreadTimeSeconds(0.0)
            , GPUTimeSeconds(0.0)
            , GameDriverTickFlushTimeSeconds(0.0)
            , DemoDriverTickFlushTimeSeconds(0.0)
            , DynamicResolutionScreenPercentage(0.0)
            , FlushAsyncLoadingTime(0.0)
            , FlushAsyncLoadingCount(0)
            , SyncLoadCount(0)
            , NumAsyncPackages(0)
            , bBinThisFrame(false)
            , bGameThreadBound(false)
            , bRenderThreadBound(false)
            , bRHIThreadBound(false)
            , bGPUBound(false)
            , HitchStatus(EFrameHitchType::NoHitch)
        {
        }
    };
 
    virtual void StartCharting()=0;
    virtual void ProcessFrame(const FFrameData& FrameData)=0;
    virtual void StopCharting()=0;
    virtual ~IPerformanceDataConsumer() {}
};
 
// FPerformanceTrackingChart
 
class FPerformanceTrackingChart : public IPerformanceDataConsumer
{
public:
    // The mode being tracked by this chart
    FString ChartLabel;
 
    // Frame time histogram (in seconds)
    FHistogram FrametimeHistogram;
 
    // Hitch time histogram (in seconds)
    FHistogram HitchTimeHistogram;
 
    // Hitch time histogram (in seconds)
    FHistogram DynamicResHistogram;
 
    // Track size of the async loader package queue (I/O)
    FHistogram AsyncPackageQueueHistogram;
 
    uint32 NumFramesBound_GameThread;
    uint32 NumFramesBound_RenderThread;
    uint32 NumFramesBound_RHIThread;
    uint32 NumFramesBound_GPU;
 
    double TotalFramesBoundTime_GameThread;
    double TotalFramesBoundTime_RenderThread;
    double TotalFramesBoundTime_RHIThread;
    double TotalFramesBoundTime_GPU;
 
    double TotalFrameTime_GameThread;
    double TotalFrameTime_RenderThread;
    double TotalFrameTime_RHIThread;
    double TotalFrameTime_GPU;
 
    double TotalFlushAsyncLoadingTime;
    int32  TotalFlushAsyncLoadingCalls;
    double MaxFlushAsyncLoadingTime;
 
    uint32 TotalSyncLoadCount;
 
    int32 TotalGameThreadBoundHitchCount;
    int32 TotalRenderThreadBoundHitchCount;
    int32 TotalRHIThreadBoundHitchCount;
    int32 TotalGPUBoundHitchCount;
 
    int32 MaxDrawCalls;
    int32 MinDrawCalls;
    int32 TotalDrawCalls;
 
    int32 MaxPlayerTicks;
    int32 MinPlayerTicks;
    int32 TotalPlayerTicks;
 
    int32 MaxVehicleTicks;
    int32 TotalVehicleTicks;
 
    int32 MaxDrawnPrimitives;
    int32 MinDrawnPrimitives;
    int64 TotalDrawnPrimitives;
 
    FDateTime CaptureStartTime;
 
    double AccumulatedChartTime;
 
    double TimeDisregarded;
    int FramesDisregarded;
 
    float StartTemperatureLevel;
    float StopTemperatureLevel;
 
    int StartBatteryLevel;
    int StopBatteryLevel;
 
    FString DeviceProfileName;
 
    bool bIsChartingPaused;
    
    // memory stats
    uint32 NumFramesAtCriticalMemoryPressure;
    uint64 MaxPhysicalMemory;
    uint64 MaxVirtualMemory;
    uint64 MinPhysicalMemory;
    uint64 MinVirtualMemory;
    uint64 MinAvailablePhysicalMemory;
    uint64 TotalPhysicalMemoryUsed;
    uint64 TotalVirtualMemoryUsed;
 
public:
    ENGINE_API FPerformanceTrackingChart();
    ENGINE_API FPerformanceTrackingChart(const FDateTime& InStartTime, const FString& InChartLabel);
    ENGINE_API virtual ~FPerformanceTrackingChart();
 
    // Discard all accumulated data
    ENGINE_API void Reset(const FDateTime& InStartTime);
 
    ENGINE_API void AccumulateWith(const FPerformanceTrackingChart& Chart);
 
    double GetTotalTime() const
    {
        return FrametimeHistogram.GetSumOfAllMeasures();
    }
 
    int64 GetNumFrames() const
    {
        return FrametimeHistogram.GetNumMeasurements();
    }
 
    double GetAverageFramerate() const
    {
        return GetNumFrames() / GetTotalTime();
    }
 
    int64 GetNumHitches() const
    {
        return HitchTimeHistogram.GetNumMeasurements();
    }
 
    ENGINE_API double GetTotalHitchFrameTime(bool bSubtractHitchThreshold = true) const;
 
    double GetPercentHitchTime(bool bSubtractHitchThreshold = true) const
    {
        const double TotalTime = GetTotalTime();
        const double TotalHitchTime = GetTotalHitchFrameTime(bSubtractHitchThreshold);
        return (TotalTime > 0.0) ? ((TotalHitchTime * 100.0) / TotalTime) : 0.0;
    }
 
    double GetPercentMissedVSync(int32 TargetFPS) const
    {
        const int64 TotalTargetFrames = static_cast<int64>(TargetFPS * GetTotalTime());
        const int64 MissedFrames = FMath::Max<int64>(TotalTargetFrames - GetNumFrames(), 0);
        return ((MissedFrames * 100.0) / (double)TotalTargetFrames);
    }
 
    double GetAvgHitchesPerMinute() const
    {
        const double TotalTime = GetTotalTime();
        const int32 TotalHitchCount = (int32)GetNumHitches();
 
        return (TotalTime > 0.0) ? (TotalHitchCount / (TotalTime / 60.0f)) : 0.0;
    }
 
    double GetAvgHitchFrameLength() const
    {
        return HitchTimeHistogram.GetAverageOfAllMeasures();
    }
 
    ENGINE_API double GetPercentFramesIOBusy(int32 StartingBin=0) const;
 
    void ChangeLabel(const FString& NewLabel)
    {
        ChartLabel = NewLabel;
    }
 
    ENGINE_API void DumpFPSChart(const FString& InMapName);
 
    // Dumps the FPS chart information to an analytic event param array.
    ENGINE_API void DumpChartToAnalyticsParams(const FString& InMapName, TArray<struct FAnalyticsEventAttribute>& InParamArray, bool bIncludeClientHWInfo, bool bIncludeHistograms = true) const;
 
 
    // Dumps the FPS chart information to the log.
    ENGINE_API void DumpChartsToOutputLog(double WallClockElapsed, const TArray<const FPerformanceTrackingChart*>& Charts, const FString& InMapName);
 
#if ALLOW_DEBUG_FILES
    // Dumps the FPS chart information to HTML.
    ENGINE_API void DumpChartsToHTML(double WallClockElapsed, const TArray<const FPerformanceTrackingChart*>& Charts, const FString& InMapName, const FString& HTMLFilename);
 
    // Dumps the FPS chart information to the special stats log file.
    ENGINE_API void DumpChartsToLogFile(double WallClockElapsed, const TArray<const FPerformanceTrackingChart*>& Charts, const FString& InMapName, const FString& LogFileName);
#endif
 
    // IPerformanceDataConsumer interface
    ENGINE_API virtual void StartCharting() override;
    ENGINE_API virtual void ProcessFrame(const FFrameData& FrameData) override;
    ENGINE_API virtual void StopCharting() override;
    // End of IPerformanceDataConsumer interface
 
    ENGINE_API void PauseCharting();
    ENGINE_API void ResumeCharting();
};
 
// FFineGrainedPerformanceTracker
 
#if ALLOW_DEBUG_FILES
 
// Fine-grained tracking (records the frame time of each frame rather than just a histogram)
class FFineGrainedPerformanceTracker : public IPerformanceDataConsumer
{
public:
    ENGINE_API FFineGrainedPerformanceTracker(const FDateTime& InStartTime);
 
    ENGINE_API void Presize(int32 NumFrames);
 
    ENGINE_API void DumpFrameTimesToStatsLog(const FString& FrameTimeFilename);
 
    static ENGINE_API float GetPercentileValue(TArray<float>& Samples, int32 Percentile);
 
    // IPerformanceDataConsumer interface
    ENGINE_API virtual void StartCharting() override;
    ENGINE_API virtual void ProcessFrame(const FFrameData& FrameData) override;
    ENGINE_API virtual void StopCharting() override;
    // End of IPerformanceDataConsumer interface
 
public:
    TArray<float> RenderThreadFrameTimes;
    TArray<float> GameThreadFrameTimes;
    TArray<float> GPUFrameTimes;
    TArray<float> FrameTimes;
    TArray<int32> ActiveModes;
    TArray<float> DynamicResolutionScreenPercentages;
 
    const FDateTime CaptureStartTime;
 
    int32 CurrentModeContext;
};
 
#endif
 
// FPerformanceTrackingSystem
 
// Overall state of the built-in performance tracking
struct FPerformanceTrackingSystem
{
public:
    ENGINE_API FPerformanceTrackingSystem();
 
    ENGINE_API IPerformanceDataConsumer::FFrameData AnalyzeFrame(float DeltaSeconds);
    ENGINE_API void StartCharting();
    ENGINE_API void StopCharting();
 
    static ENGINE_API FString CreateFileNameForChart(const FString& ChartType, const FString& InMapName, const FString& FileExtension);
 
    static ENGINE_API FString CreateOutputDirectory(const FDateTime& CaptureStartTime);
 
    // Should we subtract off idle time spent waiting (due to running above target framerate) before thresholding into bins?
    // (controlled by t.FPSChart.ExcludeIdleTime)
    static ENGINE_API bool ShouldExcludeIdleTimeFromCharts();
 
private:
    double FPSChartStartTime;
 
    double FPSChartStopTime;
 
    double LastTimeChartCreationTicked;
 
    float LastDeltaSeconds;
 
    double LastHitchTime;
};
 
 
// Prints the FPS chart summary to an endpoint
struct FDumpFPSChartToEndpoint
{
protected:
    const FPerformanceTrackingChart& Chart;
 
public:
    ENGINE_API void DumpChart(double InWallClockTimeFromStartOfCharting, FString InMapName, FString InDeviceProfileName = FString(TEXT("Unknown")));
 
    FDumpFPSChartToEndpoint(const FPerformanceTrackingChart& InChart)
        : Chart(InChart)
    {
    }
 
    virtual ~FDumpFPSChartToEndpoint() { }
 
protected:
    double WallClockTimeFromStartOfCharting; // This can be much larger than TotalTime if the chart was paused or long frames were omitted
    FString MapName;
    FString DeviceProfileName;
 
    float AvgGPUFrameTime;
    float AvgRenderThreadFrameTime;
    float AvgGameThreadFrameTime;
 
    double TotalFlushAsyncLoadingTimeInMS;
    int32  TotalFlushAsyncLoadingCalls;
    double MaxFlushAsyncLoadingTimeInMS;
    double AvgFlushAsyncLoadingTimeInMS;
 
    int32 TotalSyncLoadCount;
 
    float BoundGameThreadPct;
    float BoundRenderThreadPct;
    float BoundGPUPct;
 
    Scalability::FQualityLevels ScalabilityQuality;
    FIntPoint GameResolution;
    FString WindowMode;
 
    FString OSMajor;
    FString OSMinor;
 
    FString CPUVendor;
    FString CPUBrand;
 
    // The primary GPU for the desktop (may not be the one we ended up using, e.g., in an optimus laptop)
    FString DesktopGPUBrand;
 
    // The actual GPU adapter we initialized
    FString ActualGPUBrand;
 
protected:
    virtual void PrintToEndpoint(const FString& Text) = 0;
 
    ENGINE_API virtual void FillOutMemberStats();
    ENGINE_API virtual void HandleHitchBucket(const FHistogram& HitchHistogram, int32 BucketIndex);
    ENGINE_API virtual void HandleHitchSummary(int32 TotalHitchCount, double TotalTimeSpentInHitchBuckets);
    ENGINE_API virtual void HandleFPSThreshold(int32 TargetFPS, float PctMissedFrames);
    ENGINE_API virtual void HandleDynamicResThreshold(int32 TargetScreenPercentage, float PctTimeAbove);
    ENGINE_API virtual void HandleBasicStats();
};