Histogram.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "HAL/PlatformCrt.h"
#include "Logging/LogMacros.h"
#include "Math/UnrealMathUtility.h"
#include "Misc/AssertionMacros.h"
#include "Templates/UnrealTemplate.h"
 
#include <initializer_list>
 
struct FAnalyticsEventAttribute;
struct FHistogramBuilder;
template <typename FuncType> class TFunctionRef;
 
DECLARE_LOG_CATEGORY_EXTERN(LogHistograms, Log, All);
 
 struct FHistogramBuilder;
 
struct FHistogram
{
    CORE_API void InitLinear(double MinTime, double MaxTime, double BinSize);
 
    CORE_API void InitHitchTracking();
 
    CORE_API void InitFromArray(TArrayView<const double> Thresholds);
 
    UE_FORCEINLINE_HINT void InitFromArray(std::initializer_list<double> Thresholds)
    {
        InitFromArray(MakeArrayView(Thresholds));
    }
 
    CORE_API void Reset();
 
    inline void AddMeasurement(double Value)
    {
        AddMeasurement(Value, Value);
    }
 
    CORE_API void AddMeasurement(double ValueForBinning, double MeasurementValue);
 
    CORE_API void DumpToLog(const FString& HistogramName);
 
    CORE_API FString DumpToJsonString(TFunctionRef<FString (double, double)> ConvertBinToLabel) const;
 
    CORE_API FString DumpToJsonString() const;
 
    CORE_API FString DumpToJsonString2(TFunctionRef<FString (double, double)> ConvertBinToLabel) const;
 
    CORE_API FString DumpToJsonString2() const;
 
    static CORE_API FString DefaultConvertBinToLabel(double MinValue, double UpperBound);
 
    inline int32 GetNumBins() const
    {
        return Bins.Num();
    }
 
    inline double GetBinLowerBound(int IdxBin) const
    {
        return Bins[IdxBin].MinValue;
    }
 
    inline double GetBinUpperBound(int IdxBin) const
    {
        return Bins[IdxBin].UpperBound;
    }
 
    inline int32 GetBinObservationsCount(int IdxBin) const
    {
        return Bins[IdxBin].Count;
    }
 
    inline double GetBinObservationsSum(int IdxBin) const
    {
        return Bins[IdxBin].Sum;
    }
 
    inline int64 GetNumMeasurements() const
    {
        return CountOfAllMeasures;
    }
 
    inline double GetSumOfAllMeasures() const
    {
        return SumOfAllMeasures;
    }
 
    inline double GetAverageOfAllMeasures() const
    {
        return (CountOfAllMeasures > 0) ? (SumOfAllMeasures / (double)CountOfAllMeasures) : 0 ;
    }
 
    inline double GetMinOfAllMeasures() const
    {
        return MinimalMeasurement;
    }
 
    inline double GetMaxOfAllMeasures() const
    {
        return MaximalMeasurement;
    }
 
    inline FHistogram operator-(const FHistogram& Other) const
    {
        // Logic below expects the bins to be of equal size
        check(GetNumBins() == Other.GetNumBins());
 
        FHistogram Tmp;
        for (int32 BinIndex = 0, NumBins = Bins.Num(); BinIndex < NumBins; BinIndex++)
        {
            Tmp.Bins.Add(Bins[BinIndex] - Other.Bins[BinIndex]);
        }
        return Tmp;
    }
 
    inline FHistogram operator+(const FHistogram& Other) const
    {
        // Logic below expects the bins to be of equal size
        check(GetNumBins() == Other.GetNumBins());
 
        FHistogram Tmp;
        for (int32 BinIndex = 0, NumBins = Bins.Num(); BinIndex < NumBins; BinIndex++)
        {
            Tmp.Bins.Add(Bins[BinIndex] + Other.Bins[BinIndex]);
        }
        return Tmp;
    }
 
    inline FHistogram& operator+=(const FHistogram& Other)
    {
        // Logic below expects the bins to be of equal size
        check(GetNumBins() == Other.GetNumBins());
 
        for (int32 BinIndex = 0, NumBins = Bins.Num(); BinIndex < NumBins; BinIndex++)
        {
            Bins[BinIndex] += Other.Bins[BinIndex];
        }
 
        SumOfAllMeasures += Other.SumOfAllMeasures;
        CountOfAllMeasures += Other.CountOfAllMeasures;
        MinimalMeasurement = FMath::Min(MinimalMeasurement, Other.MinimalMeasurement);
        MaximalMeasurement = FMath::Max(MaximalMeasurement, Other.MaximalMeasurement);
 
        return *this;
    }
 
protected:
 
    struct FBin
    {
        double MinValue;
 
        double UpperBound;
 
        double Sum;
 
        int32 Count;
 
        FBin()
        {
        }
 
        FBin(double MinInclusive, double MaxExclusive, double InSum, int32 InCount)  //@TODO: FLOATPRECISION: THIS CHANGES BEHAVIOR
            : MinValue(MinInclusive)
            , UpperBound(MaxExclusive)
            , Sum(InSum)
            , Count(InCount)
        {
        }
 
        FBin(double MinInclusive, double MaxExclusive)
            : MinValue(MinInclusive)
            , UpperBound(MaxExclusive)
            , Sum(0)
            , Count(0)
        {
        }
 
        FBin(double MinInclusive)
            : MinValue(MinInclusive)
            , UpperBound(FLT_MAX)
            , Sum(0)
            , Count(0)
        {
        }
 
        UE_FORCEINLINE_HINT FBin operator-(const FBin& Other) const
        {
            return FBin(MinValue, UpperBound, Sum - Other.Sum, Count - Other.Count);
        }
        UE_FORCEINLINE_HINT FBin operator+(const FBin& Other) const
        {
            return FBin(MinValue, UpperBound, Sum + Other.Sum, Count + Other.Count);
        }
        inline FBin& operator+=(const FBin& Other)
        {
            Sum += Other.Sum;
            Count += Other.Count;
            return *this;
        }
    };
 
    TArray<FBin> Bins;
 
    double SumOfAllMeasures;
    int64 CountOfAllMeasures;
    double MinimalMeasurement;
    double MaximalMeasurement;
 
    friend FHistogramBuilder;
};
 
struct FHistogramBuilder
{
    FHistogramBuilder(FHistogram& InHistogram, double StartingValue = 0.0)
        : MyHistogram(&InHistogram)
        , LastValue(StartingValue)
    {
        MyHistogram->SumOfAllMeasures = 0.0;
        MyHistogram->CountOfAllMeasures = 0;
        MyHistogram->MinimalMeasurement = DBL_MAX;
        MyHistogram->MaximalMeasurement = -DBL_MAX;
        MyHistogram->Bins.Reset();
    }
 
    void AddBin(double MaxValue)
    {
        // Can't add to a closed builder
        check(MyHistogram);
        MyHistogram->Bins.Emplace(LastValue, MaxValue);
        LastValue = MaxValue;
    }
 
    void FinishBins()
    {
        MyHistogram->Bins.Emplace(LastValue);
        MyHistogram = nullptr;
    }
 
    ~FHistogramBuilder()
    {
        // Close it out if the user hasn't already
        if (MyHistogram != nullptr)
        {
            FinishBins();
        }
    }
private:
    FHistogram* MyHistogram;
    double LastValue;
};