NetStats.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include "HAL/CriticalSection.h"
#include "Logging/LogMacros.h"
#include "Containers/Array.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogNetStats, Log, All);
 
namespace UE::Net::Private
{
    class FNetRefHandleManager;
    class FNetStatsContext;
}
 
namespace UE::Net::Private
{
 
class FNetSendStats
{
public:
    FNetSendStats() = default;
    FNetSendStats(const FNetSendStats&) = delete;
    FNetSendStats& operator=(const FNetSendStats&) = delete;
 
    void SetNumberOfRootObjectsScheduledForReplication(uint32 Count);
 
    void AddNumberOfReplicatedRootObjects(uint32 Count);
 
    void AddNumberOfReplicatedObjects(uint32 Count);
 
    void AddNumberOfReplicatedDestructionInfos(uint32 Count);
 
    void AddNumberOfDeltaCompressedReplicatedObjects(uint32 Count);
 
    void AddNumberOfReplicatedObjectStatesMaskedOut(uint32 Count);
 
    uint32 GetNumberOfReplicatedRootObjects() const;
 
    uint32 GetNumberOfReplicatedObjects() const;
 
    void SetNumberOfActiveHugeObjects(uint32 Count);
 
    void AddHugeObjectWaitingTime(double Seconds);
 
    void AddHugeObjectStallTime(double Seconds);
 
    IRISCORE_API void Accumulate(const FNetSendStats& Stats);
 
    IRISCORE_API void Reset();
 
    IRISCORE_API void ReportCsvStats();
 
    void SetNumberOfReplicatingConnections(uint32 Count);
 
private:
    // Helper struct to facilitate reset of stats.
    struct FStats
    {
        double HugeObjectWaitingForAckTimeInSeconds = 0;
        double HugeObjectStallingTimeInSeconds = 0;
 
        int32 ScheduledForReplicationRootObjectCount = 0;
        int32 ReplicatedRootObjectCount = 0;
        int32 ReplicatedObjectCount = 0;
        int32 ReplicatedDestructionInfoCount = 0;
        int32 DeltaCompressedObjectCount = 0;
        int32 ReplicatedObjectStatesMaskedOut = 0;
        int32 ActiveHugeObjectCount = 0;
        int32 HugeObjectsWaitingForAckCount = 0;
        int32 HugeObjectsStallingCount = 0;
        int32 ReplicatingConnectionCount = 0;
    };
 
    FCriticalSection CS;
    FStats Stats;
};
 
inline void FNetSendStats::SetNumberOfRootObjectsScheduledForReplication(uint32 Count)
{
    Stats.ScheduledForReplicationRootObjectCount = Count;
}
 
inline void FNetSendStats::AddNumberOfReplicatedRootObjects(uint32 Count)
{
    Stats.ReplicatedRootObjectCount += Count;
}
 
inline void FNetSendStats::AddNumberOfReplicatedObjects(uint32 Count)
{
    Stats.ReplicatedObjectCount += Count;
}
 
inline void FNetSendStats::AddNumberOfDeltaCompressedReplicatedObjects(uint32 Count)
{
    Stats.DeltaCompressedObjectCount += Count;
}
 
inline void FNetSendStats::AddNumberOfReplicatedObjectStatesMaskedOut(uint32 Count)
{
    Stats.ReplicatedObjectStatesMaskedOut += Count;
}
 
inline void FNetSendStats::AddNumberOfReplicatedDestructionInfos(uint32 Count)
{
    Stats.ReplicatedDestructionInfoCount += Count;
}
 
inline uint32 FNetSendStats::GetNumberOfReplicatedRootObjects() const
{
    return Stats.ReplicatedRootObjectCount;
}
 
inline uint32 FNetSendStats::GetNumberOfReplicatedObjects() const
{
    return Stats.ReplicatedObjectCount;
}
 
inline void FNetSendStats::SetNumberOfActiveHugeObjects(uint32 Count)
{
    Stats.ActiveHugeObjectCount = static_cast<int32>(Count);
}
 
inline void FNetSendStats::AddHugeObjectWaitingTime(double Seconds)
{
    ++Stats.HugeObjectsWaitingForAckCount;
    Stats.HugeObjectWaitingForAckTimeInSeconds += Seconds;
}
 
inline void FNetSendStats::AddHugeObjectStallTime(double Seconds)
{
    ++Stats.HugeObjectsStallingCount;
    Stats.HugeObjectStallingTimeInSeconds += Seconds;
}
 
inline void FNetSendStats::SetNumberOfReplicatingConnections(uint32 Count)
{
    Stats.ReplicatingConnectionCount = Count;
}
 
class FNetTypeStats
{
public:
 
    struct FInitParams
    {
        FNetRefHandleManager* NetRefHandleManager = nullptr;
    };
 
    // Preset stats type indices
    static constexpr int32 DefaultTypeStatsIndex = 0U;
    static constexpr int32 OOBChannelTypeStatsIndex = 1U;
 
public:
    FNetTypeStats();
    FNetTypeStats(const FNetTypeStats&) = delete;
    FNetTypeStats& operator=(const FNetTypeStats&) = delete;
    ~FNetTypeStats();
 
    void Init(FInitParams& InitParams);
 
    void PreUpdateSetup();
 
    void ResetStats();
        
    int32 GetOrCreateTypeStats(FName Name);
 
    FNetStatsContext* GetNetStatsContext() { check(!bIsInParallelPhase); return IsEnabled() ?  ParentStatsContext : nullptr; }
 
    bool IsEnabled() const { return bIsEnabled; }
 
    void Accumulate(FNetStatsContext& Context);
 
    void ReportCSVStats();
 
    void CleanupChildNetStatsContexts();
 
    void AccumulateChildrenToParent();
 
    FNetStatsContext* AcquireChildNetStatsContext();
 
    void ReleaseChildNetStatsContext(FNetStatsContext* StatsContext);
 
    void SetIsInParallelPhase(const bool InParallelPhase) { bIsInParallelPhase = InParallelPhase; }
 
private:
    FNetStatsContext* CreateNetStatsContext();
 
    FNetStatsContext* CreateChildNetStatsContext();
 
    void UpdateContext(FNetStatsContext& Context);
 
    FNetStatsContext* ParentStatsContext = nullptr;
 
    FCriticalSection ChildStatsContextCS;
 
    TArray<FNetStatsContext*> ChildStatsContext;
 
    FNetRefHandleManager* NetRefHandleManager = nullptr;
    TArray<FName> TypeStatsNames;
    bool bIsEnabled = false;
    bool bIsInParallelPhase = false;
};
 
struct FReplicationStats
{
    void ReportCSVStats();
 
    void Accumulate(const FReplicationStats& Stats)
    {
        PendingObjectCount += Stats.PendingObjectCount;
        PendingDependentObjectCount += Stats.PendingDependentObjectCount;
        HugeObjectSendQueue += Stats.HugeObjectSendQueue;
        MaxPendingObjectCount = FMath::Max(MaxPendingObjectCount, Stats.MaxPendingObjectCount);
        MaxPendingDependentObjectCount = FMath::Max(MaxPendingDependentObjectCount, Stats.MaxPendingDependentObjectCount);
        MaxHugeObjectSendQueue = FMath::Max(MaxHugeObjectSendQueue, Stats.MaxHugeObjectSendQueue);
        SampleCount += Stats.SampleCount;
    }
 
    uint64 PendingObjectCount;
    uint64 PendingDependentObjectCount;
    uint64 HugeObjectSendQueue;
    uint32 MaxPendingObjectCount;
    uint32 MaxPendingDependentObjectCount;
    uint32 MaxHugeObjectSendQueue;
    uint32 SampleCount;
};
 
} // end namespace UE::Net::Private