StatsData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/IndirectArray.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PlatformMemory.h"
#include "HAL/ThreadSafeCounter.h"
#include "Math/NumericLimits.h"
#include "Math/UnrealMathUtility.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Build.h"
#include "Misc/Parse.h"
#include "Stats/Stats.h"
#include "Stats/StatsCommon.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
struct FEventData;
 
#if STATS
 
enum
{
    STAT_FRAME_SLOP = 3,
    MAX_STAT_LAG = 4,
};
 
struct FStatConstants
{
    static CORE_API const FName NAME_ThreadRoot;
 
    static CORE_API const char* ThreadGroupName;
    static CORE_API const FName NAME_ThreadGroup;
 
    static CORE_API const FName RAW_SecondsPerCycle;
 
    static CORE_API const FName NAME_NoCategory;
 
    static CORE_API const FString StatsFileExtension;
 
    static CORE_API const FString StatsFileRawExtension;
 
    static CORE_API const FString ThreadNameMarker;
 
    static CORE_API const FName RAW_EventWaitWithId;
 
    static CORE_API const FName RAW_EventTriggerWithId;
 
    static CORE_API const FName RAW_NamedMarker;
 
    static CORE_API const FStatNameAndInfo AdvanceFrame;
};
 
template <typename T>
void ParseTypedValue( const TCHAR* Stream, const TCHAR* Match, T& Out )
{
    TCHAR Temp[64] = TEXT( "" );
    if( FParse::Value( Stream, Match, Temp, UE_ARRAY_COUNT( Temp ) ) )
    {
        LexFromString( Out, Temp );
    }
}
 
template<typename T>
struct TParsedValueWithDefault
{
public:
    TParsedValueWithDefault( const TCHAR* Stream, const TCHAR* Match, const T& Default )
        : Value( Default )
    {
        if (Stream && Match)
        {
            ParseTypedValue<T>( Stream, Match, Value );
        }
    }
 
    const T& Get() const
    {
        return Value;
    }
 
    void Set( const T& NewValue )
    {
        Value = NewValue;
    }
 
private:
    T Value;
};
 
struct EStatCompareBy
{
    enum Type
    {
        Name,
        CallCount,
        Sum,
    };
};
 
struct EStatDisplayMode
{
    enum Type
    {
        Invalid         = 0x0,
        Hierarchical    = 0x1,
        Flat            = 0x2,
    };
};
 
template< typename T >
struct FStatNameComparer
{
    inline bool operator()( const T& A, const T& B ) const
    {
        check(0);
        return 0;
    }
};
 
template< typename T >
struct FStatDurationComparer
{
    inline bool operator()( const T& A, const T& B ) const
    {
        check(0);
        return 0;
    }
};
 
template< typename T >
struct FStatCallCountComparer
{
    inline bool operator()( const T& A, const T& B ) const
    {
        check(0);
        return 0;
    }
};
 
template<>
struct FStatNameComparer<FStatMessage>
{
    UE_FORCEINLINE_HINT bool operator()( const FStatMessage& A, const FStatMessage& B ) const
    {
        return A.NameAndInfo.GetRawName().Compare( B.NameAndInfo.GetRawName() ) < 0;
    }
};
 
template<>
struct FStatDurationComparer<FStatMessage>
{
    inline bool operator()( const FStatMessage& A, const FStatMessage& B ) const
    {
        const uint32 DurationA = FromPackedCallCountDuration_Duration( A.GetValue_int64() );
        const uint32 DurationB = FromPackedCallCountDuration_Duration( B.GetValue_int64() );
        return DurationA == DurationB ? FStatNameComparer<FStatMessage>()(A,B) : DurationA > DurationB;
    }
};
 
template<>
struct FStatCallCountComparer<FStatMessage>
{
    inline bool operator()( const FStatMessage& A, const FStatMessage& B ) const
    {
        const uint32 CallCountA = FromPackedCallCountDuration_CallCount( A.GetValue_int64() );
        const uint32 CallCountB = FromPackedCallCountDuration_CallCount( B.GetValue_int64() );
        return CallCountA == CallCountB ? FStatNameComparer<FStatMessage>()(A,B) : CallCountA > CallCountB;
    }
};
 
//@todo can we just use TIndirectArray here?
struct FStatPacketArray
{
    TArray<FStatPacket*> Packets;
 
    ~FStatPacketArray()
    {
        Empty();
    }
 
    CORE_API void Empty();
 
    void RemovePtrsButNoData()
    {
        Packets.Empty();
    }
};
 
struct FRawStatStackNode
{
    FStatMessage Meta; // includes aggregated inclusive time and call counts packed into the int64
 
    TMap<FName, FRawStatStackNode*> Children;
 
    FRawStatStackNode()
        : Meta(FStatConstants::NAME_ThreadRoot, EStatDataType::ST_None, nullptr, nullptr, nullptr, false, false, false)
    {
    }
 
    CORE_API explicit FRawStatStackNode(FRawStatStackNode const& Other);
 
    explicit FRawStatStackNode(FStatMessage const& InMeta)
        : Meta(InMeta)
    {
    }
 
    FRawStatStackNode& operator=(const FRawStatStackNode& Other)
    {
        if( this != &Other )
        {
            DeleteAllChildrenNodes();
            Meta = Other.Meta;
 
            Children.Empty(Other.Children.Num());
            for (TMap<FName, FRawStatStackNode*>::TConstIterator It(Other.Children); It; ++It)
            {
                Children.Add(It.Key(), new FRawStatStackNode(*It.Value()));
            }
        }
        return *this;
    }
 
    ~FRawStatStackNode()
    {
        DeleteAllChildrenNodes();
    }
 
    CORE_API void MergeMax(FRawStatStackNode const& Other);
    CORE_API void MergeAdd(FRawStatStackNode const& Other);
    CORE_API void Divide(uint32 Div);
 
    CORE_API void CullByCycles(int64 MinCycles);
 
    CORE_API void CullByDepth(int32 NoCullLevels);
 
    CORE_API void AddNameHierarchy(int32 CurrentPrefixDepth = 0);
 
    CORE_API void AddSelf();
 
    CORE_API void DebugPrint(TCHAR const* Filter = nullptr, int32 MaxDepth = MAX_int32, int32 Depth = 0) const;
 
    CORE_API void DebugPrintLeafFilter(TCHAR const* Filter) const;
 
    CORE_API void DebugPrintLeafFilterInner(TCHAR const* Filter, int32 Depth, TArray<FString>& Stack) const;
 
    CORE_API void Encode(TArray<FStatMessage>& OutStats) const;
 
    CORE_API int64 ChildCycles() const;
 
    template< class TComparer >
    void Sort( const TComparer& Comparer )
    {
        Children.ValueSort( Comparer );
        for( auto It = Children.CreateIterator(); It; ++It )
        {
            FRawStatStackNode* Child = It.Value();
            Child->Sort( Comparer );
        }
    }
 
    CORE_API void* operator new(size_t Size);
    CORE_API void operator delete(void *RawMemory);
 
protected:
    void DeleteAllChildrenNodes()
    {
        for (TMap<FName, FRawStatStackNode*>::TIterator It(Children); It; ++It)
        {
            delete It.Value();
        }
    }
};
 
template<>
struct FStatNameComparer<FRawStatStackNode>
{
    UE_FORCEINLINE_HINT bool operator()( const FRawStatStackNode& A, const FRawStatStackNode& B ) const
    {
        return A.Meta.NameAndInfo.GetRawName().Compare( B.Meta.NameAndInfo.GetRawName() ) < 0;
    }
};
 
template<>
struct FStatDurationComparer<FRawStatStackNode>
{
    inline bool operator()( const FRawStatStackNode& A, const FRawStatStackNode& B ) const
    {
        const uint32 DurationA = FromPackedCallCountDuration_Duration( A.Meta.GetValue_int64() );
        const uint32 DurationB = FromPackedCallCountDuration_Duration( B.Meta.GetValue_int64() );
        return DurationA == DurationB ? FStatNameComparer<FRawStatStackNode>()(A,B) : DurationA > DurationB;
    }
};
 
template<>
struct FStatCallCountComparer<FRawStatStackNode>
{
    inline bool operator()( const FRawStatStackNode& A, const FRawStatStackNode& B ) const
    {
        const uint32 CallCountA = FromPackedCallCountDuration_CallCount( A.Meta.GetValue_int64() );
        const uint32 CallCountB = FromPackedCallCountDuration_CallCount( B.Meta.GetValue_int64() );
        return CallCountA == CallCountB ? FStatNameComparer<FRawStatStackNode>()(A,B) : CallCountA > CallCountB;
    }
};
 
struct FComplexRawStatStackNode
{
    FComplexStatMessage ComplexStat;
 
    TMap<FName, FComplexRawStatStackNode*> Children;
 
    FComplexRawStatStackNode()
    {}
 
    explicit FComplexRawStatStackNode(FComplexRawStatStackNode const& Other);
 
    explicit FComplexRawStatStackNode(FRawStatStackNode const& Other);
 
    void CopyNameHierarchy( const FRawStatStackNode& Other )    
    {
        DeleteAllChildrenNodes();
 
        ComplexStat = Other.Meta;
 
        Children.Empty(Other.Children.Num());
        for (auto It = Other.Children.CreateConstIterator(); It; ++It)
        {
            Children.Add(It.Key(), new FComplexRawStatStackNode(*It.Value()));
        }
    }
 
public:
    ~FComplexRawStatStackNode()
    {
        DeleteAllChildrenNodes();
    }
 
    void MergeAddAndMinMax( const FRawStatStackNode& Other );
 
    void Divide(uint32 Div);
 
    void CullByCycles( int64 MinCycles );
 
    void CullByDepth( int32 NoCullLevels );
 
    void CopyExclusivesFromSelf();
 
    void* operator new(size_t Size);
    void operator delete(void *RawMemory);
 
protected:
    void DeleteAllChildrenNodes()
    {
        for (auto It = Children.CreateIterator(); It; ++It)
        {
            delete It.Value();
        }
    }
};
 
 
struct FEventData
{
    FEventData()
        : Frame( 0 )
        , Duration( 0 )
        , DurationMS( 0.0f )
    {}
 
    bool HasValidStacks() const
    {
        return WaitStackStats.Num() > 0 && TriggerStackStats.Num() > 0;
    }
 
    TArray<FStatNameAndInfo> WaitStackStats;
    TArray<FStatNameAndInfo> TriggerStackStats;
    int64 Frame;
    uint32 Duration;
    float DurationMS;
};
 
//@todo split header
 
struct IItemFilter
{
    virtual ~IItemFilter() { }
 
    virtual bool Keep(FStatMessage const& Item) = 0;
};
 
 
// #Stats: 2014-03-21 Move metadata functionality into a separate class
// 
class FStatsThreadState
{
    friend class FStatsThread;
    friend struct FStatPacketArray;
    friend struct FStatsReadFile;
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam(FOnNewFrameHistory, int64);
 
    DECLARE_TS_MULTICAST_DELEGATE_OneParam(FOnNewRawStatPacket, const FStatPacket*);
 
    CORE_API void ScanForAdvance(const FStatMessagesArray& Data);
 
    CORE_API void ScanForAdvance(FStatPacketArray& NewData);
 
public:
    CORE_API void ProcessMetaDataOnly(TArray64<FStatMessage>& Data);
 
    CORE_API void ToggleFindMemoryExtensiveStats();
 
    void ResetStatsForRawStats()
    {
        MaxNumStatMessages = 0;
        TotalNumStatMessages = 0;
    }
 
private:
    CORE_API void ProcessNonFrameStats( FStatMessagesArray& Data, TSet<FName>* NonFrameStatsFound );
 
    CORE_API void AddToHistoryAndEmpty( FStatPacketArray& NewData );
 
    CORE_API void ProcessRawStats(FStatPacketArray& NewData);
 
    CORE_API void ResetRawStats();
 
    CORE_API void ResetRegularStats();
 
    CORE_API void UpdateStatMessagesMemoryUsage();
 
    CORE_API void FindAndDumpMemoryExtensiveStats( const FStatPacketArray& Frame );
 
protected:
    CORE_API void FindOrAddMetaData(FStatMessage const& Item);
 
    CORE_API void GetRawStackStats(int64 FrameNumber, FRawStatStackNode& Out, TArray<FStatMessage>* OutNonStackStats = nullptr) const;
 
    CORE_API void Condense(int64 TargetFrame, TArray<FStatMessage>& OutStats) const;
 
    CORE_API int64 GetFastThreadFrameTimeInternal(int64 TargetFrame, int32 ThreadID, EThreadType::Type Thread) const;
 
    int32 HistoryFrames;
 
    int64 LastFullFrameMetaAndNonFrame;
 
    int64 LastFullFrameProcessed;
 
    mutable TMap<int64, TArray<FStatMessage>* > CondensedStackHistory;
 
    TSet<int64> GoodFrames;
 
    TSet<int64> BadFrames;
 
    FStatPacketArray StartupRawStats;
 
    int64 TotalNumStatMessages;
 
    FThreadSafeCounter NumStatMessages;
 
    int32 MaxNumStatMessages;
 
    bool bFindMemoryExtensiveStats;
 
public:
 
    CORE_API FStatsThreadState(int32 InHistoryFrames = STAT_FRAME_SLOP + 10);
 
    mutable FOnNewFrameHistory NewFrameDelegate;
 
    mutable FOnNewRawStatPacket NewRawStatPacket;
 
    int64 CurrentGameFrame;
 
    int64 CurrentRenderFrame;
 
    int64 CurrentEndOfPipeFrame;
 
    TMap<FName, FStatMessage> NotClearedEveryFrame;
 
    TMap<FName, FStatMessage> ShortNameToLongName;
 
    mutable TMap<uint32, FEventData> EventsHistory;
 
    TMap<FPlatformMemory::EMemoryCounterRegion, FName> MemoryPoolToCapacityLongName;
 
    TMultiMap<FName, FName> Groups;
 
    TMap<uint32, FName> Threads;
 
    TMap<int64, FStatPacketArray> History;
 
    CORE_API int64 GetOldestValidFrame() const;
 
    CORE_API int64 GetLatestValidFrame() const;
 
    bool IsFrameValid(int64 Frame) const
    {
        return GoodFrames.Contains(Frame);
    }
 
    CORE_API int64 GetFastThreadFrameTime(int64 TargetFrame, EThreadType::Type Thread) const;
    CORE_API int64 GetFastThreadFrameTime(int64 TargetFrame, uint32 ThreadID) const;
 
    CORE_API FName GetStatThreadName( const FStatPacket& Packet ) const;
 
    CORE_API TArray<FStatMessage> const& GetCondensedHistory(int64 TargetFrame) const;
 
    const FStatPacketArray& GetStatPacketArray( int64 TargetFrame ) const
    {
        check( IsFrameValid( TargetFrame ) );
        const FStatPacketArray& Frame = History.FindChecked( TargetFrame );
        return Frame;
    }
 
    CORE_API void GetInclusiveAggregateStackStats( const TArray<FStatMessage>& CondensedMessages, TArray<FStatMessage>& OutStats, IItemFilter* Filter = nullptr, bool bAddNonStackStats = true, TMap<FName, TArray<FStatMessage>>* OptionalOutThreadBreakdownMap = nullptr ) const;
 
    CORE_API void GetInclusiveAggregateStackStats(int64 TargetFrame, TArray<FStatMessage>& OutStats, IItemFilter* Filter = nullptr, bool bAddNonStackStats = true, TMap<FName, TArray<FStatMessage>>* OptionalOutThreadBreakdownMap = nullptr) const;
 
    CORE_API void GetExclusiveAggregateStackStats( const TArray<FStatMessage>& CondensedMessages, TArray<FStatMessage>& OutStats, IItemFilter* Filter = nullptr, bool bAddNonStackStats = true ) const;
 
    CORE_API void GetExclusiveAggregateStackStats(int64 TargetFrame, TArray<FStatMessage>& OutStats, IItemFilter* Filter = nullptr, bool bAddNonStackStats = true) const;
 
    CORE_API void UncondenseStackStats( const TArray<FStatMessage>& CondensedMessages, FRawStatStackNode& Root, IItemFilter* Filter = nullptr, TArray<FStatMessage>* OutNonStackStats = nullptr ) const;
 
    CORE_API void UncondenseStackStats(int64 TargetFrame, FRawStatStackNode& Root, IItemFilter* Filter = nullptr, TArray<FStatMessage>* OutNonStackStats = nullptr) const;
 
    CORE_API void AddMissingStats(TArray<FStatMessage>& Dest, TSet<FName> const& EnabledItems) const;
 
    static CORE_API FStatsThreadState& GetLocalState();
};
 
//@todo split header
 
struct FStatsUtils
{
    static CORE_API void DivideStat(FStatMessage& Dest, uint32 Div);
 
    static CORE_API void AddMergeStatArray(TArray<FStatMessage>& Dest, TArray<FStatMessage> const& Item);
 
    static CORE_API void MaxMergeStatArray(TArray<FStatMessage>& Dest, TArray<FStatMessage> const& Item);
 
    static CORE_API void DivideStatArray(TArray<FStatMessage>& Dest, uint32 Div);
 
    static CORE_API void AccumulateStat(FStatMessage& Dest, FStatMessage const& Item, EStatOperation::Type Op = EStatOperation::Invalid, bool bAllowNameMismatch = false);
 
    static void AddNonStackStats( const FName LongName, const FStatMessage& Item, const EStatOperation::Type Op, TMap<FName, FStatMessage>& out_NonStackStats )
    {
        if (
            Item.NameAndInfo.GetField<EStatDataType>() != EStatDataType::ST_None && 
            Item.NameAndInfo.GetField<EStatDataType>() != EStatDataType::ST_FName &&
            (Op == EStatOperation::Set ||
            Op == EStatOperation::Clear ||
            Op == EStatOperation::Add ||
            Op == EStatOperation::Subtract ||
            Op == EStatOperation::MaxVal))
        {
            FStatMessage* Result = out_NonStackStats.Find(LongName);
            if (!Result)
            {
                Result = &out_NonStackStats.Add(LongName, Item);
                Result->NameAndInfo.SetField<EStatOperation>(EStatOperation::Set);
                Result->Clear();
            }
            FStatsUtils::AccumulateStat(*Result, Item);
        }
    }
 
    static CORE_API FString DebugPrint(FStatMessage const& Item);
 
    static CORE_API void GetNameAndGroup(FStatMessage const& Item, FString& OutName, FString& OutGroup);
 
    static FStatMessage ComputeCall(FStatMessage const& ScopeStart, FStatMessage const& ScopeEnd)
    {
        checkStats(ScopeStart.NameAndInfo.GetField<EStatOperation>() == EStatOperation::CycleScopeStart);
        checkStats(ScopeEnd.NameAndInfo.GetField<EStatOperation>() == EStatOperation::CycleScopeEnd);
        FStatMessage Result(ScopeStart);
        Result.NameAndInfo.SetField<EStatOperation>(EStatOperation::Set);
        Result.NameAndInfo.SetFlag(EStatMetaFlags::IsPackedCCAndDuration, true);
        checkStats(ScopeEnd.NameAndInfo.GetFlag(EStatMetaFlags::IsCycle));
 
        // cycles can wrap and are actually uint32's so we do something special here
        int64 Delta = int32(uint32(ScopeEnd.GetValue_int64()) - uint32(ScopeStart.GetValue_int64()));
        checkStats(Delta >= 0);
        Result.GetValue_int64() = ToPackedCallCountDuration(1, uint32(Delta));
        return Result;
    }
 
    static void StatOpMaxVal_Int64( const FStatNameAndInfo& DestNameAndInfo, int64& Dest, const int64& Other )
    {
        if (DestNameAndInfo.GetFlag(EStatMetaFlags::IsPackedCCAndDuration))
        {
            Dest = ToPackedCallCountDuration(
                FMath::Max<uint32>(FromPackedCallCountDuration_CallCount(Dest), FromPackedCallCountDuration_CallCount(Other)),
                FMath::Max<uint32>(FromPackedCallCountDuration_Duration(Dest), FromPackedCallCountDuration_Duration(Other)));
        }
        else
        {
            Dest = FMath::Max<int64>(Dest,Other);
        }
    }
    static void StatOpMinVal_Int64(const FStatNameAndInfo& DestNameAndInfo, int64& Dest, const int64& Other)
    {
        if (DestNameAndInfo.GetFlag(EStatMetaFlags::IsPackedCCAndDuration))
        {
            Dest = ToPackedCallCountDuration(
                FMath::Min<uint32>(FromPackedCallCountDuration_CallCount(Dest), FromPackedCallCountDuration_CallCount(Other)),
                FMath::Min<uint32>(FromPackedCallCountDuration_Duration(Dest), FromPackedCallCountDuration_Duration(Other)));
        }
        else
        {
            Dest = FMath::Min<int64>(Dest, Other);
        }
    }
 
    static CORE_API void ToEscapedString(FStringView Input, FStringBuilderBase& Output);
    static CORE_API FString FromEscapedString(const TCHAR* Escaped);
    
    static FString BuildUniqueThreadName( uint32 InThreadID )
    {
        // Make unique name.
        return FString::Printf( TEXT( "%s%x_0" ), *FStatConstants::ThreadNameMarker, InThreadID );
    }
 
    static int32 ParseThreadID( const FString& InThreadName, FString* out_ThreadName = nullptr )
    {
        // Extract the thread id.
        const FString ThreadName = InThreadName.Replace( TEXT( "_0" ), TEXT( "" ) );
        int32 Index = 0;
        ThreadName.FindLastChar(TEXT('_'),Index);
 
        // Parse the thread name if requested.
        if( out_ThreadName )
        {
            *out_ThreadName = ThreadName.Left( Index );
        }
 
        const FString ThreadIDStr = ThreadName.RightChop(Index+1);
        const uint32 ThreadID = FParse::HexNumber( *ThreadIDStr );
 
        return ThreadID;
    }
};
 
struct FComplexStatUtils
{
    static CORE_API void AddAndMinMax( FComplexStatMessage& Dest, const FStatMessage& Item, EComplexStatField::Type SumIndex, EComplexStatField::Type MaxIndex, EComplexStatField::Type MinIndex);
 
    static CORE_API void DivideStat( FComplexStatMessage& Dest, uint32 Div, EComplexStatField::Type SumIndex, EComplexStatField::Type DestIndex );
 
    static CORE_API void MergeAddAndMinMaxArray( TArray<FComplexStatMessage>& Dest, const TArray<FStatMessage>& Source, EComplexStatField::Type SumIndex, EComplexStatField::Type MaxIndex, EComplexStatField::Type MinIndex);
 
    static CORE_API void DiviveStatArray( TArray<FComplexStatMessage>& Dest, uint32 Div, EComplexStatField::Type SumIndex, EComplexStatField::Type DestIndex );
};
 
//@todo split header
 
struct FActiveStatGroupInfo
{
    TArray<FComplexStatMessage> FlatAggregate;
 
    TMap<FName, TArray<FComplexStatMessage>> FlatAggregateThreadBreakdown;
    
    TArray<FComplexStatMessage> HierAggregate;
 
    TArray<int32> Indentation;
 
    TArray<FComplexStatMessage> MemoryAggregate;
 
    TArray<FComplexStatMessage> CountersAggregate;
 
    TArray<FComplexStatMessage> GpuStatsAggregate;
 
    TSet<FName> BudgetIgnoreStats;
 
    TMap<FName, float> ThreadBudgetMap;
};
 
struct FGameThreadStatsData
{
    FGameThreadStatsData( bool bInDrawOnlyRawStats, bool bInRenderStats )
        : bDrawOnlyRawStats(bInDrawOnlyRawStats)
        , bRenderStats(bInRenderStats)
    {}
 
    const FComplexStatMessage* GetStatData(const FName& StatName ) const
    {
        return NameToStatMap.FindRef(StatName);
    }
 
    TIndirectArray<FActiveStatGroupInfo> ActiveStatGroups;
    TArray<FName> GroupNames;
    TArray<FString> GroupDescriptions;
    TMap<FPlatformMemory::EMemoryCounterRegion, int64> PoolCapacity;
    TMap<FPlatformMemory::EMemoryCounterRegion, FString> PoolAbbreviation;
    FString RootFilter;
 
    TMap<FName, const FComplexStatMessage*> NameToStatMap;
 
    const bool bDrawOnlyRawStats;
 
    const bool bRenderStats;
};
 
struct FLatestGameThreadStatsData 
{
    FGameThreadStatsData* Latest;
 
    FLatestGameThreadStatsData()
        : Latest(nullptr)
    {
    }
 
    ~FLatestGameThreadStatsData()
    {
        delete Latest;
        Latest = nullptr;
    }
 
    void NewData(FGameThreadStatsData* Data);
 
    CORE_API static FLatestGameThreadStatsData& Get();
};
 
struct FStatGroupGameThreadNotifier
{
public:
    CORE_API static FStatGroupGameThreadNotifier& Get();
 
    void NewData(FStatNameAndInfo NameAndInfo)
    {
        NameAndInfos.Add(NameAndInfo);
        const FName GroupName = NameAndInfo.GetGroupName();
        if (!GroupName.IsNone() && GroupName != NAME_Groups)
        {
            StatGroupNames.Add(GroupName);
        }
    }
 
    void SendData()
    {
        if (NameAndInfos.Num() > 0)
        {
            // Should only do this if the delegate has been registered!
            check(NewStatGroupDelegate.IsBound());
            NewStatGroupDelegate.Execute(NameAndInfos);
            ClearData();
        }
    }
 
    void ClearData()
    {
        NameAndInfos.Empty();
    }
 
    DECLARE_DELEGATE_OneParam(FOnNewStatGroupRegistered, const TArray<FStatNameAndInfo>&);
    FOnNewStatGroupRegistered NewStatGroupDelegate;
 
    TSet<FName> StatGroupNames;
 
private:
    FStatGroupGameThreadNotifier(){}
    ~FStatGroupGameThreadNotifier(){}
 
    TArray<FStatNameAndInfo> NameAndInfos;
};
 
#endif