StatsCollector.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
 
namespace BuildPatchServices
{
    enum class EStatFormat : uint8
    {
        // Using the AccumulateTimeBegin and End functions, measured in cycles
        Timer,
        // Value measured in Bytes
        DataSize,
        // Value measured in Bytes per second
        DataSpeed,
        // Uses percentage printing, the returned stat should only be used with the percentage helpers
        Percentage,
        // Generic int64 output
        Value
    };
 
    class FStatsCollector
    {
    public:
        typedef int64 FAtomicValue;
 
    public:
        virtual ~FStatsCollector() {}
        virtual volatile FAtomicValue* CreateStat(const FString& Name, EStatFormat Type, FAtomicValue InitialValue = 0) = 0;
        virtual void LogStats(float TimeBetweenLogs = 0.0f) = 0;
 
    public:
        static uint64 GetCycles();
        static double GetSeconds();
        static double CyclesToSeconds(uint64 Cycles);
        static uint64 SecondsToCycles(double Seconds);
        static void AccumulateTimeBegin(uint64& TempValue);
        static void AccumulateTimeEnd(volatile FAtomicValue* Stat, uint64& TempValue);
        static void Accumulate(volatile FAtomicValue* Stat, int64 Amount);
        static void Set(volatile FAtomicValue* Stat, int64 Value);
        static void SetAsPercentage(volatile FAtomicValue* Stat, double Value);
        static double GetAsPercentage(volatile FAtomicValue* Stat);
    };
 
    class FStatsCollectorFactory
    {
    public:
        static FStatsCollector* Create();
    };
 
    class FStatsScopedTimer
    {
    public:
        FStatsScopedTimer(volatile FStatsCollector::FAtomicValue* InStat)
            : Stat(InStat)
        {
            FStatsCollector::AccumulateTimeBegin(TempTime);
        }
        ~FStatsScopedTimer()
        {
            FStatsCollector::AccumulateTimeEnd(Stat, TempTime);
        }
 
    private:
        uint64 TempTime;
        volatile FStatsCollector::FAtomicValue* Stat;
    };
 
    class FStatsParallelScopeTimer
    {
    public:
        FStatsParallelScopeTimer(volatile FStatsCollector::FAtomicValue* InStaticTempValue, volatile FStatsCollector::FAtomicValue* InTimerStat, volatile FStatsCollector::FAtomicValue* InCounterStat)
            : TempTime(InStaticTempValue)
            , TimerStat(InTimerStat)
            , CounterStat(InCounterStat)
        {
            FStatsCollector::FAtomicValue OldValue = FPlatformAtomics::InterlockedAdd(CounterStat, 1);
            if (OldValue == 0)
            {
                FPlatformAtomics::InterlockedExchange(TempTime, FStatsCollector::FAtomicValue(FStatsCollector::GetCycles()));
            }
        }
        ~FStatsParallelScopeTimer()
        {
            FStatsCollector::FAtomicValue CurrTempTime = *TempTime;
            FStatsCollector::FAtomicValue OldValue = FPlatformAtomics::InterlockedAdd(CounterStat, -1);
            if (OldValue == 1)
            {
                FPlatformAtomics::InterlockedAdd(TimerStat, FStatsCollector::FAtomicValue(FStatsCollector::GetCycles() - CurrTempTime));
            }
        }
        FStatsCollector::FAtomicValue GetCurrentTime() const
        {
            return (*TimerStat) + ((*CounterStat) > 0 ? FStatsCollector::FAtomicValue(FStatsCollector::GetCycles() - (*TempTime)) : 0);
        }
 
    private:
        volatile FStatsCollector::FAtomicValue* TempTime;
        volatile FStatsCollector::FAtomicValue* TimerStat;
        volatile FStatsCollector::FAtomicValue* CounterStat;
    };
}