CookStats.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/StringFwd.h"
#include "Containers/UnrealString.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformTime.h"
#include "HAL/PreprocessorHelpers.h"
#include "HAL/ThreadSafeCounter64.h"
#include "Templates/Decay.h"
#include "Templates/Function.h"
#include "Templates/UnrealTemplate.h"
#include "Trace/Trace.h"
 
namespace UE { namespace Trace { class FChannel; } }
 
#ifndef ENABLE_COOK_STATS
#define ENABLE_COOK_STATS WITH_EDITOR
#endif
 
template <typename FuncType> class TFunctionRef;
template <typename T> struct TDecay;
 
enum class EPackageEventStatType : uint8
{
    LoadPackage = 0,
    SavePackage = 1,
    BeginCacheForCookedPlatformData = 2,
    IsCachedCookedPlatformDataLoaded = 3,
};
 
#if ENABLE_COOK_STATS
class FCookStatsManager
{
public:
    template <typename KeyType, typename ValueType>
    struct TKeyValuePair
    {
        template<typename KeyType2, typename ValueType2>
        TKeyValuePair(KeyType2&& InKey, ValueType2&& InValue)
        : Key(Forward<KeyType2>(InKey)), Value(Forward<ValueType2>(InValue))
        {
        }
        TKeyValuePair() : Key {}, Value {}
        {
        }
        bool operator==(const TKeyValuePair& Other) const
        {
            return Key == Other.Key;
        }
        bool operator!=(const TKeyValuePair& Other) const
        {
            return Key != Other.Key;
        }
        bool operator<(const TKeyValuePair& Other) const
        {
            return Key < Other.Key;
        }
        UE_FORCEINLINE_HINT bool operator()(const TKeyValuePair& A, const TKeyValuePair& B) const
        {
            return A.Key < B.Key;
        }
        KeyType     Key;
        ValueType   Value;
    };
 
    template <typename KeyType, typename ValueType>
    static TKeyValuePair<typename TDecay<KeyType>::Type, typename TDecay<ValueType>::Type> MakePair(KeyType&& InKey, ValueType&& InValue)
    {
        return TKeyValuePair<typename TDecay<KeyType>::Type, typename TDecay<ValueType>::Type>(Forward<KeyType>(InKey), Forward<ValueType>(InValue));
    }
 
 
    typedef TKeyValuePair<FString, FString> StringKeyValue;
    typedef TFunctionRef<void(const FString& StatName, const TArray<StringKeyValue>& StatAttributes)> AddStatFuncRef;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(FGatherCookStatsDelegate, AddStatFuncRef);
 
    static CORE_API FGatherCookStatsDelegate CookStatsCallbacks;
 
    static CORE_API void LogCookStats(AddStatFuncRef AddStat);
 
    struct FAutoRegisterCallback
    {
        template<typename Func>
        explicit FAutoRegisterCallback(Func Callback)
        {
            CookStatsCallbacks.AddLambda(Callback);
        }
    };
 
    //-------------------------------------------------------------------------
    // Helper to initialize an array of KeyValues on one line.
    //-------------------------------------------------------------------------
 
    template <typename...ArgTypes>
    static TArray<FCookStatsManager::StringKeyValue> CreateKeyValueArray(ArgTypes&&...Args)
    {
        TArray<FCookStatsManager::StringKeyValue> Attrs;
        Attrs.Empty(sizeof...(Args) / 2);
        ImplCreateKeyValueArray(Attrs, Forward<ArgTypes>(Args)...);
        return Attrs;
    }
 
private:
    template <typename KeyType>
    static void ImplCreateKeyValueArray(TArray<FCookStatsManager::StringKeyValue>& Attrs, KeyType&& Key)
    {
        Attrs.Emplace(LexToString(Forward<KeyType>(Key)), TEXT(""));
    }
 
    template <typename KeyType, typename ValueType>
    static void ImplCreateKeyValueArray(TArray<FCookStatsManager::StringKeyValue>& Attrs, KeyType&& Key, ValueType&& Value)
    {
        Attrs.Emplace(LexToString(Forward<KeyType>(Key)), LexToString(Forward<ValueType>(Value)));
    }
 
    template <typename KeyType, typename ValueType, typename...ArgTypes>
    static void ImplCreateKeyValueArray(TArray<FCookStatsManager::StringKeyValue>& Attrs, KeyType&& Key, ValueType&& Value, ArgTypes&&...Args)
    {
        Attrs.Emplace(LexToString(Forward<KeyType>(Key)), LexToString(Forward<ValueType>(Value)));
        ImplCreateKeyValueArray(Attrs, Forward<ArgTypes>(Args)...);
    }
 
};
 
struct FDerivedDataUsageStats;
 
class FCookStats
{
public:
    struct CallStats
    {
        enum class EHitOrMiss : uint8
        {
            Hit,
            Miss,
            MaxValue,
        };
 
        enum class EStatType : uint8
        {
            Counter,
            Cycles,
            Bytes,
            MaxValue,
        };
 
        struct GameAndOtherThreadAccumulator
        {
            void Accumulate(int64 Value, bool bIsInGameThread)
            {
                if (bIsInGameThread)
                {
                    GameThread += Value;
                }
                else if (Value != 0)
                {
                    OtherThread.Add(Value);
                }
            }
            int64 GetAccumulatedValue(bool bIsInGameThread) const
            {
                return bIsInGameThread ? GameThread : OtherThread.GetValue();
            }
 
            int64 GameThread = 0l;
            FThreadSafeCounter64 OtherThread;
        };
 
        void Accumulate(EHitOrMiss HitOrMiss, EStatType StatType, int64 Value, bool bIsInGameThread)
        {
            Accumulators[(uint8)HitOrMiss][(uint8)StatType].Accumulate(Value, bIsInGameThread);
        }
 
        int64 GetAccumulatedValue(EHitOrMiss HitOrMiss, EStatType StatType, bool bIsInGameThread) const
        {
            return Accumulators[(uint8)HitOrMiss][(uint8)StatType].GetAccumulatedValue(bIsInGameThread);
        }
 
        int64 GetAccumulatedValueAnyThread(EHitOrMiss HitOrMiss, EStatType StatType) const
        {
            return GetAccumulatedValue(HitOrMiss, StatType, true) + GetAccumulatedValue(HitOrMiss, StatType, false);
        }
 
        void LogStats(FCookStatsManager::AddStatFuncRef AddStat, const FString& StatName, const FString& NodeName, const TCHAR* CallName) const
        {
            auto LogStat = [&](EHitOrMiss HitOrMiss, bool bGameThread)
            {
                // only report the stat if it's non-zero
                if (GetAccumulatedValue(HitOrMiss, EStatType::Cycles, bGameThread) > 0)
                {
                    AddStat(StatName, FCookStatsManager::CreateKeyValueArray(
                        TEXT("ThreadName"), bGameThread ? TEXT("GameThread") : TEXT("OthrThread"),
                        TEXT("Call"), CallName,
                        TEXT("HitOrMiss"), HitOrMiss == EHitOrMiss::Hit ? TEXT("Hit") : TEXT("Miss"),
                        TEXT("Count"), GetAccumulatedValue(HitOrMiss, EStatType::Counter, bGameThread),
                        TEXT("TimeSec"), (double)GetAccumulatedValue(HitOrMiss, EStatType::Cycles, bGameThread) * FPlatformTime::GetSecondsPerCycle(),
                        TEXT("MB"), (double)GetAccumulatedValue(HitOrMiss, EStatType::Bytes, bGameThread) / (1024.0 * 1024.0),
                        TEXT("MB/s"), GetAccumulatedValue(HitOrMiss, EStatType::Cycles, bGameThread) == 0
                            ? 0.0
                            : (double)GetAccumulatedValue(HitOrMiss, EStatType::Bytes, bGameThread) / (1024.0 * 1024.0) /
                             ((double)GetAccumulatedValue(HitOrMiss, EStatType::Cycles, bGameThread) * FPlatformTime::GetSecondsPerCycle()),
                        TEXT("Node"), NodeName
                        ));
                }
            };
 
            LogStat(EHitOrMiss::Hit, true);
            LogStat(EHitOrMiss::Miss, true);
            LogStat(EHitOrMiss::Hit, false);
            LogStat(EHitOrMiss::Miss, false);
        }
 
        void Combine(const CallStats& Other)
        {
            for (int32 IsGameThread = 0; IsGameThread <= 1; IsGameThread++)
            {
                for (int32 HitOrMiss = 0; HitOrMiss < (uint8)EHitOrMiss::MaxValue; HitOrMiss++)
                {
                    for (int32 StatType = 0; StatType < (uint8)EStatType::MaxValue; StatType++)
                    {
                        int64 Value = Other.GetAccumulatedValue((EHitOrMiss)HitOrMiss, (EStatType)StatType, IsGameThread == 1);
                        Accumulate((EHitOrMiss)HitOrMiss, (EStatType)StatType, Value, IsGameThread == 1);
                    }
                }
            }
        }
 
    private:
        GameAndOtherThreadAccumulator Accumulators[(uint8)EHitOrMiss::MaxValue][(uint8)EStatType::MaxValue];
    };
 
    class FScopedStatsCounter
    {
    public:
        explicit FScopedStatsCounter(CallStats& InStats)
            : Stats(InStats)
            , StartTime(FPlatformTime::Cycles64())
            , bIsInGameThread(IsInGameThread())
        {
        }
 
        FScopedStatsCounter(FScopedStatsCounter&& InOther)
            : Stats(InOther.Stats)
            , StartTime(InOther.StartTime)
            , BytesProcessed(InOther.BytesProcessed)
            , bIsInGameThread(InOther.bIsInGameThread)
            , bCanceled(InOther.bCanceled)
            , bTrackCyclesOnly(InOther.bTrackCyclesOnly)
            , HitOrMiss(InOther.HitOrMiss)
        {
            InOther.Cancel();
        }
 
        FScopedStatsCounter(const FScopedStatsCounter&) = delete;
 
        ~FScopedStatsCounter()
        {
            if (!bCanceled)
            {
                uint64 CurrentTime = FPlatformTime::Cycles64();
                const uint64 CyclesUsed = CurrentTime - StartTime;
 
                Stats.Accumulate(HitOrMiss, CallStats::EStatType::Cycles, CyclesUsed, bIsInGameThread);
                if (!bTrackCyclesOnly)
                {
                    Stats.Accumulate(HitOrMiss, CallStats::EStatType::Counter, 1l, bIsInGameThread);
                }
                Stats.Accumulate(HitOrMiss, CallStats::EStatType::Bytes, BytesProcessed, bIsInGameThread);
            }
        }
 
    public:
        void AddHit(int64 InBytesProcessed)
        {
            HitOrMiss = CallStats::EHitOrMiss::Hit;
            BytesProcessed = InBytesProcessed;
        }
 
        void AddMiss(int64 InBytesProcessed = 0)
        {
            HitOrMiss = CallStats::EHitOrMiss::Miss;
            BytesProcessed = InBytesProcessed;
        }
 
        void AddHitOrMiss(CallStats::EHitOrMiss InHitOrMiss, int64 InBytesProcessed)
        {
            HitOrMiss = InHitOrMiss;
            BytesProcessed = InBytesProcessed;
        }
 
        void Cancel()
        {
            bCanceled = true;
        }
 
        void TrackCyclesOnly()
        {
            bTrackCyclesOnly = true;
        }
 
    private:
        CallStats& Stats;
        uint64 StartTime;
        int64 BytesProcessed = 0;
        bool bIsInGameThread;
        bool bCanceled = false;
        bool bTrackCyclesOnly = false;
        CallStats::EHitOrMiss HitOrMiss = CallStats::EHitOrMiss::Miss;
    };
 
    using FDDCResourceUsageStats = FDerivedDataUsageStats;
};
 
struct FDerivedDataUsageStats
{
    FCookStats::FScopedStatsCounter TimeSyncWork()
    {
        return FCookStats::FScopedStatsCounter(SyncWorkStats);
    }
 
    FCookStats::FScopedStatsCounter TimeAsyncWait()
    {
        return FCookStats::FScopedStatsCounter(AsyncWaitStats);
    }
 
    // expose these publicly for low level access. These should really never be accessed directly except when finished accumulating them.
    FCookStats::CallStats SyncWorkStats;
    FCookStats::CallStats AsyncWaitStats;
 
    void LogStats(FCookStatsManager::AddStatFuncRef AddStat, const FString& StatName, const FString& NodeName) const
    {
        SyncWorkStats.LogStats(AddStat, StatName, NodeName, TEXT("SyncWork"));
        AsyncWaitStats.LogStats(AddStat, StatName, NodeName, TEXT("AsyncWait"));
    }
};
 
#define COOK_STAT(...) __VA_ARGS__
 
UE_TRACE_CHANNEL_EXTERN(CookChannel, CORE_API);
 
#define UE_INSIGHTS_COOK_PROFILER_VERSION 2
 
CORE_API void TracePackage(uint64 InId, const FStringView InName);
CORE_API void TracePackageAssetClass(uint64 InId, const FStringView InName);
CORE_API bool ShouldTracePackageInfo();
 
#if UE_INSIGHTS_COOK_PROFILER_VERSION == 2
 
UE_DEPRECATED(5.5, "TracePackageStat is deprecated, please use TracePackageStatBeginScope and TracePackageStatEndScope instead.")
CORE_API void TracePackageStat(uint64 InId, uint64 Duration, EPackageEventStatType StatType);
 
CORE_API void TracePackageStatBeginScope(uint64 InId, uint64 Time, EPackageEventStatType StatType);
CORE_API void TracePackageStatEndScope(uint64 InId, uint64 Time, EPackageEventStatType StatType);
 
struct FScopedCookStat
{
    FScopedCookStat(const FScopedCookStat&) = delete;
    FScopedCookStat(FScopedCookStat&&) = delete;
 
    FScopedCookStat(uint64 Id, EPackageEventStatType InStatType)
        : Id(Id)
        , StatType(InStatType)
    {
        TracePackageStatBeginScope(Id, FPlatformTime::Cycles64(), StatType);
    }
 
    ~FScopedCookStat()
    {
        TracePackageStatEndScope(Id, FPlatformTime::Cycles64(), StatType);
    }
 
private:
    uint64 Id;
    EPackageEventStatType StatType;
};
 
#endif
 
#if UE_INSIGHTS_COOK_PROFILER_VERSION == 1
 
UE_DEPRECATED(5.5, "TracePackageStat is deprecated, please use TracePackageStatBeginScope and TracePackageStatEndScope instead.")
CORE_API void TracePackageStat(uint64 InId, uint64 Duration, EPackageEventStatType StatType);
 
struct FScopedCookStat
{
    FScopedCookStat(const FScopedCookStat&) = delete;
    FScopedCookStat(FScopedCookStat&&) = delete;
 
    FScopedCookStat(uint64 Id, EPackageEventStatType InStatType)
        : Id(Id)
        , StatType(InStatType)
    {
        StartTimestamp = FPlatformTime::Cycles64();
    }
 
    ~FScopedCookStat()
    {
        uint64 Duration = FPlatformTime::Cycles64() - StartTimestamp;
        TracePackageStat(Id, Duration, StatType);
    }
 
private:
    uint64 Id;
    uint64 StartTimestamp;
    EPackageEventStatType StatType;
};
 
#endif
 
#define UE_SCOPED_COOK_STAT(Name, StatType) \
    FScopedCookStat  PREPROCESSOR_JOIN(__CookTimerScope, __LINE__)(Name.ToUnstableInt(), StatType);
 
#define UE_MULTI_SCOPED_COOK_STAT_INIT() \
    TOptional<FScopedCookStat> __CookStatScope; \
    FName __PrevPackageName = NAME_None;
 
#define UE_MULTI_SCOPED_COOK_STAT(Name, StatType) \
    if (__PrevPackageName != Name) \
    { \
        __CookStatScope.Emplace(Name.ToUnstableInt(), EPackageEventStatType::LoadPackage); \
        __PrevPackageName = Name; \
    }
 
#define UE_MULTI_SCOPED_COOK_STAT_RESET() \
    __CookStatScope.Reset(); \
    __PrevPackageName = NAME_None;
#else
 
#define COOK_STAT(...)
#define UE_SCOPED_COOK_STAT(...)
#define UE_MULTI_SCOPED_COOK_STAT_INIT(...)
#define UE_MULTI_SCOPED_COOK_STAT(...)
#define UE_MULTI_SCOPED_COOK_STAT_RESET(...)
 
#define TracePackage(...)
#define TracePackageStat(...)
#define TracePackageStatBeginScope(...)
#define TracePackageStatEndScope(...)
#define TracePackageAssetClass(...)
#define ShouldTracePackageInfo(...) false
 
#endif