NetPing.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Net/Core/Analytics/NetStatsUtils.h"
#include "GameFramework/PlayerState.h"
 
#include "NetPing.generated.h"
 
// Forward declarations
enum class EPingType : uint32;
class FInternetAddr;
 
namespace UE::Net
{
 
namespace Private
{
 
constexpr int32 PingTypeToIdx(EPingType PingType)
{
    // FGenericPlatformMath::FloorLog2 as constexpr
 
    uint32 Value = static_cast<uint32>(PingType);
    uint32 Pos = 0;
    if (Value >= 1<<16) { Value >>= 16; Pos += 16; }
    if (Value >= 1<< 8) { Value >>=  8; Pos +=  8; }
    if (Value >= 1<< 4) { Value >>=  4; Pos +=  4; }
    if (Value >= 1<< 2) { Value >>=  2; Pos +=  2; }
    if (Value >= 1<< 1) {               Pos +=  1; }
 
    return Pos;
}
 
static int32 PingTypeToIdxRuntime(EPingType PingType)
{
    return FMath::FloorLog2(static_cast<uint32>(PingType));
}
 
}
}
 
UENUM()
enum class EPingType : uint32
{
    None                    = 0x00000000,
    RoundTrip               = 0x00000001,   // Round Trip ping which includes any server/client frame time delay
    RoundTripExclFrame      = 0x00000002,   // Round Trip ping which may attempt to exclude server frame time delay (inaccurate)
    ICMP                    = 0x00000004,   // Standard ICMP ping (GameNetDriver client only, accuracy affected by network ICMP throttling)
    UDPQoS                  = 0x00000008,   // UDP based ping used with QoS ping host on server (more accurate than ICMP)
 
    Max                     = UDPQoS,
    Count                   = UE::Net::Private::PingTypeToIdx(static_cast<EPingType>(EPingType::Max)) + 1
};
 
ENUM_CLASS_FLAGS(EPingType);
 
 
UENUM()
enum class EPingAverageType : uint8
{
    None,           // No averaging
    MovingAverage,  // Moving average of the last 4 seconds of ping data
    PlayerStateAvg  // Original PlayerState ping code, calculating a moving average of the last 4 seconds of ping data. To be deprecated.
};
 
enum class ENetPingControlMessage : uint8
{
    SetPingAddress,     // Sent from the server to the client, to override the ICMP/UDP ping address
    PingFailure,        // Sent from the client to the server, to report failure to ping an ICMP/UDP address
 
    Max = PingFailure
};
 
 
namespace UE::Net
{
static bool IsValidPingType(EPingType PingType)
{
    const uint32 PingTypeVal = static_cast<uint32>(PingType);
 
    return FMath::IsPowerOfTwo(PingTypeVal) && PingTypeVal <= static_cast<uint32>(EPingType::Max);
}
 
namespace Private
{
    class FNetPingICMP;
    class FNetPingUDPQoS;
}
 
struct FPingValues
{
    double Current = -1.0;
 
    double Min = -1.0;
 
    double Max = -1.0;
};
 
class FNetPing
{
    template <typename T> friend struct UE::Core::Private::PimplPtr::TPimplHeapObjectImpl;
 
private:
    class FAverageStorageBase
    {
    public:
        uint32 PingCount = 0;
 
        uint32 PingTimeouts = 0;
    };
 
    class FNoAverageStorage : public FAverageStorageBase
    {
    public:
        TSampleMinMaxAvg<EMinMaxValueMode::PerSample> PingValues;
    };
 
    class FMovingAverageStorage : public FAverageStorageBase
    {
    public:
        TSampleMinMaxAvg<EMinMaxValueMode::PerMeasurement> PingValues;
 
        TBinnedMovingAvg<decltype(PingValues), TBinParms::NumBins(4)> PingAccumulator{TBinParms::TimePerBin(1.0)};
 
 
    public:
        FMovingAverageStorage();
    };
 
    class FPlayerStateAvgStorage : public FAverageStorageBase
    {
    private:
        uint8 CurPingBucket = 0;
 
        PingAvgData PingBucket[4];
 
        double CurPingBucketTimestamp = 0.0;
 
    public:
        TSampleMinMaxAvg<EMinMaxValueMode::PerMeasurement> PingValues;
 
 
    public:
        void Reset();
 
        void UpdatePing(double TimeVal, float InPing);
 
    private:
        void RecalculateAvgPing();
    };
 
 
private:
    FNetPing() = delete;
 
    FNetPing(UNetConnection* InOwner);
 
public:
    ~FNetPing();
 
    static TPimplPtr<FNetPing> CreateNetPing(UNetConnection* InOwner);
 
    void UpdatePing(EPingType PingType, double TimeVal, double PingValue);
 
    void UpdatePingTimeout(EPingType PingType);
 
    ENGINE_API FPingValues GetPingValues(EPingType PingType) const;
 
    void TickRealtime(double CurTimeSeconds);
 
    ENGINE_API static void HandleNetPingControlMessage(UNetConnection* Connection, ENetPingControlMessage MessageType, FString MessageStr);
 
    EPingType GetPingTypes() const
    {
        return PingTypes;
    }
 
private:
    void Init();
 
#if STATS
    void UpdatePingStats(EPingType PingType, double CurrentValue);
 
    void UpdateTimeoutStats(EPingType PingType, uint32 NumTimeouts, double TimeoutPercent);
#endif
 
    const FSampleMinMaxAvg& GetPingStorageValues(EPingType PingType) const;
 
    FAverageStorageBase& GetPingStorageBase(EPingType PingType);
 
    void ResetPingValues(EPingType PingType);
 
 
    const TCHAR* GetRemoteAddr();
 
    FString GetICMPAddr();
 
    FString GetUDPQoSAddr();
 
    void UpdateRemoteAddr(double CurTimeSeconds);
 
    void PingTimerICMP(double CurTimeSeconds);
 
    void PingTimerUDP(double CurTimeSeconds);
 
 
    void ServerSetPingAddress(EPingType PingType, FString PingAddress);
 
 
private:
    TObjectPtr<UNetConnection> Owner;
 
    TWeakPtr<const FInternetAddr> WeakRemoteAddr;
 
    FString CachedRemoteAddr = TEXT("");
 
    double NextRemoteAddrCheckTimestamp = 0.0;
 
    EPingType PingTypes = EPingType::None;
 
    EPingAverageType PingAverageTypes[static_cast<uint32>(EPingType::Count)] = { EPingAverageType::None };
 
    uint8 PingAverageStorageIdx[static_cast<uint32>(EPingType::Count)] = { 0 };
 
    TArray<FNoAverageStorage> PingNoAverageStorage;
 
    TArray<FMovingAverageStorage> PingMovingAverageStorage;
 
    TArray<FPlayerStateAvgStorage> PingPlayerStateAvgStorage;
 
    double NextPingTimerICMPTimestamp = 0.0;
 
    double NextPingTimerUDPTimestamp = 0.0;
 
    TSharedPtr<Private::FNetPingICMP> NetPingICMP;
 
    TSharedPtr<Private::FNetPingUDPQoS> NetPingUDPQoS;
 
    FString OverridePingICMPAddress;
 
    FString OverridePingUDPQoSAddress;
 
    int32 OverridePingUDPQosPort = INDEX_NONE;
 
    int32 OverridePingAddressCount = 0;
};
 
}