NetStatsUtils.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ArrayView.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Misc/Optional.h"
#include "Templates/EnableIf.h"
#include "Templates/Models.h"
 
#include <limits>
 
 
namespace UE::Net
{
 
template<typename ConsumerType>
class TSampleProducer
{
    struct CSampleConsumer
    {
        template<typename T>
        auto Requires(T& A) -> decltype(
            A.AddSample(0.0)
        );
    };
 
    struct CPeekMeasurements
    {
        template<typename T>
        auto Requires(T& A) -> decltype(
            A.PeekMeasurement(0.0, 0.0)
        );
    };
 
    static_assert(TModels_V<CSampleConsumer, ConsumerType>, "ConsumerType must implement AddSample(double Val)");
 
public:
    void SetConsumer(ConsumerType* InConsumer)
    {
        Consumer = InConsumer;
    }
 
protected:
    void OutputSample(double Value)
    {
        if (Consumer != nullptr)
        {
            Consumer->AddSample(Value);
        }
    }
 
    template<typename InnerConsumerType=ConsumerType, typename = typename TEnableIf<TModels_V<CPeekMeasurements, InnerConsumerType>>::Type>
    inline void PeekMeasurement(double TimeVal, double Value)
    {
        if (Consumer != nullptr)
        {
            Consumer->PeekMeasurement(TimeVal, Value);
        }
    }
 
    template<typename InnerConsumerType=ConsumerType, typename = typename TEnableIf<!TModels_V<CPeekMeasurements, InnerConsumerType>>::Type, int32 UnusedParamForODR=0>
    inline void PeekMeasurement(double TimeVal, double Value)
    {
    }
 
private:
    ConsumerType* Consumer;
};
 
enum class EBinnedValueMode : uint8
{
    MovingAvg,
 
    MovingSum
};
 
class FBinnedMovingValueBase
{
protected:
    struct FBin
    {
        double Sum = 0.0;
 
        int32 Count = 0;
    };
 
protected:
    FBinnedMovingValueBase() = delete;
    NETCORE_API explicit FBinnedMovingValueBase(const TArrayView<FBin> InBins, double InTimePerBin, EBinnedValueMode InMode);
 
    NETCORE_API void AddMeasurement_Implementation(double TimeVal, double Value, TOptional<double>& OutSample);
 
public:
    NETCORE_API double GetSample() const;
 
    NETCORE_API void Reset();
 
private:
    NETCORE_API void ResetNewAndSkippedBins(int32 BinIdx, TOptional<double>& OutSample);
 
 
private:
    const TArrayView<FBin> BinsView;
 
    const double TimePerBin = 0.0;
 
    const double BinRange = 0.0;
 
    const EBinnedValueMode SampleMode = EBinnedValueMode::MovingAvg;
 
    int32 FirstBinIndex = INDEX_NONE;
 
    int32 LastWrittenBinIndex = INDEX_NONE;
 
    double TotalSum = 0.0;
 
    int32 TotalCount = 0;
};
 
template<typename ConsumerType, int32 NumBins, EBinnedValueMode InMode>
class TBinnedMovingValue : public FBinnedMovingValueBase, public TSampleProducer<ConsumerType>
{
public:
    explicit TBinnedMovingValue(double TimePerBin)
        : FBinnedMovingValueBase(MakeArrayView(Bins, NumBins), TimePerBin, InMode)
    {
    }
 
    void AddMeasurement(double TimeVal, double Value)
    {
        TOptional<double> FinalSample;
 
        TSampleProducer<ConsumerType>::PeekMeasurement(TimeVal, Value);
        AddMeasurement_Implementation(TimeVal, Value, FinalSample);
 
        if (FinalSample.IsSet())
        {
            this->OutputSample(FinalSample.GetValue());
        }
    }
 
    void Flush()
    {
        this->OutputSample(GetSample());
    }
 
private:
    FBin Bins[NumBins] = {};
};
 
template<typename ConsumerType, int32 NumBins, EBinnedValueMode InMode>
class TBinnedDeltaMovingValue : private TBinnedMovingValue<ConsumerType, NumBins, InMode>
{
    using Super = TBinnedMovingValue<ConsumerType, NumBins, InMode>;
 
public:
    // Using Super for constructors can break clang
    using TBinnedMovingValue<ConsumerType, NumBins, InMode>::TBinnedMovingValue;
    using Super::SetConsumer;
    using Super::GetSample;
    using Super::Flush;
 
    void AddMeasurement(double TimeVal, double Value)
    {
        if (LastValue != std::numeric_limits<double>::min())
        {
            Super::AddMeasurement(TimeVal, (Value - LastValue));
        }
 
        LastValue = Value;
    }
 
    void Reset()
    {
        Super::Reset();
 
        LastValue = std::numeric_limits<double>::min();
    }
 
private:
    double LastValue = std::numeric_limits<double>::min();
};
 
template<typename ConsumerType, int32 NumBins>
using TBinnedMovingAvg = TBinnedMovingValue<ConsumerType, NumBins, EBinnedValueMode::MovingAvg>;
 
template<typename ConsumerType, int32 NumBins>
using TDeltaBinnedMovingAvg = TBinnedDeltaMovingValue<ConsumerType, NumBins, EBinnedValueMode::MovingAvg>;
 
template<typename ConsumerType, int32 NumBins>
using TBinnedMovingSum = TBinnedMovingValue<ConsumerType, NumBins, EBinnedValueMode::MovingSum>;
 
template<typename ConsumerType, int32 NumBins>
using TDeltaBinnedMovingSum = TBinnedDeltaMovingValue<ConsumerType, NumBins, EBinnedValueMode::MovingSum>;
 
}
 
namespace TBinParms
{
    static constexpr int32 NumBins(int32 InNumBins)
    {
        return InNumBins;
    }
 
    static constexpr double TimePerBin(double InBinSize)
    {
        return InBinSize;
    }
}
 
 
namespace UE::Net
{
 
enum EMinMaxValueMode
{
    PerSample,
 
    PerMeasurement,
 
    PerTimeSeconds
};
 
class FSampleMinMaxAvg
{
    template<EMinMaxValueMode, int32> friend class TSampleMinMaxAvg;
 
private:
    NETCORE_API void AddSample_Internal(double Value);
 
public:
    NETCORE_API void Reset();
 
    double GetMin() const
    {
        return ((MinValue == std::numeric_limits<double>::max()) ? 0.0 : MinValue);
    }
 
    double GetMax() const
    {
        return ((MaxValue == std::numeric_limits<double>::min()) ? 0.0 : MaxValue);
    }
 
    double GetCurrent() const
    {
        return CurrentValue;
    }
 
    double GetAvg() const
    {
        return TotalCount == 0 ? 0.0 : (TotalSum / static_cast<double>(TotalCount));
    }
 
    double GetSum() const
    {
        return TotalSum;
    }
 
    int32 GetSampleCount() const
    {
        return TotalCount;
    }
 
private:
    double MinValue = std::numeric_limits<double>::max();
 
    double MaxValue = std::numeric_limits<double>::min();
 
    double CurrentValue = 0.0;
 
    double TotalSum = 0.0;
 
    int32 TotalCount = 0;
};
 
template<EMinMaxValueMode Mode, int32 MinMaxTimeSeconds=1>
class TSampleMinMaxAvg;
 
template<>
class TSampleMinMaxAvg<EMinMaxValueMode::PerSample> : public FSampleMinMaxAvg
{
public:
    void AddSample(double Value)
    {
        if (Value < MinValue)
        {
            MinValue = Value;
        }
 
        if (Value > MaxValue)
        {
            MaxValue = Value;
        }
 
        AddSample_Internal(Value);
    }
};
 
template<>
class TSampleMinMaxAvg<EMinMaxValueMode::PerMeasurement> : public FSampleMinMaxAvg
{
public:
    inline void AddSample(double Value)
    {
        AddSample_Internal(Value);
    }
 
    void PeekMeasurement(double TimeVal, double Value)
    {
        if (Value < MinValue)
        {
            MinValue = Value;
        }
 
        if (Value > MaxValue)
        {
            MaxValue = Value;
        }
    }
};
 
template<int32 MinMaxTimeSeconds>
class TSampleMinMaxAvg<EMinMaxValueMode::PerTimeSeconds, MinMaxTimeSeconds> : public FSampleMinMaxAvg
{
public:
    inline void AddSample(double Value)
    {
        AddSample_Internal(Value);
    }
 
    void PeekMeasurement(double TimeVal, double Value)
    {
        if (UNLIKELY(MinMaxPeriodStart == 0.0))
        {
            MinMaxPeriodStart = TimeVal;
        }
        else if ((TimeVal - MinMaxPeriodStart) >= static_cast<double>(MinMaxTimeSeconds))
        {
            const double NewMinMaxSample = MinMaxPeriodSum / MinMaxPeriodCount;
 
            if (NewMinMaxSample < MinValue)
            {
                MinValue = NewMinMaxSample;
            }
 
            if (NewMinMaxSample > MaxValue)
            {
                MaxValue = NewMinMaxSample;
            }
 
            MinMaxPeriodStart = TimeVal;
            MinMaxPeriodSum = 0.0;
            MinMaxPeriodCount = 0;
        }
 
        MinMaxPeriodSum += Value;
        MinMaxPeriodCount++;
    }
 
private:
    double MinMaxPeriodStart = 0.0;
 
    double MinMaxPeriodSum = 0.0;
 
    int32 MinMaxPeriodCount = 0;
};
 
class FUsingNetStatsUtils
{
public:
    template<typename ConsumerType> using TSampleProducer = TSampleProducer<ConsumerType>;
    using EBinnedValueMode = EBinnedValueMode;
    template<typename ConsumerType, int32 NumBins, EBinnedValueMode InMode> using TBinnedMovingValue =
        TBinnedMovingValue<ConsumerType, NumBins, InMode>;
    template<typename ConsumerType, int32 NumBins, EBinnedValueMode InMode> using TBinnedDeltaMovingValue =
        TBinnedDeltaMovingValue<ConsumerType, NumBins, InMode>;
    template<typename ConsumerType, int32 NumBins> using TBinnedMovingAvg = TBinnedMovingAvg<ConsumerType, NumBins>;
    template<typename ConsumerType, int32 NumBins> using TDeltaBinnedMovingAvg = TDeltaBinnedMovingAvg<ConsumerType, NumBins>;
    template<typename ConsumerType, int32 NumBins> using TBinnedMovingSum = TBinnedMovingSum<ConsumerType, NumBins>;
    template<typename ConsumerType, int32 NumBins> using TDeltaBinnedMovingSum = TDeltaBinnedMovingSum<ConsumerType, NumBins>;
    using EMinMaxValueMode = EMinMaxValueMode;
    using FSampleMinMaxAvg = FSampleMinMaxAvg;
    template<EMinMaxValueMode Mode, int32 MinMaxTimeSeconds=1> using TSampleMinMaxAvg = TSampleMinMaxAvg<Mode, MinMaxTimeSeconds>;
};
 
}
 
namespace TSampleParms
{
    static constexpr int32 TimeSeconds(int32 InTimeSeconds)
    {
        return InTimeSeconds;
    }
}