StatsSystemTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Misc/Build.h"
#include "Misc/CoreMiscDefines.h"
 
// Note: it would be nice to only include these when STATS is defined but many other files
// currently rely on these includes indirectly.
#include "Containers/Array.h"
#include "Containers/ChunkedArray.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/LockFreeList.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/LowLevelMemTracker.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PlatformMemory.h"
#include "HAL/PlatformMisc.h"
#include "HAL/PlatformTLS.h"
#include "HAL/PlatformTime.h"
#include "HAL/ThreadSafeCounter.h"
#include "HAL/UnrealMemory.h"
#include "Math/Color.h"
#include "Math/NumericLimits.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CString.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/SourceLocation.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "ProfilingDebugging/CpuProfilerTrace.h"
#include "ProfilingDebugging/MiscTrace.h"
#include "Stats/StatsCommon.h"
#include "Stats/StatsTrace.h"
#include "Templates/Atomic.h"
#include "Templates/SharedPointer.h"
#include "Templates/TypeCompatibleBytes.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "Trace/Detail/Channel.h"
#include "Trace/Detail/Channel.inl"
#include "Trace/Trace.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
#if STATS
 
class FThreadStats;
template <typename T> struct TIsPODType;
 
struct TStatIdData
{
    bool IsNone() const
    {
        FMinimalName LocalName = Name.Load(EMemoryOrder::Relaxed);
        return LocalName.IsNone();
    }
 
    TStatIdData() = default;
 
    TStatIdData(FMinimalName InName) : Name(InName)
    {
    }
 
    TAtomic<FMinimalName> Name;
 
    TUniquePtr<WIDECHAR[]> StatDescriptionWide;
 
    TUniquePtr<ANSICHAR[]> StatDescriptionAnsi;
};
 
struct TStatId
{
    UE_FORCEINLINE_HINT TStatId()
        : StatIdPtr(&TStatId_NAME_None)
    {
    }
    UE_FORCEINLINE_HINT TStatId(TStatIdData const* InStatIdPtr)
        : StatIdPtr(InStatIdPtr)
    {
    }
    UE_FORCEINLINE_HINT bool IsValidStat() const
    {
        return !IsNone();
    }
    UE_FORCEINLINE_HINT bool IsNone() const
    {
        return StatIdPtr->IsNone();
    }
    UE_FORCEINLINE_HINT TStatIdData const* GetRawPointer() const
    {
        return StatIdPtr;
    }
 
    UE_FORCEINLINE_HINT FMinimalName GetMinimalName(EMemoryOrder MemoryOrder) const
    {
        return StatIdPtr->Name.Load(MemoryOrder);
    }
 
    UE_FORCEINLINE_HINT FName GetName() const
    {
        return MinimalNameToName(StatIdPtr->Name);
    }
 
    UE_FORCEINLINE_HINT static const TStatIdData& GetStatNone()
    {
        return TStatId_NAME_None;
    }
 
    UE_FORCEINLINE_HINT const ANSICHAR* GetStatDescriptionANSI() const
    {
        return StatIdPtr->StatDescriptionAnsi.Get();
    }
 
    UE_FORCEINLINE_HINT const WIDECHAR* GetStatDescriptionWIDE() const
    {
        return StatIdPtr->StatDescriptionWide.Get();
    }
 
    UE_FORCEINLINE_HINT bool operator==(TStatId Other) const
    {
        return StatIdPtr == Other.StatIdPtr;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(TStatId Other) const
    {
        return StatIdPtr != Other.StatIdPtr;
    }
 
    friend uint32 GetTypeHash(TStatId StatId)
    {
        return GetTypeHash(StatId.StatIdPtr);
    }
 
    static void AutoRTFMAssignFromOpenToClosed(TStatId& Closed, const TStatId& Open)
    {
        Closed = Open;
    }
 
private:
    CORE_API static TStatIdData TStatId_NAME_None;
 
    TStatIdData const* StatIdPtr;
};
 
namespace EThreadType
{
    enum Type
    {
        Invalid,
        Game,
        Renderer,
        EndOfPipe,
        Other,
    };
}
 
 
struct EStatDataType
{
    enum Type
    {
        Invalid,
        ST_None,
        ST_int64,
        ST_double,
        ST_FName,
        ST_Ptr,
 
        Num,
        Mask = 0x7,
        Shift = 0,
        NumBits = 3
    };
};
 
struct EStatOperation
{
    enum Type
    {
        Invalid,
        SetLongName,
        AdvanceFrameEventGameThread,
        AdvanceFrameEventRenderThread,
        AdvanceFrameEventEndOfPipe,
        CycleScopeStart,
        CycleScopeEnd,
        SpecialMessageMarker,
        Set,
        Clear,
        Add,
        Subtract,
 
        // these are special ones for processed data
        ChildrenStart,
        ChildrenEnd,
        Leaf,
        MaxVal,
 
        Memory UE_DEPRECATED(5.3, "Use Trace/MemoryInsights and/or LLM for memory profiling."),
 
        Num,
        Mask = 0xf,
        Shift = EStatDataType::Shift + EStatDataType::NumBits,
        NumBits = 4
    };
};
 
struct EStatMetaFlags
{
    enum Type
    {
        Invalid = 0x00,
        DummyAlwaysOne = 0x01,
        IsGPU = 0x02,
        IsCycle = 0x04,
        IsMemory = 0x08,
        IsPackedCCAndDuration = 0x10,
        ShouldClearEveryFrame = 0x20,
        SendingFName = 0x40,
 
        Num = 0x80,
        Mask = 0xff,
        Shift = EStatOperation::Shift + EStatOperation::NumBits,
        NumBits = 8
    };
};
 
//@todo merge these two after we have redone the user end
struct EMemoryRegion
{
    enum Type
    {
        Invalid = FPlatformMemory::MCR_Invalid,
 
        Num = FPlatformMemory::MCR_MAX,
        Mask = 0xf,
        Shift = EStatMetaFlags::Shift + EStatMetaFlags::NumBits,
        NumBits = 4
    };
    static_assert(FPlatformMemory::MCR_MAX < (1 << NumBits), "Need to expand memory region field.");
};
 
enum class UE_DEPRECATED(5.3, "Use Trace/MemoryInsights and/or LLM for memory profiling.") EMemoryOperation : uint8
{
    Invalid,
    Alloc,
    Free,
    Realloc,
 
    Num,
    Mask = 0x7,
    NumBits = 3,
};
 
namespace EStatAllFields
{
    enum Type
    {
        NumBits = EMemoryRegion::Shift + EMemoryRegion::NumBits,
        StartShift = 28 - NumBits,
    };
}
 
static_assert(EStatAllFields::StartShift > 0, "Too many stat fields.");
 
UE_FORCEINLINE_HINT int64 ToPackedCallCountDuration(uint32 CallCount, uint32 Duration)
{
    return (int64(CallCount) << 32) | Duration;
}
 
UE_FORCEINLINE_HINT uint32 FromPackedCallCountDuration_CallCount(int64 Both)
{
    return uint32(Both >> 32);
}
 
UE_FORCEINLINE_HINT uint32 FromPackedCallCountDuration_Duration(int64 Both)
{
    return uint32(Both & MAX_uint32);
}
 
class FStatNameAndInfo
{
    FNameEntryId Index;
    int32 Number;
 
public:
    static CORE_API const char* GpuStatCategory;
 
    UE_FORCEINLINE_HINT FStatNameAndInfo()
    {
    }
 
    inline FStatNameAndInfo(FName Other, bool bAlreadyHasMeta)
        : Index(Other.GetComparisonIndex())
        , Number(Other.GetNumber())
    {
        if (!bAlreadyHasMeta)
        {
            // ok, you can't have numbered stat FNames too large
            checkStats(!(Number >> EStatAllFields::StartShift));
            Number |= EStatMetaFlags::DummyAlwaysOne << (EStatMetaFlags::Shift + EStatAllFields::StartShift);
        }
        CheckInvariants();
    }
 
    inline FStatNameAndInfo(FName InStatName, char const* InGroup, char const* InCategory, TCHAR const* InDescription, EStatDataType::Type InStatType, bool bShouldClearEveryFrame, bool bCycleStat, bool bSortByName, FPlatformMemory::EMemoryCounterRegion MemoryRegion = FPlatformMemory::MCR_Invalid)
    {
        FName LongName = ToLongName(InStatName, InGroup, InCategory, InDescription, bSortByName);
        Index = LongName.GetComparisonIndex();
        Number = LongName.GetNumber();
 
        // ok, you can't have numbered stat FNames too large
        checkStats(!(Number >> EStatAllFields::StartShift));
        Number |= EStatMetaFlags::DummyAlwaysOne << (EStatMetaFlags::Shift + EStatAllFields::StartShift);
 
        SetField<EStatDataType>(InStatType);
        SetFlag(EStatMetaFlags::ShouldClearEveryFrame, bShouldClearEveryFrame);
        SetFlag(EStatMetaFlags::IsCycle, bCycleStat);
        if (MemoryRegion != FPlatformMemory::MCR_Invalid)
        {
            SetFlag(EStatMetaFlags::IsMemory, true);
            SetField<EMemoryRegion>(EMemoryRegion::Type(MemoryRegion));
        }
 
        if (InCategory == GpuStatCategory)
        {
            SetFlag(EStatMetaFlags::IsGPU, true);
        }
 
        CheckInvariants();
    }
 
    UE_FORCEINLINE_HINT void SetNumberDirect(int32 InNumber)
    {
        Number = InNumber;
    }
 
    inline int32 GetRawNumber() const
    {
        CheckInvariants();
        return Number;
    }
 
    inline void SetRawName(FName RawName)
    {
        // ok, you can't have numbered stat FNames too large
        checkStats(!(RawName.GetNumber() >> EStatAllFields::StartShift));
        CheckInvariants();
        int32 LocalNumber = Number;
        LocalNumber &= ~((1 << EStatAllFields::StartShift) - 1);
        Index = RawName.GetComparisonIndex();
        Number = (LocalNumber | RawName.GetNumber());
    }
 
    inline FName GetRawName() const
    {
        CheckInvariants();
        return FName(Index, Index, Number & ((1 << EStatAllFields::StartShift) - 1));
    }
 
    inline FName GetEncodedName() const
    {
        CheckInvariants();
        return FName(Index, Index, Number);
    }
 
    inline FName GetShortName() const
    {
        CheckInvariants();
        return GetShortNameFrom(GetRawName());
    }
 
    inline FName GetGroupName() const
    {
        CheckInvariants();
        return GetGroupNameFrom(GetRawName());
    }
 
    inline FName GetGroupCategory() const
    {
        CheckInvariants();
        return GetGroupCategoryFrom(GetRawName());
    }
 
    inline FString GetDescription() const
    {
        CheckInvariants();
        return GetDescriptionFrom(GetRawName());
    }
    inline bool GetSortByName() const
    {
        CheckInvariants();
        return GetSortByNameFrom(GetRawName());
    }
 
 
    inline void CheckInvariants() const
    {
        checkStats((Number & (EStatMetaFlags::DummyAlwaysOne << (EStatAllFields::StartShift + EStatMetaFlags::Shift)))
            && Index);
    }
 
    template<typename TField>
    typename TField::Type GetField() const
    {
        CheckInvariants();
        int32 LocalNumber = Number;
        LocalNumber = (LocalNumber >> (EStatAllFields::StartShift + TField::Shift)) & TField::Mask;
        checkStats(LocalNumber != TField::Invalid && LocalNumber < TField::Num);
        return typename TField::Type(LocalNumber);
    }
 
    template<typename TField>
    void SetField(typename TField::Type Value)
    {
        int32 LocalNumber = Number;
        CheckInvariants();
        checkStats(Value < TField::Num && Value != TField::Invalid);
        LocalNumber &= ~(TField::Mask << (EStatAllFields::StartShift + TField::Shift));
        LocalNumber |= Value << (EStatAllFields::StartShift + TField::Shift);
        Number = LocalNumber;
        CheckInvariants();
    }
 
    bool GetFlag(EStatMetaFlags::Type Bit) const
    {
        int32 LocalNumber = Number;
        CheckInvariants();
        checkStats(Bit < EStatMetaFlags::Num && Bit != EStatMetaFlags::Invalid);
        return !!((LocalNumber >> (EStatAllFields::StartShift + EStatMetaFlags::Shift)) & Bit);
    }
 
    void SetFlag(EStatMetaFlags::Type Bit, bool Value)
    {
        int32 LocalNumber = Number;
        CheckInvariants();
        checkStats(Bit < EStatMetaFlags::Num && Bit != EStatMetaFlags::Invalid);
        if (Value)
        {
            LocalNumber |= (Bit << (EStatAllFields::StartShift + EStatMetaFlags::Shift));
        }
        else
        {
            LocalNumber &= ~(Bit << (EStatAllFields::StartShift + EStatMetaFlags::Shift));
        }
        Number = LocalNumber;
        CheckInvariants();
    }
 
 
    CORE_API static FName ToLongName(FName InStatName, char const* InGroup, char const* InCategory, TCHAR const* InDescription, bool InSortByName);
    CORE_API static FName GetShortNameFrom(FName InLongName);
    CORE_API static FName GetGroupNameFrom(FName InLongName);
    CORE_API static FName GetGroupCategoryFrom(FName InLongName);
    CORE_API static FString GetDescriptionFrom(FName InLongName);
    CORE_API static bool GetSortByNameFrom(FName InLongName);
 
};
 
 
union UStatData
{
private:
    double  Float;
    int64   Cycles;
    uint64  Ptr;
    uint32  CCAndDuration[2];
    CORE_API const FString GetName() const
    {
        return FName::SafeString(FNameEntryId::FromUnstableInt(static_cast<uint32>(Cycles)));
    }
};
 
struct FStatMessage
{
    enum
    {
        DATA_SIZE = 8,
        DATA_ALIGN = 8,
    };
    union
    {
#if UE_BUILD_DEBUG
        UStatData                               DebugStatData;
#endif // UE_BUILD_DEBUG
        TAlignedBytes<DATA_SIZE, DATA_ALIGN>    StatData;
    };
 
    FStatNameAndInfo                        NameAndInfo;
 
    FStatMessage()
    {
    }
 
    FStatMessage(FName InStatName, EStatDataType::Type InStatType, char const* InGroup, char const* InCategory, TCHAR const* InDescription, bool bShouldClearEveryFrame, bool bCycleStat, bool bSortByName, FPlatformMemory::EMemoryCounterRegion MemoryRegion = FPlatformMemory::MCR_Invalid)
        : NameAndInfo(InStatName, InGroup, InCategory, InDescription, InStatType, bShouldClearEveryFrame, bCycleStat, bSortByName, MemoryRegion)
    {
        NameAndInfo.SetField<EStatOperation>(EStatOperation::SetLongName);
    }
 
    explicit UE_FORCEINLINE_HINT FStatMessage(FStatNameAndInfo InStatName)
        : NameAndInfo(InStatName)
    {
    }
 
    inline FStatMessage(FName InStatName, EStatOperation::Type InStatOperation)
        : NameAndInfo(InStatName, true)
    {
        NameAndInfo.SetField<EStatOperation>(InStatOperation);
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) == true);
 
        // these branches are FORCEINLINE_STATS of constants in almost all cases, so they disappear
        if (InStatOperation == EStatOperation::CycleScopeStart || InStatOperation == EStatOperation::CycleScopeEnd)
        {
            GetValue_int64() = int64(FPlatformTime::Cycles());
        }
        else
        {
            checkStats(0);
        }
    }
 
    inline FStatMessage(FName InStatName, EStatOperation::Type InStatOperation, int64 Value, bool bIsCycle)
        : NameAndInfo(InStatName, true)
    {
        NameAndInfo.SetField<EStatOperation>(InStatOperation);
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) == bIsCycle);
        GetValue_int64() = Value;
    }
 
    inline FStatMessage(FName InStatName, EStatOperation::Type InStatOperation, double Value, bool)
        : NameAndInfo(InStatName, true)
    {
        NameAndInfo.SetField<EStatOperation>(InStatOperation);
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_double);
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) == false);
        GetValue_double() = Value;
    }
 
    inline FStatMessage(FName InStatName, EStatOperation::Type InStatOperation, FName Value, bool)
        : NameAndInfo(InStatName, true)
    {
        NameAndInfo.SetField<EStatOperation>(InStatOperation);
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_FName);
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) == false);
        GetValue_FMinimalName() = NameToMinimalName(Value);
    }
 
    inline FStatMessage(FName InStatName, EStatOperation::Type InStatOperation, uint64 Value, bool)
        : NameAndInfo(InStatName, true)
    {
        NameAndInfo.SetField<EStatOperation>(InStatOperation);
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_Ptr);
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) == false);
        GetValue_Ptr() = Value;
    }
 
    inline void Clear()
    {
        static_assert(sizeof(uint64) == DATA_SIZE, "Bad clear.");
        *(int64*)&StatData = 0;
    }
 
    inline int64& GetValue_int64()
    {
        static_assert(sizeof(int64) <= DATA_SIZE && alignof(int64) <= DATA_ALIGN, "Bad data for stat message.");
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        return *(int64*)&StatData;
    }
    inline int64 GetValue_int64() const
    {
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        return *(int64 const*)&StatData;
    }
 
    inline uint64& GetValue_Ptr()
    {
        static_assert(sizeof(uint64) <= DATA_SIZE && alignof(uint64) <= DATA_ALIGN, "Bad data for stat message.");
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_Ptr);
        return *(uint64*)&StatData;
    }
    inline uint64 GetValue_Ptr() const
    {
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_Ptr);
        return *(uint64 const*)&StatData;
    }
 
    inline int64 GetValue_Duration() const
    {
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) && NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        if (NameAndInfo.GetFlag(EStatMetaFlags::IsPackedCCAndDuration))
        {
            return FromPackedCallCountDuration_Duration(*(int64 const*)&StatData);
        }
        return *(int64 const*)&StatData;
    }
 
    inline uint32 GetValue_CallCount() const
    {
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsPackedCCAndDuration) && NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) && NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        return FromPackedCallCountDuration_CallCount(*(int64 const*)&StatData);
    }
 
    inline double& GetValue_double()
    {
        static_assert(sizeof(double) <= DATA_SIZE && alignof(double) <= DATA_ALIGN, "Bad data for stat message.");
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_double);
        return *(double*)&StatData;
    }
 
    inline double GetValue_double() const
    {
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_double);
        return *(double const*)&StatData;
    }
 
    inline FMinimalName& GetValue_FMinimalName()
    {
        static_assert(sizeof(FMinimalName) <= DATA_SIZE && alignof(FMinimalName) <= DATA_ALIGN, "Bad data for stat message.");
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_FName);
        return *(FMinimalName*)&StatData;
    }
 
    inline FMinimalName GetValue_FMinimalName() const
    {
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_FName);
        return *(FMinimalName const*)&StatData;
    }
 
    inline FName GetValue_FName() const
    {
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_FName);
        return MinimalNameToName(*(FMinimalName const*)&StatData);
    }
};
template<> struct TIsPODType<FStatMessage> { enum { Value = true }; };
 
CORE_API void GetPermanentStats(TArray<FStatMessage>& OutStats);
 
template< typename TEnum >
struct TStatMessage
{
    typedef TEnum TStructEnum;
    static constexpr int32 EnumCount = TEnum::Num;
 
    enum
    {
        DATA_SIZE = 8 * EnumCount,
        DATA_ALIGN = 8,
    };
 
    union
    {
#if UE_BUILD_DEBUG
        UStatData                               DebugStatData[EnumCount];
#endif // UE_BUILD_DEBUG
        TAlignedBytes<DATA_SIZE, DATA_ALIGN>    StatData;
    };
 
    FStatNameAndInfo                            NameAndInfo;
 
    TStatMessage()
    {}
 
    explicit inline TStatMessage(const FStatMessage& Other)
        : NameAndInfo(Other.NameAndInfo)
    {
        // Reset data type and clear all fields.
        NameAndInfo.SetField<EStatDataType>(EStatDataType::ST_None);
        Clear();
    }
 
    TStatMessage& operator=(const FStatMessage& Other)
    {
        NameAndInfo = Other.NameAndInfo;
        // Reset data type and clear all fields.
        NameAndInfo.SetField<EStatDataType>(EStatDataType::ST_None);
        Clear();
        return *this;
    }
 
    void FixStatData(const EStatDataType::Type NewType)
    {
        const EStatDataType::Type OldType = NameAndInfo.GetField<EStatDataType>();
        if (OldType != NewType)
        {
            // Convert from the old type to the new type.
            if (OldType == EStatDataType::ST_int64 && NewType == EStatDataType::ST_double)
            {
                // Get old values.
                int64 OldValues[TEnum::Num];
                for (int32 FieldIndex = 0; FieldIndex < EnumCount; ++FieldIndex)
                {
                    OldValues[FieldIndex] = GetValue_int64((typename TEnum::Type)FieldIndex);
                }
 
                // Set new stat data type
                NameAndInfo.SetField<EStatDataType>(NewType);
                for (int32 FieldIndex = 0; FieldIndex < EnumCount; ++FieldIndex)
                {
                    GetValue_double((typename TEnum::Type)FieldIndex) = (double)OldValues[FieldIndex];
                }
            }
            else if (OldType == EStatDataType::ST_double && NewType == EStatDataType::ST_int64)
            {
                // Get old values.
                double OldValues[TEnum::Num];
                for (int32 FieldIndex = 0; FieldIndex < EnumCount; ++FieldIndex)
                {
                    OldValues[FieldIndex] = GetValue_double((typename TEnum::Type)FieldIndex);
                }
 
                // Set new stat data type
                NameAndInfo.SetField<EStatDataType>(NewType);
                for (int32 FieldIndex = 0; FieldIndex < EnumCount; ++FieldIndex)
                {
                    GetValue_int64((typename TEnum::Type)FieldIndex) = (int64)OldValues[FieldIndex];
                }
            }
        }
    }
 
    inline void Clear()
    {
        static_assert(sizeof(uint64) == DATA_SIZE / EnumCount, "Bad clear.");
 
        for (int32 FieldIndex = 0; FieldIndex < EnumCount; ++FieldIndex)
        {
            *((int64*)&StatData + FieldIndex) = 0;
        }
    }
 
    inline int64& GetValue_int64(typename TEnum::Type Index)
    {
        static_assert(sizeof(int64) <= DATA_SIZE && alignof(int64) <= DATA_ALIGN, "Bad data for stat message.");
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        checkStats(Index < EnumCount);
        int64& Value = *((int64*)&StatData + (uint32)Index);
        return Value;
    }
    inline int64 GetValue_int64(typename TEnum::Type Index) const
    {
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        checkStats(Index < EnumCount);
        const int64 Value = *((int64*)&StatData + (uint32)Index);
        return Value;
    }
 
    inline int64 GetValue_Duration(typename TEnum::Type Index) const
    {
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) && NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        checkStats(Index < EnumCount);
        if (NameAndInfo.GetFlag(EStatMetaFlags::IsPackedCCAndDuration))
        {
            const uint32 Value = FromPackedCallCountDuration_Duration(*((int64 const*)&StatData + (uint32)Index));
            return Value;
        }
        const int64 Value = *((int64 const*)&StatData + (uint32)Index);
        return Value;
    }
 
    inline uint32 GetValue_CallCount(typename TEnum::Type Index) const
    {
        checkStats(NameAndInfo.GetFlag(EStatMetaFlags::IsPackedCCAndDuration) && NameAndInfo.GetFlag(EStatMetaFlags::IsCycle) && NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_int64);
        checkStats(Index < EnumCount);
        const uint32 Value = FromPackedCallCountDuration_CallCount(*((int64 const*)&StatData + (uint32)Index));
        return Value;
    }
 
    inline double& GetValue_double(typename TEnum::Type Index)
    {
        static_assert(sizeof(double) <= DATA_SIZE && alignof(double) <= DATA_ALIGN, "Bad data for stat message.");
        checkStats(Index < EnumCount);
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_double);
        double& Value = *((double*)&StatData + (uint32)Index);
        return Value;
    }
 
    inline double GetValue_double(typename TEnum::Type Index) const
    {
        checkStats(NameAndInfo.GetField<EStatDataType>() == EStatDataType::ST_double);
        checkStats(Index < EnumCount);
        const double Value = *((double const*)&StatData + (uint32)Index);
        return Value;
    }
 
    UE_FORCEINLINE_HINT FName GetShortName() const
    {
        return NameAndInfo.GetShortName();
    }
 
    UE_FORCEINLINE_HINT FString GetDescription() const
    {
        return NameAndInfo.GetDescription();
    }
};
 
struct EComplexStatField
{
    enum Type
    {
        IncSum,
        IncAve,
        IncMax,
        IncMin,
        ExcSum,
        ExcAve,
        ExcMax,
        ExcMin,
 
        Num,
    };
};
 
typedef TStatMessage<EComplexStatField> FComplexStatMessage;
 
template<> struct TIsPODType<FComplexStatMessage> { enum { Value = true }; };
 
 
struct EStatMessagesArrayConstants
{
    enum
    {
#if WITH_EDITOR
        MESSAGES_CHUNK_SIZE = 4 * 1024, // Smaller chunks prevent malloc deadlocks when running in the editor with TBB allocator
#else
        MESSAGES_CHUNK_SIZE = 64 * 1024,
#endif
    };
};
typedef TChunkedArray<FStatMessage, (uint32)EStatMessagesArrayConstants::MESSAGES_CHUNK_SIZE> FStatMessagesArray;
 
struct FStatPacket
{
    int64 Frame = 1;
    uint32 ThreadId = 0;
    EThreadType::Type ThreadType;
    bool bBrokenCallstacks = false;
    FStatMessagesArray StatMessages;
    TArray<int32> StatMessagesPresize;
 
    FStatPacket(EThreadType::Type InThreadType = EThreadType::Invalid)
        : ThreadType(InThreadType)
    {
    }
 
    FStatPacket(FStatPacket const& Other)
        : Frame(Other.Frame)
        , ThreadId(Other.ThreadId)
        , ThreadType(Other.ThreadType)
        , bBrokenCallstacks(false)
        , StatMessagesPresize(Other.StatMessagesPresize)
    {
    }
 
    void SetThreadProperties()
    {
        ThreadId = FPlatformTLS::GetCurrentThreadId();
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
            if (ThreadId == GGameThreadId)
            {
                ThreadType = EThreadType::Game;
            }
            else if (ThreadId == GRenderThreadId)
            {
                ThreadType = EThreadType::Renderer;
            }
            else
            {
                ThreadType = EThreadType::Other;
            }
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    void AssignFrame(int64 InFrame)
    {
        Frame = InFrame;
    }
};
 
struct FStatMessageLock
{
    FStatMessageLock(int32& InMessageScope)
        : MessageScope(InMessageScope)
    {
        MessageScope++;
    }
 
    ~FStatMessageLock()
    {
        MessageScope--;
    }
 
protected:
    int32& MessageScope;
};
 
struct FThreadStatsPool
{
private:
    TLockFreePointerListUnordered<void, 0> Pool;
 
public:
    CORE_API FThreadStatsPool();
 
    CORE_API static FThreadStatsPool& Get();
 
    CORE_API FThreadStats* GetFromPool();
 
    CORE_API void ReturnToPool(FThreadStats* Instance);
};
 
class FThreadStats : FNoncopyable
{
    friend class FStatsMallocProfilerProxy;
    friend class FStatsThreadState;
    friend class FStatsThread;
    friend struct FThreadStatsPool;
 
    CORE_API static FThreadSafeCounter PrimaryEnableCounter;
    CORE_API static FThreadSafeCounter PrimaryEnableUpdateNumber;
    CORE_API static FThreadSafeCounter PrimaryDisableChangeTagLock;
    CORE_API static uint32 TlsSlot;
    CORE_API static bool bPrimaryEnable;
    CORE_API static bool bPrimaryDisableForever;
    CORE_API static bool bIsRawStatsActive;
 
    FStatPacket Packet;
 
    int32 CurrentGameFrame;
 
    int32 ScopeCount = 0;
 
    int32 bWaitForExplicitFlush = 0;
 
    int32 MemoryMessageScope = 0;
 
    bool bReentranceGuard = false;
 
    bool bSawExplicitFlush = false;
 
    void SendMessage_Async(FStatPacket* ToSend);
 
protected:
    CORE_API FThreadStats(EThreadType::Type InThreadType = EThreadType::Invalid);
 
public:
    static inline FThreadStats* GetThreadStats()
    {
        FThreadStats* Stats = (FThreadStats*)FPlatformTLS::GetTlsValue(TlsSlot);
        if (!Stats)
        {
            Stats = FThreadStatsPool::Get().GetFromPool();
        }
        return Stats;
    }
 
    static CORE_API void CheckEnable();
 
    CORE_API bool DetectAndUpdateCurrentGameFrame();
 
    inline void UpdateExplicitFlush()
    {
        if (Packet.ThreadType != EThreadType::Other && bSawExplicitFlush)
        {
            bSawExplicitFlush = false;
            bWaitForExplicitFlush = 1;
            ScopeCount++; // prevent sends until the next explicit flush
        }
    }
 
    CORE_API void Flush(bool bHasBrokenCallstacks = false, bool bForceFlush = false);
 
    CORE_API void FlushRegularStats(bool bHasBrokenCallstacks, bool bForceFlush);
 
    CORE_API void FlushRawStats(bool bHasBrokenCallstacks = false, bool bForceFlush = false);
 
    static CORE_API void CheckForCollectingStartupStats();
 
    UE_AUTORTFM_ALWAYS_OPEN
    inline void AddStatMessage(const FStatMessage& StatMessage)
    {
        LLM_SCOPE(ELLMTag::Stats);
        FStatMessageLock MessageLock(MemoryMessageScope);
        Packet.StatMessages.AddElement(StatMessage);
    }
 
protected:
    template <typename TValue>
    inline void AddMessageInner(FName InStatName, EStatOperation::Type InStatOperation, TValue Value, bool bIsCycle = false)
    {
        AddStatMessage(FStatMessage(InStatName, InStatOperation, Value, bIsCycle));
 
        if constexpr (std::is_same_v<std::decay_t<TValue>, double> || std::is_same_v<std::decay_t<TValue>, int64>)
        {
            switch (InStatOperation)
            {
            case EStatOperation::Set:      TRACE_STAT_SET(InStatName,  Value); break;
            case EStatOperation::Add:      TRACE_STAT_ADD(InStatName,  Value); break;
            case EStatOperation::Subtract: TRACE_STAT_ADD(InStatName, -Value); break;
            }
        }
 
        if (!ScopeCount)
        {
            Flush();
        }
        else if (bIsRawStatsActive)
        {
            FlushRawStats();
        }
    }
 
    UE_AUTORTFM_ALWAYS_OPEN
    inline void AddMessageInner(FName InStatName, EStatOperation::Type InStatOperation)
    {
        checkStats((InStatOperation == EStatOperation::CycleScopeStart || InStatOperation == EStatOperation::CycleScopeEnd));
 
        // these branches are handled by the optimizer
        if (InStatOperation == EStatOperation::CycleScopeStart)
        {
            ScopeCount++;
            AddStatMessage(FStatMessage(InStatName, InStatOperation));
 
            if (bIsRawStatsActive)
            {
                FlushRawStats();
            }
        }
        else if (InStatOperation == EStatOperation::CycleScopeEnd)
        {
            if (ScopeCount > bWaitForExplicitFlush)
            {
                AddStatMessage(FStatMessage(InStatName, InStatOperation));
                ScopeCount--;
                if (!ScopeCount)
                {
                    Flush();
                }
                else if (bIsRawStatsActive)
                {
                    FlushRawStats();
                }
            }
            // else we dumped this frame without closing scope, so we just drop the closes on the floor
        }
    }
 
public:
    static void Shutdown()
    {
        FThreadStats* Stats = IsThreadingReady() ? (FThreadStats*)FPlatformTLS::GetTlsValue(TlsSlot) : nullptr;
        if (Stats)
        {
            // Send all remaining messages.
            Stats->Flush(false, true);
            FPlatformTLS::SetTlsValue(TlsSlot, nullptr);
            FThreadStatsPool::Get().ReturnToPool(Stats);
        }
    }
 
    static inline void AddMessage(FName InStatName, EStatOperation::Type InStatOperation)
    {
        if (!InStatName.IsNone() && WillEverCollectData() && IsThreadingReady())
        {
            GetThreadStats()->AddMessageInner(InStatName, InStatOperation);
        }
    }
 
    template<typename TValue>
    static inline void AddMessage(FName InStatName, EStatOperation::Type InStatOperation, TValue Value, bool bIsCycle = false)
    {
        if (!InStatName.IsNone() && WillEverCollectData() && IsThreadingReady())
        {
            GetThreadStats()->AddMessageInner(InStatName, InStatOperation, Value, bIsCycle);
        }
    }
 
    static CORE_API void ExplicitFlush(bool DiscardCallstack = false);
 
    static UE_FORCEINLINE_HINT bool IsCollectingData()
    {
        return bPrimaryEnable;
    }
    static UE_FORCEINLINE_HINT bool IsCollectingData(TStatId StatId)
    {
        // we don't test StatId for nullptr here because we assume it is non-null. If it is nullptr, that indicates a problem with higher level code.
        return !StatId.IsNone() && IsCollectingData();
    }
 
    static UE_FORCEINLINE_HINT bool WillEverCollectData()
    {
        return !bPrimaryDisableForever;
    }
 
    static UE_FORCEINLINE_HINT bool IsThreadingReady()
    {
        return FPlatformTLS::IsValidTlsSlot(TlsSlot);
    }
 
    static inline void PrimaryEnableAdd(int32 Value = 1)
    {
        PrimaryEnableCounter.Add(Value);
        CheckEnable();
    }
 
    static inline void PrimaryEnableSubtract(int32 Value = 1)
    {
        PrimaryEnableCounter.Subtract(Value);
        CheckEnable();
    }
 
    static inline void PrimaryDisableForever()
    {
        bPrimaryDisableForever = true;
        CheckEnable();
    }
 
    static inline void PrimaryDisableChangeTagLockAdd(int32 Value = 1)
    {
        PrimaryDisableChangeTagLock.Add(Value);
        FPlatformMisc::MemoryBarrier();
        PrimaryEnableUpdateNumber.Increment();
    }
 
    static inline void PrimaryDisableChangeTagLockSubtract(int32 Value = 1)
    {
        FPlatformMisc::MemoryBarrier();
        PrimaryEnableUpdateNumber.Increment();
        FPlatformMisc::MemoryBarrier();
        PrimaryDisableChangeTagLock.Subtract(Value);
    }
 
    static inline int32 PrimaryDisableChangeTag()
    {
        if (PrimaryDisableChangeTagLock.GetValue())
        {
            // while locked we are continually invalid, so we will just keep giving unique numbers
            return PrimaryEnableUpdateNumber.Increment();
        }
        return PrimaryEnableUpdateNumber.GetValue();
    }
 
    static inline void FrameDataIsIncomplete()
    {
        FPlatformMisc::MemoryBarrier();
        PrimaryEnableUpdateNumber.Increment();
        FPlatformMisc::MemoryBarrier();
    }
 
    static inline void EnableRawStats() TSAN_SAFE
    {
        bIsRawStatsActive = true;
        FPlatformMisc::MemoryBarrier();
    }
 
    static inline void DisableRawStats() TSAN_SAFE
    {
        bIsRawStatsActive = false;
        FPlatformMisc::MemoryBarrier();
    }
 
    static CORE_API void StartThread();
    static CORE_API void StopThread();
    static CORE_API void WaitForStats();
};
 
/*
 * Wrapper used by the end-of-pipe tasks to report stats on the appropriate timeline.
 * Acts as a singleton instance of FThreadStats, since the end-of-pipe is a logical part of the frame, not a specific thread.
 */
class FEndOfPipeStats : private FThreadStats
{
    static CORE_API FEndOfPipeStats EndOfPipeStats;
 
    FEndOfPipeStats()
        : FThreadStats(EThreadType::EndOfPipe)
    {}
 
public:
    static FEndOfPipeStats* Get()
    {
        return &EndOfPipeStats;
    }
 
    template<typename TValue>
    void AddMessage(FName InStatName, EStatOperation::Type InStatOperation, TValue Value, bool bIsCycle = false)
    {
        if (!InStatName.IsNone() && WillEverCollectData() && IsThreadingReady())
        {
            FThreadStats::AddMessageInner(InStatName, InStatOperation, Value, bIsCycle);
        }
    }
 
    void Flush()
    {
        FThreadStats::Flush(false, true);
    }
};
 
class FCycleCounter
{
    enum
    {
        NamedEvent = 1 << 0,
        TraceEvent = 1 << 1,
        ThreadStatsEvent = 1 << 2,
    };
 
    FName StatId;
    uint8 EmittedEvent = 0;
 
public:
 
    UE_AUTORTFM_ALWAYS_OPEN
    inline void Start(TStatId InStatId, EStatFlags InStatFlags, bool bAlways = false, UE::FSourceLocation SourceLocation = UE::FSourceLocation::Current())
    {
        FMinimalName StatMinimalName = InStatId.GetMinimalName(EMemoryOrder::Relaxed);
        if (StatMinimalName.IsNone())
        {
            return;
        }
 
        // Emit named event for active cycle stat.
        if (GCycleStatsShouldEmitNamedEvents
            && (GShouldEmitVerboseNamedEvents || !EnumHasAnyFlags(InStatFlags, EStatFlags::Verbose)))
        {
#if PLATFORM_USES_ANSI_STRING_FOR_EXTERNAL_PROFILING
            FPlatformMisc::BeginNamedEvent(FColor(0), InStatId.GetStatDescriptionANSI());
#else
            FPlatformMisc::BeginNamedEvent(FColor(0), InStatId.GetStatDescriptionWIDE());
#endif
            EmittedEvent |= NamedEvent;
 
#if CPUPROFILERTRACE_ENABLED
            if (UE_TRACE_CHANNELEXPR_IS_ENABLED(CpuChannel))
            {
                FName StatName = MinimalNameToName(StatMinimalName);
                FCpuProfilerTrace::OutputBeginDynamicEventWithId(StatName, InStatId.GetStatDescriptionWIDE(), SourceLocation.GetFileName(), SourceLocation.GetLine());
                EmittedEvent |= TraceEvent;
            }
#endif
        }
 
        if ((bAlways && FThreadStats::WillEverCollectData()) || FThreadStats::IsCollectingData())
        {
            FName StatName = MinimalNameToName(StatMinimalName);
            StatId = StatName;
            FThreadStats::AddMessage(StatName, EStatOperation::CycleScopeStart);
            EmittedEvent |= ThreadStatsEvent;
        }
    }
 
    UE_AUTORTFM_ALWAYS_OPEN
    UE_FORCEINLINE_HINT void Start(TStatId InStatId, bool bAlways = false, UE::FSourceLocation SourceLocation = UE::FSourceLocation::Current())
    {
        Start(InStatId, EStatFlags::None, bAlways, SourceLocation);
    }
 
    UE_AUTORTFM_ALWAYS_OPEN
    inline void StartTrace(const FName Name)
    {
#if CPUPROFILERTRACE_ENABLED
        if (UE_TRACE_CHANNELEXPR_IS_ENABLED(CpuChannel))
        {
            FCpuProfilerTrace::OutputBeginDynamicEvent(Name);
            EmittedEvent |= TraceEvent;
        }
#endif
    }
 
    UE_AUTORTFM_ALWAYS_OPEN
    inline void StartTrace(const FName Name, const TCHAR* Desc)
    {
#if CPUPROFILERTRACE_ENABLED
        if (UE_TRACE_CHANNELEXPR_IS_ENABLED(CpuChannel))
        {
            FCpuProfilerTrace::OutputBeginDynamicEventWithId(Name, Desc);
            EmittedEvent |= TraceEvent;
        }
#endif
    }
 
    UE_AUTORTFM_ALWAYS_OPEN
    inline void Stop()
    {
        if (EmittedEvent & NamedEvent)
        {
            FPlatformMisc::EndNamedEvent();
        }
 
#if CPUPROFILERTRACE_ENABLED
        if (EmittedEvent & TraceEvent)
        {
            FCpuProfilerTrace::OutputEndEvent();
        }
#endif
 
        if (EmittedEvent & ThreadStatsEvent)
        {
            FThreadStats::AddMessage(StatId, EStatOperation::CycleScopeEnd);
        }
 
        EmittedEvent = 0;
    }
 
    UE_AUTORTFM_ALWAYS_OPEN
    inline void StopAndResetStatId()
    {
        Stop();
        StatId = NAME_None;
    }
};
 
class FScopeCycleCounter : public FCycleCounter
{
public:
    inline FScopeCycleCounter(TStatId StatId, EStatFlags StatFlags, bool bAlways = false, UE::FSourceLocation SourceLocation = UE::FSourceLocation::Current())
    {
        Start(StatId, StatFlags, bAlways, SourceLocation);
        AutoRTFM::PushOnAbortHandler(this, [this]() { this->Stop(); });
    }
 
    UE_FORCEINLINE_HINT FScopeCycleCounter(TStatId StatId, bool bAlways = false, UE::FSourceLocation SourceLocation = UE::FSourceLocation::Current())
        : FScopeCycleCounter(StatId, EStatFlags::None, bAlways, SourceLocation)
    {
    }
 
    inline ~FScopeCycleCounter()
    {
        AutoRTFM::PopOnAbortHandler(this);
        Stop();
    }
 
};
 
UE_FORCEINLINE_HINT void StatsPrimaryEnableAdd(int32 Value = 1)
{
    FThreadStats::PrimaryEnableAdd(Value);
}
UE_FORCEINLINE_HINT void StatsPrimaryEnableSubtract(int32 Value = 1)
{
    FThreadStats::PrimaryEnableSubtract(Value);
}
 
class FSimpleScopeSecondsStat
{
public:
 
    FSimpleScopeSecondsStat(TStatId InStatId, double InScale = 1.0)
        : StartTime(FPlatformTime::Seconds())
        , StatId(InStatId)
        , Scale(InScale)
    {
 
    }
 
    virtual ~FSimpleScopeSecondsStat()
    {
        double TotalTime = (FPlatformTime::Seconds() - StartTime) * Scale;
        FThreadStats::AddMessage(StatId.GetName(), EStatOperation::Add, TotalTime);
    }
 
private:
 
    double StartTime;
    TStatId StatId;
    double Scale;
};
 
class FStartupMessages
{
    friend class FStatsThread;
 
    TArray64<FStatMessage> DelayedMessages;
    FCriticalSection CriticalSection;
 
public:
    AUTORTFM_DISABLE CORE_API void AddThreadMetadata(const FName InThreadFName, uint32 InThreadID);
 
    AUTORTFM_DISABLE CORE_API void AddMetadata(FName InStatName, const TCHAR* InStatDesc, const char* InGroupName, const char* InGroupCategory, const TCHAR* InGroupDesc, bool bShouldClearEveryFrame, EStatDataType::Type InStatType, bool bCycleStat, bool bSortByName, FPlatformMemory::EMemoryCounterRegion InMemoryRegion = FPlatformMemory::MCR_Invalid);
 
    CORE_API static FStartupMessages& Get();
};
 
class IStatGroupEnableManager
{
public:
    CORE_API static IStatGroupEnableManager& Get();
 
    virtual ~IStatGroupEnableManager()
    {
    }
 
    virtual TStatId GetHighPerformanceEnableForStat(FName StatShortName, const char* InGroup, const char* InCategory, bool bDefaultEnable, bool bShouldClearEveryFrame, EStatDataType::Type InStatType, TCHAR const* InDescription, bool bCycleStat, bool bSortByName, FPlatformMemory::EMemoryCounterRegion MemoryRegion = FPlatformMemory::MCR_Invalid) = 0;
 
    virtual void SetHighPerformanceEnableForGroup(FName Group, bool Enable) = 0;
 
    virtual void SetHighPerformanceEnableForAllGroups(bool Enable) = 0;
 
    virtual void ResetHighPerformanceEnableForAllGroups() = 0;
 
    virtual void StatGroupEnableManagerCommand(FString const& Cmd) = 0;
 
    virtual void UpdateMemoryUsage() = 0;
};
 
 
struct FThreadSafeStaticStatBase
{
protected:
    mutable TAtomic<const TStatIdData*> HighPerformanceEnable { nullptr };
    AUTORTFM_OPEN CORE_API const TStatIdData* DoSetup(FName InStatName, const TCHAR* InStatDesc, const char* InGroupName, const char* InGroupCategory, const TCHAR* InGroupDesc, bool bDefaultEnable, bool bShouldClearEveryFrame, EStatDataType::Type InStatType, bool bCycleStat, bool bSortByName, FPlatformMemory::EMemoryCounterRegion InMemoryRegion) const;
};
 
template<class TStatData, bool TCompiledIn>
struct FThreadSafeStaticStatInner : public FThreadSafeStaticStatBase
{
    inline TStatId GetStatId() const
    {
        const TStatIdData* LocalHighPerformanceEnable = HighPerformanceEnable.Load(EMemoryOrder::Relaxed);
        if (!LocalHighPerformanceEnable)
        {
            LocalHighPerformanceEnable = DoSetup(
                FName(TStatData::GetStatName()),
                TStatData::GetDescription(),
                TStatData::TGroup::GetGroupName(),
                TStatData::TGroup::GetGroupCategory(),
                TStatData::TGroup::GetDescription(),
                TStatData::TGroup::IsDefaultEnabled(),
                TStatData::IsClearEveryFrame(),
                TStatData::GetStatType(),
                TStatData::IsCycleStat(),
                TStatData::TGroup::GetSortByName(),
                TStatData::GetMemoryRegion()
            );
        }
        return TStatId(LocalHighPerformanceEnable);
    }
 
    UE_FORCEINLINE_HINT FName GetStatFName() const
    {
        return GetStatId().GetName();
    }
};
 
struct FDynamicStat : public FThreadSafeStaticStatBase
{
    FDynamicStat(
        FName InStatName,
        const TCHAR* InStatDesc,
        const char* InGroupName,
        const char* InGroupCategory,
        const TCHAR* InGroupDesc,
        bool bDefaultEnable,
        bool bShouldClearEveryFrame,
        EStatDataType::Type InStatType,
        bool bCycleStat,
        bool bSortByName,
        FPlatformMemory::EMemoryCounterRegion InMemoryRegion
    )
    {
        HighPerformanceEnable = DoSetup(
            InStatName,
            InStatDesc,
            InGroupName,
            InGroupCategory,
            InGroupDesc,
            bDefaultEnable,
            bShouldClearEveryFrame,
            InStatType,
            bCycleStat,
            bSortByName,
            InMemoryRegion
        );
    }
 
    UE_FORCEINLINE_HINT TStatId GetStatId() const
    {
        return TStatId(HighPerformanceEnable.Load(EMemoryOrder::Relaxed));
    }
 
    UE_FORCEINLINE_HINT FName GetStatFName() const
    {
        return GetStatId().GetName();
    }
};
 
template<class TStatData>
struct FThreadSafeStaticStatInner<TStatData, false>
{
    UE_FORCEINLINE_HINT TStatId GetStatId()
    {
        return TStatId();
    }
    UE_FORCEINLINE_HINT FName GetStatFName() const
    {
        return FName();
    }
};
 
template<class TStatData>
struct FThreadSafeStaticStat : public FThreadSafeStaticStatInner<TStatData, TStatData::TGroup::CompileTimeEnable>
{
    FThreadSafeStaticStat()
    {
        //This call will result in registering the Group if it's compile time enabled. 
        //It fixes a bug when a StatGroup only has counters that are using the INC_\DEC_ macros. 
        //Those macros are guarded for the stats collection to be active which prevented the registration of the stat group.
        //It was not possible to activate the stat group unless another was already active.
        //Most groups are registered when a FScopeCycleCounter is declared as GetStatId is called as the constructor parameter.
        FThreadSafeStaticStatInner<TStatData, TStatData::TGroup::CompileTimeEnable>::GetStatId(); //-V530
    }
};
 
#else // STATS
 
inline void StatsPrimaryEnableAdd(int32 Value = 1)
{
}
inline void StatsPrimaryEnableSubtract(int32 Value = 1)
{
}
 
#endif // STATS