StatsFile.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/AsyncWork.h"
#include "Containers/Array.h"
#include "Containers/ChunkedArray.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/SparseArray.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "Delegates/IDelegateInstance.h"
#include "HAL/PlatformCrt.h"
#include "HAL/ThreadSafeBool.h"
#include "HAL/ThreadSafeCounter.h"
#include "Internationalization/Text.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Build.h"
#include "Misc/Compression.h"
#include "Serialization/Archive.h"
#include "Stats/Stats.h"
#include "Stats/StatsCommon.h"
#include "Stats/StatsData.h"
#include "Trace/Detail/Channel.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
class FAsyncStatsWrite;
struct FStatsReadFile;
 
#if STATS
 
class FAsyncStatsWrite;
struct FStatsReadFile;
 
enum EStatMagicNoHeader : uint32
{
    MAGIC_NO_HEADER = 0x7E1B83C1,
    MAGIC_NO_HEADER_SWAPPED = 0xC1831B7E,
    NO_VERSION = 0,
};
 
enum EStatMagicWithHeader : uint32
{
    MAGIC = 0x10293847,
    MAGIC_SWAPPED = 0x47382910,
    VERSION_2 = 2,
    VERSION_3 = 3,
 
    VERSION_4 = 4,
    HAS_COMPRESSED_DATA_VER = VERSION_4,
 
    VERSION_5 = 5,
 
    VERSION_6 = 6,
 
    VERSION_LATEST = VERSION_6,
};
 
struct EStatsFileConstants
{
    enum
    {
        MAX_COMPRESSED_SIZE = 1024 * 1024,
 
        DUMMY_HEADER_SIZE = 1024,
 
        END_OF_COMPRESSED_DATA = 0xE0F0DA4A,
 
        NO_COMPRESSION = 0,
    };
};
 
/*-----------------------------------------------------------------------------
    FCompressedStatsData
-----------------------------------------------------------------------------*/
 
struct FCompressedStatsData
{
    FCompressedStatsData( TArray<uint8>& InSrcData, TArray<uint8>& InDestData )
        : SrcData( InSrcData )
        , DestData( InDestData )
        , bEndOfCompressedData( false )
    {}
 
    static void WriteEndOfCompressedData( FArchive& Writer )
    {
        int32 Marker = EStatsFileConstants::END_OF_COMPRESSED_DATA;
        check( Writer.IsSaving() );
        Writer << Marker << Marker;
    }
 
protected:
    friend FArchive& operator << (FArchive& Ar, FCompressedStatsData& Data)
    {
        if( Ar.IsSaving() )
        {
            Data.WriteCompressed( Ar );
        }
        else if( Ar.IsLoading() )
        {
            Data.ReadCompressed( Ar );
        }
        else
        {
            check( 0 );
        }
        return Ar;
    }
 
    void WriteCompressed( FArchive& Writer )
    {
        int32 UncompressedSize = SrcData.Num();
        if( UncompressedSize > EStatsFileConstants::MAX_COMPRESSED_SIZE - EStatsFileConstants::DUMMY_HEADER_SIZE )
        {
            int32 DisabledCompressionSize = EStatsFileConstants::NO_COMPRESSION;
            Writer << DisabledCompressionSize << UncompressedSize;
            Writer.Serialize( SrcData.GetData(), UncompressedSize );
        }
        else
        {
            DestData.Reserve( EStatsFileConstants::MAX_COMPRESSED_SIZE );
            int32 CompressedSize = (int32)DestData.GetAllocatedSize();
 
            const bool bResult = FCompression::CompressMemory( NAME_Zlib, DestData.GetData(), CompressedSize, SrcData.GetData(), UncompressedSize );
            check( bResult );
            Writer << CompressedSize << UncompressedSize;
            Writer.Serialize( DestData.GetData(), CompressedSize );
        }
    }
 
    void ReadCompressed( FArchive& Reader )
    {
        int32 CompressedSize = 0;
        int32 UncompressedSize = 0;
        Reader << CompressedSize << UncompressedSize;
 
        if( CompressedSize == EStatsFileConstants::END_OF_COMPRESSED_DATA && UncompressedSize == EStatsFileConstants::END_OF_COMPRESSED_DATA )
        {
            bEndOfCompressedData = true;
        }
        // This chunk is not compressed.
        else if( CompressedSize == 0 )
        {
            DestData.Reset( UncompressedSize );
            DestData.AddUninitialized( UncompressedSize );
            Reader.Serialize( DestData.GetData(), UncompressedSize );
        }
        else
        {
            SrcData.Reset( CompressedSize );
            DestData.Reset( UncompressedSize );
            SrcData.AddUninitialized( CompressedSize );
            DestData.AddUninitialized( UncompressedSize );
 
            Reader.Serialize( SrcData.GetData(), CompressedSize );
            const bool bResult = FCompression::UncompressMemory(NAME_Zlib, DestData.GetData(), UncompressedSize, SrcData.GetData(), CompressedSize );
            check( bResult );
        }
    }
 
public:
    const bool HasReachedEndOfCompressedData() const
    {
        return bEndOfCompressedData;
    }
    
protected:
    TArray<uint8>& SrcData;
 
    TArray<uint8>& DestData;
 
    bool bEndOfCompressedData;
};
 
/*-----------------------------------------------------------------------------
    Stats file writing functionality
-----------------------------------------------------------------------------*/
 
struct FStatsStreamHeader
{
    FStatsStreamHeader()
        : Version( 0 )
        , FrameTableOffset( 0 )
        , FNameTableOffset( 0 )
        , NumFNames( 0 )
        , MetadataMessagesOffset( 0 )
        , NumMetadataMessages( 0 )
        , bRawStatsFile( false )
    {}
 
    uint32  Version;
 
    FString PlatformName;
 
    uint64  FrameTableOffset;
 
    uint64  FNameTableOffset;
 
    uint64  NumFNames;
 
    uint64  MetadataMessagesOffset;
 
    uint64  NumMetadataMessages;
 
    bool bRawStatsFile;
 
    bool IsFinalized() const
    {
        return NumMetadataMessages > 0 && MetadataMessagesOffset > 0 && FrameTableOffset > 0;
    }
 
    bool HasCompressedData() const
    {
        return Version >= EStatMagicWithHeader::HAS_COMPRESSED_DATA_VER;
    }
 
    friend FArchive& operator << (FArchive& Ar, FStatsStreamHeader& Header)
    {
        Ar << Header.Version;
 
        if( Ar.IsSaving() )
        {
            Header.PlatformName.SerializeAsANSICharArray( Ar, 255 );
        }
        else if( Ar.IsLoading() )
        {
            Ar << Header.PlatformName;
        }
 
        Ar << Header.FrameTableOffset;
 
        Ar << Header.FNameTableOffset
            << Header.NumFNames;
 
        Ar << Header.MetadataMessagesOffset
            << Header.NumMetadataMessages;
 
        Ar << Header.bRawStatsFile;
 
        return Ar;
    }
};
 
/*-----------------------------------------------------------------------------
    FStatsFrameInfo
-----------------------------------------------------------------------------*/
 
struct FStatsFrameInfo
{
    FStatsFrameInfo()
        : FrameFileOffset(0)
    {}
 
    FStatsFrameInfo( int64 InFrameFileOffset )
        : FrameFileOffset(InFrameFileOffset)
    {}
 
    FStatsFrameInfo( int64 InFrameFileOffset, TMap<uint32, int64>& InThreadCycles )
        : FrameFileOffset(InFrameFileOffset)
        , ThreadCycles(InThreadCycles)
    {}
 
    friend FArchive& operator << (FArchive& Ar, FStatsFrameInfo& Data)
    {
        Ar << Data.ThreadCycles << Data.FrameFileOffset;
        return Ar;
    }
 
    int64 FrameFileOffset;
 
    TMap<uint32, int64> ThreadCycles;
};
 
/*-----------------------------------------------------------------------------
    FStatsWriteStream
-----------------------------------------------------------------------------*/
 
struct FStatsWriteStream
{
protected:
    CORE_API void WriteMetadata( FArchive& Ar );
 
    CORE_API void WriteCondensedMessages( FArchive& Ar, int64 TargetFrame );
 
    inline void WriteFName( FArchive& Ar, FStatNameAndInfo NameAndInfo )
    {
        FName RawName = NameAndInfo.GetRawName();
        bool bSendFName = !FNamesSent.Contains( RawName.GetComparisonIndex() );
 
        int32 ComparisonInt = RawName.GetComparisonIndex().ToUnstableInt();
        Ar << ComparisonInt;
 
        int32 Number = NameAndInfo.GetRawNumber();
        if (bSendFName)
        {
            FNamesSent.Add( RawName.GetComparisonIndex() );
            Number |= EStatMetaFlags::SendingFName << (EStatMetaFlags::Shift + EStatAllFields::StartShift);
        }
        Ar << Number;
        if (bSendFName)
        {
            FString Name = RawName.ToString();
            Ar << Name;
        }
    }
 
    inline void WriteMessage( FArchive& Ar, FStatMessage const& Item )
    {
        WriteFName( Ar, Item.NameAndInfo );
        switch (Item.NameAndInfo.GetField<EStatDataType>())
        {
            case EStatDataType::ST_int64:
            {
                int64 Payload = Item.GetValue_int64();
                Ar << Payload;
                break;
            }
 
            case EStatDataType::ST_double:
            {
                double Payload = Item.GetValue_double();
                Ar << Payload;
                break;
            }
 
            case EStatDataType::ST_FName:
            {
                WriteFName( Ar, FStatNameAndInfo( Item.GetValue_FName(), false ) );
                break;
            }
 
            case EStatDataType::ST_Ptr:
            {
                uint64 Payload = Item.GetValue_Ptr();
                Ar << Payload;
                break;
            }
        }
    }
 
    TSet<FNameEntryId> FNamesSent;
 
    TArray<uint8> OutData;
};
 
/*-----------------------------------------------------------------------------
    IStatsWriteFile
-----------------------------------------------------------------------------*/
 
struct IStatsWriteFile : public FStatsWriteStream
{
    friend class FAsyncStatsWrite;
 
protected:
    FArchive* File;
 
    FString ArchiveFilename;
 
    FStatsStreamHeader Header;
 
    FAsyncTask<FAsyncStatsWrite>* AsyncTask;
 
    TArray<uint8> CompressedData;
 
    TArray<FStatsFrameInfo> FramesInfo;
 
    FDelegateHandle DataDelegateHandle;
 
    int64 FileSize;
 
    double StartTime;
 
protected:
    CORE_API IStatsWriteFile();
 
public:
    virtual ~IStatsWriteFile()
    {}
 
    CORE_API void Start( const FString& InFilename );
 
    CORE_API void Stop();
 
    CORE_API FText GetFileMetaDesc() const;
 
protected:
    virtual void SetDataDelegate( bool bSet ) = 0;
 
    virtual void FinalizeSavingData( int64 FrameFileOffset )
    {};
 
    bool IsValid() const
    {
        return !!File;
    }
 
    CORE_API void WriteHeader();
 
protected:
    CORE_API void Finalize();
 
    CORE_API void WaitTask();
 
    CORE_API void SendTask();
};
 
struct FStatsWriteFile : public IStatsWriteFile
{
    friend class FAsyncStatsWrite;
 
protected:
    TMap<uint32, int64> ThreadCycles;
 
public:
    FStatsWriteFile()
    {
        Header.bRawStatsFile = false;
    }
 
protected:
    CORE_API virtual void SetDataDelegate( bool bSet ) override;
 
    CORE_API virtual void FinalizeSavingData( int64 FrameFileOffset ) override;
 
    CORE_API void WriteFrame( int64 TargetFrame );
};
 
struct FRawStatsWriteFile : public IStatsWriteFile
{
    bool bWrittenOffsetToData;
 
public:
    FRawStatsWriteFile()
        : bWrittenOffsetToData(false)
    {
        Header.bRawStatsFile = true;
    }
 
protected:
    CORE_API virtual void SetDataDelegate( bool bSet ) override;
 
    CORE_API void WriteRawStatPacket( const FStatPacket* StatPacket );
 
    CORE_API void WriteStatPacket( FArchive& Ar, FStatPacket& StatPacket );
};
 
/*-----------------------------------------------------------------------------
    Stats file reading functionality
-----------------------------------------------------------------------------*/
 
class FStatsLoadedState : public FStatsThreadState
{
    friend struct FStatsReadFile;
 
public:
    FStatsLoadedState()
        : MaxFrameSeen( 0 )
        , MinFrameSeen( -1 )
    {}
 
    CORE_API void ProcessMetaDataAndLeaveDataOnly( TArray<FStatMessage>& CondensedMessages );
 
    CORE_API void AddFrameFromCondensedMessages( TArray<FStatMessage>& CondensedMessages );
 
    CORE_API int64 GetOldestValidFrame() const;
 
    CORE_API int64 GetLatestValidFrame() const;
 
protected:
    CORE_API void AdvanceFrameForLoad( TArray<FStatMessage>& CondensedMessages );
 
    int64 MaxFrameSeen;
 
    int64 MinFrameSeen;
};
 
struct FStatsReadStream
{
public:
    FStatsStreamHeader Header;
 
    TMap<int32, FNameEntryId> FNamesIndexMap;
 
    TArray<FStatsFrameInfo> FramesInfo;
 
    bool ReadHeader( FArchive& Ar )
    {
        bool bStatWithHeader = false;
 
        uint32 Magic = 0;
        Ar << Magic;
        if( Magic == EStatMagicNoHeader::MAGIC_NO_HEADER )
        {
 
        }
        else if( Magic == EStatMagicNoHeader::MAGIC_NO_HEADER_SWAPPED )
        {
            Ar.SetByteSwapping( true );
        }
        else if( Magic == EStatMagicWithHeader::MAGIC )
        {
            bStatWithHeader = true;
        }
        else if( Magic == EStatMagicWithHeader::MAGIC_SWAPPED )
        {
            bStatWithHeader = true;
            Ar.SetByteSwapping( true );
        }
        else
        {
            return false;
        }
 
        // We detected a header for a stats file, read it.
        if( bStatWithHeader )
        {
            Ar << Header;
        }
 
        return true;
    }
 
    void ReadStatPacket( FArchive& Ar, FStatPacket& StatPacked )
    {
        Ar << StatPacked.Frame;
        Ar << StatPacked.ThreadId;
        int32 MyThreadType = 0;
        Ar << MyThreadType;
        StatPacked.ThreadType = (EThreadType::Type)MyThreadType;
 
        Ar << StatPacked.bBrokenCallstacks;
        // We must handle stat messages in a different way.
        int32 NumMessages = 0;
        Ar << NumMessages;
        StatPacked.StatMessages.Reserve( NumMessages );
        for( int32 MessageIndex = 0; MessageIndex < NumMessages; ++MessageIndex )
        {
            new(StatPacked.StatMessages) FStatMessage( ReadMessage( Ar, true ) );
        }
    }
 
    inline FStatNameAndInfo ReadFName( FArchive& Ar, bool bHasFNameMap )
    {
        // If we read the whole FNames translation map, we don't want to add the FName again.
        // This is a bit tricky, even if we have the FName translation map, we still need to read the FString.
        // CAUTION!! This is considered to be thread safe in this case.
        int32 Index = 0;
        Ar << Index;
        int32 Number = 0;
        Ar << Number;
        FName TheFName;
        
        if( !bHasFNameMap )
        {
            if( Number & (EStatMetaFlags::SendingFName << (EStatMetaFlags::Shift + EStatAllFields::StartShift)) )
            {
                FString Name;
                Ar << Name;
 
                TheFName = FName( *Name );
                FNamesIndexMap.Add( Index, TheFName.GetComparisonIndex() );
                Number &= ~(EStatMetaFlags::SendingFName << (EStatMetaFlags::Shift + EStatAllFields::StartShift));
            }
            else
            {
                if( FNamesIndexMap.Contains( Index ) )
                {
                    const FNameEntryId MyIndex = FNamesIndexMap.FindChecked( Index );
                    TheFName = FName( MyIndex, MyIndex, 0 );
                }
                else
                {
                    TheFName = FName( TEXT( "Unknown FName" ) );
                    Number = 0;
                    UE_LOG( LogTemp, Warning, TEXT( "Missing FName Indexed: %d, %d" ), Index, Number );
                }
            }
        }
        else
        {
            if( Number & (EStatMetaFlags::SendingFName << (EStatMetaFlags::Shift + EStatAllFields::StartShift)) )
            {
                FString Name;
                Ar << Name;
                Number &= ~(EStatMetaFlags::SendingFName << (EStatMetaFlags::Shift + EStatAllFields::StartShift));
            }
            if( FNamesIndexMap.Contains( Index ) )
            {
                const FNameEntryId MyIndex = FNamesIndexMap.FindChecked( Index );
                TheFName = FName( MyIndex, MyIndex, 0 );
            }
            else
            {
                TheFName = FName( TEXT( "Unknown FName" ) );
                Number = 0;
                UE_LOG( LogTemp, Warning, TEXT( "Missing FName Indexed: %d, %d" ), Index, Number );
            }
        }
 
        FStatNameAndInfo Result( TheFName, false );
        Result.SetNumberDirect( Number );
        return Result;
    }
 
    inline FStatMessage ReadMessage( FArchive& Ar, bool bHasFNameMap = false )
    {
        FStatMessage Result( ReadFName( Ar, bHasFNameMap ) );
        Result.Clear();
        switch( Result.NameAndInfo.GetField<EStatDataType>() )
        {
            case EStatDataType::ST_int64:
            {
                int64 Payload = 0;
                Ar << Payload;
                Result.GetValue_int64() = Payload;
                break;
            }
                
            case EStatDataType::ST_double:
            {
                double Payload = 0;
                Ar << Payload;
                Result.GetValue_double() = Payload;
                break;
            }
                
            case EStatDataType::ST_FName:
            {
                FStatNameAndInfo Payload( ReadFName( Ar, bHasFNameMap ) );
                Result.GetValue_FMinimalName() = NameToMinimalName( Payload.GetRawName() );
                break;
            }
 
            case EStatDataType::ST_Ptr:
            {
                uint64 Payload = 0;
                Ar << Payload;
                Result.GetValue_Ptr() = Payload;
                break;
            }
        }
        return Result;
    }
 
    void ReadFramesOffsets( FArchive& Ar )
    {
        Ar.Seek( Header.FrameTableOffset );
        Ar << FramesInfo;
    }
 
    void ReadFNamesAndMetadataMessages(FArchive& Ar, TArray64<FStatMessage>& out_MetadataMessages)
    {
        // Read FNames.
        Ar.Seek(Header.FNameTableOffset);
        out_MetadataMessages.Reserve(Header.NumFNames);
        for (uint64 Index = 0; Index < Header.NumFNames; Index++)
        {
            ReadFName(Ar, false);
        }
 
        // Read metadata messages.
        Ar.Seek(Header.MetadataMessagesOffset);
        out_MetadataMessages.Reserve(Header.NumMetadataMessages);
        for (uint64 Index = 0; Index < Header.NumMetadataMessages; Index++)
        {
            out_MetadataMessages.Add(ReadMessage(Ar, false));
        }
    }
};
 
struct FRawStatsFileInfo
{
    FRawStatsFileInfo()
        : TotalPacketsSize( 0 )
        , TotalStatMessagesNum( 0 )
        , MaximumPacketSize( 0 )
        , TotalPacketsNum( 0 )
    {}
 
    int32 TotalPacketsSize;
 
    int32 TotalStatMessagesNum;
 
    int32 MaximumPacketSize;
 
    int32 TotalPacketsNum;
};
 
enum class EStatsProcessingStage : int32
{
    SPS_Started = 0,
 
    SPS_ReadStats,
 
    SPS_PreProcessStats,
 
    SPS_ProcessStats,
 
    SPS_PostProcessStats,
 
    SPS_Finished,
 
    SPS_Stopped,
 
    SPS_Invalid,
 
};
 
class FAsyncStatsFile
{
    FStatsReadFile* Owner;
 
public:
    FAsyncStatsFile( FStatsReadFile* InOwner );
 
    void DoWork();
 
    TStatId GetStatId() const
    {
        return TStatId();
    }
 
    bool CanAbandon()
    {
        return true;
    }
 
    void Abandon();
};
 
/*-----------------------------------------------------------------------------
    Stats stack helpers
-----------------------------------------------------------------------------*/
 
struct FStackState
{
    FStackState()
        : bIsBrokenCallstack( false )
    {}
 
    TArray<FName> Stack;
 
    FName Current;
 
    bool bIsBrokenCallstack;
};
 
/*-----------------------------------------------------------------------------
    FStatsReadFile
-----------------------------------------------------------------------------*/
 
template<typename T>
struct FStatsReader
{
    static T* Create( const TCHAR* Filename )
    {
        T* StatsReadFile = new T( Filename );
        const bool bValid = StatsReadFile->PrepareLoading();
        if (!bValid)
        {
            delete StatsReadFile;
        }
        return bValid ? StatsReadFile : nullptr;
    }
};
 
struct FStatsReadFile
{
    friend class FAsyncStatsFile;
    friend struct FStatsReader<FStatsReadFile>;
 
    static CORE_API const double NumSecondsBetweenUpdates;
 
public:
    CORE_API void ReadAndProcessSynchronously();
 
    CORE_API void ReadAndProcessAsynchronously();
 
    CORE_API void SetHistoryFrames( int32 InHistoryFrames );
 
    int32 GetNumFrames() const
    {
        return NumFrames;
    }
 
protected:
    CORE_API FStatsReadFile( const TCHAR* InFilename, bool bInRawStatsFile );
 
public:
    CORE_API virtual ~FStatsReadFile();
 
protected:
    CORE_API bool PrepareLoading();
 
    CORE_API void ReadStats();
 
    CORE_API void ReadRawStats();
 
    CORE_API void ReadRegularStats();
 
    CORE_API virtual void PreProcessStats();
 
    CORE_API void ProcessStats();
 
    virtual void ReadStatsFrame( const TArray<FStatMessage>& CondensedMessages, const int64 Frame )
    {}
 
    CORE_API virtual void PostProcessStats();
 
    virtual void ProcessAdvanceFrameEventGameThreadOperation( const FStatMessage& Message, const FStackState& StackState )
    {}
 
    virtual void ProcessAdvanceFrameEventRenderThreadOperation( const FStatMessage& Message, const FStackState& StackState )
    {}
 
    virtual void ProcessCycleScopeStartOperation( const FStatMessage& Message, const FStackState& StackState )
    {}
 
    virtual void ProcessCycleScopeEndOperation( const FStatMessage& Message, const FStackState& StackState )
    {}
 
    virtual void ProcessSpecialMessageMarkerOperation( const FStatMessage& Message, const FStackState& StackState )
    {}
 
    void SetProcessingStage( EStatsProcessingStage NewStage )
    {
        if (GetProcessingStage() != NewStage)
        {
            ProcessingStage.Set( int32( NewStage ) );
            StageProgress.Set( 0 );
        }
    }
 
public:
    const EStatsProcessingStage GetProcessingStage() const
    {
        return EStatsProcessingStage( ProcessingStage.GetValue() );
    }
 
    const bool IsProcessingStopped() const
    {
        return GetProcessingStage() == EStatsProcessingStage::SPS_Stopped;
    }
 
    FString GetProcessingStageAsString() const
    {
        const EStatsProcessingStage Stage = GetProcessingStage();
        FString Result;
        if (Stage== EStatsProcessingStage::SPS_Started)
        {
            Result = TEXT( "SPS_Started" );
        }
        else if (Stage == EStatsProcessingStage::SPS_ReadStats)
        {
            Result = TEXT( "SPS_ReadStats" );
        }
        else if (Stage == EStatsProcessingStage::SPS_PreProcessStats)
        {
            Result = TEXT( "SPS_PreProcessStats" );
        }
        else if (Stage == EStatsProcessingStage::SPS_ProcessStats)
        {
            Result = TEXT( "SPS_ProcessStats" );
        }
        else if (Stage == EStatsProcessingStage::SPS_PostProcessStats)
        {
            Result = TEXT( "SPS_PostProcessStats" );
        }
        else if (Stage == EStatsProcessingStage::SPS_Finished)
        {
            Result = TEXT( "SPS_Finished" );
        }
        else if (Stage == EStatsProcessingStage::SPS_Stopped)
        {
            Result = TEXT( "SPS_Stopped" );
        }
        else if (Stage == EStatsProcessingStage::SPS_Invalid)
        {
            Result = TEXT( "SPS_Invalid" );
        }
 
        return Result;
    }
 
    int32 GetStageProgress() const
    {
        return StageProgress.GetValue();
    }
 
    bool IsBusy()
    {
        return AsyncWork != nullptr ? !AsyncWork->IsDone() : false;
    }
 
    void RequestStop()
    {
        bShouldStopProcessing = true;
    }
 
protected:
    CORE_API void UpdateReadStageProgress();
 
    CORE_API void UpdateCombinedHistoryStats();
 
    CORE_API void UpdateProcessStageProgress( const int32 CurrentStatMessageIndex, const int32 FrameIndex, const int32 PacketIndex );
 
protected:
    FStatsLoadedState State;
 
    FStatsReadStream Stream;
 
    FStatsStreamHeader& Header;
 
    FArchive* Reader;
 
    FAsyncTask<FAsyncStatsFile>* AsyncWork;
 
    FRawStatsFileInfo FileInfo;
 
    TMap<int32, FStatPacketArray> CombinedHistory;
 
    TArray<int32> Frames;
 
    TSet<FName> UObjectRawNames;
 
    FThreadSafeCounter ProcessingStage;
 
    FThreadSafeCounter StageProgress;
 
    FThreadSafeBool bShouldStopProcessing;
 
    double LastUpdateTime;
 
    const FString Filename;
 
    int32 NumFrames;
 
    const bool bRawStatsFile;
};
 
/*-----------------------------------------------------------------------------
    Commands functionality
-----------------------------------------------------------------------------*/
 
struct FCommandStatsFile
{
    static CORE_API FCommandStatsFile& Get();
 
    FCommandStatsFile()
        : FirstFrame(-1)
        , CurrentStatsFile(nullptr)
    {}
 
    void Start( const FString& Filename );
 
    void StartRaw( const FString& Filename );
 
    void Stop();
 
    void TestLastSaved();
 
    bool IsStatFileActive() const
    {
        return StatFileActiveCounter.GetValue() > 0;
    }
 
    FText GetFileMetaDesc() const
    {
        if (IsStatFileActive() && CurrentStatsFile != nullptr)
        {
            return CurrentStatsFile->GetFileMetaDesc();
        }
        return FText();
    }
 
    FString LastFileSaved;
 
protected:
    int64 FirstFrame;
 
    FThreadSafeCounter StatFileActiveCounter;
 
    IStatsWriteFile* CurrentStatsFile;
};
 
 
#endif // STATS