NetworkProfiler.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    NetworkProfiler.h: network profiling support.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/EngineTypes.h"
#include "IPAddress.h"
#include "Containers/BitArray.h"
#include "Serialization/MemoryWriter.h"
#include "ProfilingDebugging/CsvProfiler.h"
#include "Misc/ScopeLock.h"
#include "Misc/TransactionallySafeCriticalSection.h"
 
class AActor;
class FOutBunch;
class UNetConnection;
struct FURL;
 
#if USE_NETWORK_PROFILER 
 
CSV_DECLARE_CATEGORY_EXTERN(NetworkProfiler);
 
#define NETWORK_PROFILER( x ) \
    if ( GNetworkProfiler.IsTrackingEnabled() ) \
    { \
        CSV_SCOPED_TIMING_STAT_EXCLUSIVE(NetworkProfiler); \
        x; \
    }
 
DECLARE_MULTICAST_DELEGATE_OneParam(FOnNetworkProfileStarted, const FString& /*Filename */);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnNetworkProfileFinished, const FString& /*Filename */);
 
enum class ENetworkProfilerVersionHistory : uint32;
 
/*=============================================================================
    Network profiler header.
=============================================================================*/
 
class FNetworkProfilerHeader
{
private:
    uint32  Magic;
    ENetworkProfilerVersionHistory  Version;
 
    FString Tag;
    FString GameName;
    FString URL;
 
public:
    FNetworkProfilerHeader();
 
    void Reset(const FURL& InURL);
 
    FString GetURL() const { return URL; }
 
    friend FArchive& operator << ( FArchive& Ar, FNetworkProfilerHeader& Header );
};
 
/*=============================================================================
    FNetworkProfiler
=============================================================================*/
 
class FNetworkProfiler
{
private:
 
    friend struct FNetworkProfilerScopedIgnoreReplicateProperties;
    friend struct FNetworkProfilerCVarHelper;
 
    static ENGINE_API bool bIsComparisonTrackingEnabled;
 
    FArchive*                               FileWriter;
 
    FTransactionallySafeCriticalSection     CriticalSection;
 
    TMap<FString,int32>                     NameToNameTableIndexMap;
 
    TArray<FString>                         NameArray;
 
    TMap<FString, int32>                    AddressTableIndexMap;
 
    bool                                    bHasNoticeableNetworkTrafficOccured;
    bool                                    bIsTrackingEnabled; 
    bool                                    bShouldTrackingBeEnabled;
 
    FNetworkProfilerHeader                  CurrentHeader;
 
    TSharedPtr<const FInternetAddr>         LastAddress;
 
    FOnNetworkProfileStarted                OnNetworkProfileStartedDelegate;
 
    FOnNetworkProfileFinished               OnNetworkProfileFinishedDelegate;
 
    FTimerHandle                            AutoStopTimerHandle;
 
    struct FSendBunchInfo
    {
        uint16 ChannelIndex;
        uint32 ChannelTypeNameIndex;
        uint16 NumHeaderBits;
        uint16 NumPayloadBits;
 
        FSendBunchInfo()
            : ChannelIndex(0)
            , ChannelTypeNameIndex(0)
            , NumHeaderBits(0)
            , NumPayloadBits(0) {}
 
        FSendBunchInfo( uint16 InChannelIndex, uint32 InChannelTypeNameIndex, uint16 InNumHeaderBits, uint16 InNumPayloadBits )
            : ChannelIndex(InChannelIndex)
            , ChannelTypeNameIndex(InChannelTypeNameIndex)
            , NumHeaderBits(InNumHeaderBits)
            , NumPayloadBits(InNumPayloadBits) {}
    };
 
    TMap<UNetConnection*, TArray<FSendBunchInfo>>   OutgoingBunches;
 
    struct FQueuedRPCInfo
    {
        UNetConnection* Connection;
        UObject* TargetObject;
        uint32 ActorNameIndex;
        uint32 FunctionNameIndex;
        uint32 NumHeaderBits;
        uint32 NumParameterBits;
        uint32 NumFooterBits;
 
        FQueuedRPCInfo()
            : Connection(nullptr)
            , TargetObject(nullptr)
            , ActorNameIndex(0)
            , FunctionNameIndex(0)
            , NumHeaderBits(0)
            , NumParameterBits(0)
            , NumFooterBits(0) {}
    };
    
    TArray<FQueuedRPCInfo> QueuedRPCs;
 
    ENGINE_API int32 GetNameTableIndex( const FString& Name );
 
    ENGINE_API int32 GetAddressTableIndex( const FString& Address );
 
    ENGINE_API void TrackCompareProperties_Unsafe(const FString& ObjectName, uint32 Cycles, TBitArray<>& PropertiesCompared, TBitArray<>& PropertiesThatChanged, TArray<uint8>& PropertyNameExportData);
 
    // Used with FScopedIgnoreReplicateProperties.
    uint32 IgnorePropertyCount;
 
    // Set of names that correspond to Object's whose top level property names have been exported.
    TSet<FString> ExportedObjects;
 
    ENGINE_API void AutoStopTracking();
 
    void SerializeReplicateProperty( uint32 NameTableIndex, uint16 NumBits, UNetConnection* Connection );
    
    void SerializeWritePropertyHeader( uint32 NameTableIndex, uint16 NumBits, UNetConnection* Connection );
 
    void SerializeWritePropertyHandle( uint16 NumBits, UNetConnection* Connection );
 
    void SerializeBeginContentBlock( uint32 NameTableIndex, uint16 NumBits, UNetConnection* Connection );
 
    void SerializeEndContentBlock( uint32 NameTableIndex, uint16 NumBits, UNetConnection* Connection );
 
    
    FString NextFileName;
 
public:
    ENGINE_API FNetworkProfiler();
 
    ENGINE_API void EnableTracking( bool bShouldEnableTracking );
 
    ENGINE_API void SetNextFileName(const FString& FileName);
 
    ENGINE_API void TrackFrameBegin();
 
    ENGINE_API void SetCurrentConnection( UNetConnection* Connection );
 
    
    ENGINE_API void TrackSendRPC(const AActor* Actor, const UFunction* Function, uint32 NumHeaderBits, uint32 NumParameterBits, uint32 NumFooterBits, UNetConnection* Connection);
    
    ENGINE_API void TrackQueuedRPC(UNetConnection* Connection, UObject* TargetObject, const AActor* Actor, const UFunction* Function, uint32 NumHeaderBits, uint32 NumParameterBits, uint32 NumFooterBits);
 
    ENGINE_API void FlushQueuedRPCs( UNetConnection* Connection, UObject* TargetObject );
 
    ENGINE_API void TrackSocketSend( const FString& SocketDesc, const void* Data, uint16 BytesSent );
 
    ENGINE_API void TrackSocketSendTo(
        const FString& SocketDesc,
        const void* Data,
        uint16 BytesSent,
        uint16 NumPacketIdBits,
        uint16 NumBunchBits,
        uint16 NumAckBits,
        uint16 NumPaddingBits,
        UNetConnection* Connection );
 
    ENGINE_API void TrackSocketSendToCore(
        const FString& SocketDesc,
        const void* Data,
        uint16 BytesSent,
        uint16 NumPacketIdBits,
        uint16 NumBunchBits,
        uint16 NumAckBits,
        uint16 NumPaddingBits,
        UNetConnection* Connection );
 
    
    ENGINE_API void TrackSendBunch( FOutBunch* OutBunch, uint16 NumBits, UNetConnection* Connection );
    
    ENGINE_API void PushSendBunch( UNetConnection* Connection, FOutBunch* OutBunch, uint16 NumHeaderBits, uint16 NumPayloadBits );
 
    ENGINE_API void PopSendBunch( UNetConnection* Connection );
 
    ENGINE_API void FlushOutgoingBunches( UNetConnection* Connection );
 
    ENGINE_API void TrackReplicateActor( const AActor* Actor, FReplicationFlags RepFlags, uint32 Cycles, UNetConnection* Connection );
 
    ENGINE_API void TrackReplicatePropertiesMetadata(const UObject* Object, TBitArray<>& InactiveProperties, bool bSentAllProperties, UNetConnection* Connection);
 
    template<typename T, typename ProjectionType>
    void TrackCompareProperties(const UObject* Object, uint32 Cycles, TBitArray<>& PropertiesCompared, TBitArray<>& PropertiesThatChanged, const TArray<T>& PropertyNameContainers, ProjectionType PropertyNameProjection)
    {
        if (IsComparisonTrackingEnabled())
        {
            UE::TScopeLock ScopeLock(CriticalSection);
 
            FString ObjectName = GetNameSafe(Object);
            TArray<uint8> PropertyNameExportData;
 
            if (!ExportedObjects.Contains(ObjectName))
            {
                uint32 NumProperties = PropertyNameContainers.Num();
                PropertyNameExportData.Reserve(2 + (NumProperties * 2));
                FMemoryWriter PropertyNameAr(PropertyNameExportData);
 
                PropertyNameAr.SerializeIntPacked(NumProperties);
                for (const T& PropertyNameContainer : PropertyNameContainers)
                {
                    uint32 PropertyNameIndex = GetNameTableIndex(PropertyNameProjection(PropertyNameContainer));
                    PropertyNameAr.SerializeIntPacked(PropertyNameIndex);
                }
            }
 
            TrackCompareProperties_Unsafe(ObjectName, Cycles, PropertiesCompared, PropertiesThatChanged, PropertyNameExportData);
        }
    }
 
    ENGINE_API void TrackReplicateProperty( const FProperty* Property, uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API void TrackWritePropertyHeader( const FProperty* Property, uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API void TrackEvent( const FString& EventName, const FString& EventDescription, UNetConnection* Connection );
 
    ENGINE_API void TrackSessionChange( bool bShouldContinueTracking, const FURL& InURL );
 
    ENGINE_API void TrackSendAck( uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API void TrackExportBunch( uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API void TrackMustBeMappedGuids( uint16 NumGuids, uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API void TrackBeginContentBlock( UObject* Object, uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API void TrackEndContentBlock( UObject* Object, uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API void TrackWritePropertyHandle( uint16 NumBits, UNetConnection* Connection );
 
    ENGINE_API bool Exec( UWorld * InWorld, const TCHAR* Cmd, FOutputDevice & Ar );
 
    bool inline IsTrackingEnabled() const { return bIsTrackingEnabled || bShouldTrackingBeEnabled; }
    bool IsComparisonTrackingEnabled() const { return (bIsTrackingEnabled || bShouldTrackingBeEnabled) && bIsComparisonTrackingEnabled; }
 
    FOnNetworkProfileStarted& OnNetworkProfileStarted() { return OnNetworkProfileStartedDelegate; }
 
    FOnNetworkProfileFinished& OnNetworkProfileFinished() { return OnNetworkProfileFinishedDelegate; }
};
 
extern ENGINE_API FNetworkProfiler GNetworkProfiler;
 
#define NETWORK_PROFILER_IGNORE_PROPERTY_SCOPE const FNetworkProfilerScopedIgnoreReplicateProperties _NetProfilePrivate_IgnoreScope;
 
struct FNetworkProfilerScopedIgnoreReplicateProperties
{
    FNetworkProfilerScopedIgnoreReplicateProperties()
    {
        ++GNetworkProfiler.IgnorePropertyCount;
    }
 
    ~FNetworkProfilerScopedIgnoreReplicateProperties()
    {
        --GNetworkProfiler.IgnorePropertyCount;
    }
 
private:
 
    FNetworkProfilerScopedIgnoreReplicateProperties(const FNetworkProfilerScopedIgnoreReplicateProperties&) = delete;
    FNetworkProfilerScopedIgnoreReplicateProperties(FNetworkProfilerScopedIgnoreReplicateProperties&&) = delete;
};
 
#else   // USE_NETWORK_PROFILER
 
#define NETWORK_PROFILER(x)
#define NETWORK_PROFILER_IGNORE_PROPERTY_SCOPE 
 
#endif