299 lines
12 KiB
C
299 lines
12 KiB
C
//====== Copyright Valve Corporation, All rights reserved. ====================
|
|
//
|
|
// Some public types for communicating detailed connection stats
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef STEAMDATAGRAM_STATS_H
|
|
#define STEAMDATAGRAM_STATS_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "steamnetworkingtypes.h"
|
|
|
|
#pragma pack(push)
|
|
#pragma pack(8)
|
|
|
|
STEAMDATAGRAMLIB_INTERFACE void SteamDatagramLinkInstantaneousStats_Clear( SteamDatagramLinkInstantaneousStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE void SteamDatagramLinkLifetimeStats_Clear( SteamDatagramLinkLifetimeStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE int SteamDatagramLinkLifetimeStats_PingHistogramTotalCount( const SteamDatagramLinkLifetimeStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE int SteamDatagramLinkLifetimeStats_QualityHistogramTotalCount( const SteamDatagramLinkLifetimeStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE int SteamDatagramLinkLifetimeStats_JitterHistogramTotalCount( const SteamDatagramLinkLifetimeStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE int SteamDatagramLinkLifetimeStats_TXSpeedHistogramTotalCount( const SteamDatagramLinkLifetimeStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE int SteamDatagramLinkLifetimeStats_RXSpeedHistogramTotalCount( const SteamDatagramLinkLifetimeStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE void SteamDatagramLinkStats_Clear( SteamDatagramLinkStats *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE void SteamNetworkingDetailedConnectionStatus_Clear( SteamNetworkingDetailedConnectionStatus *pThis );
|
|
STEAMDATAGRAMLIB_INTERFACE int SteamNetworkingDetailedConnectionStatus_Print( const SteamNetworkingDetailedConnectionStatus *pThis, char *pszBuf, int cbBuf );
|
|
|
|
/// Instantaneous statistics for a link between two hosts.
|
|
struct SteamDatagramLinkInstantaneousStats
|
|
{
|
|
|
|
/// Data rates
|
|
float m_flOutPacketsPerSec;
|
|
float m_flOutBytesPerSec;
|
|
float m_flInPacketsPerSec;
|
|
float m_flInBytesPerSec;
|
|
|
|
/// Smoothed ping. This will be -1 if we don't have any idea!
|
|
int m_nPingMS;
|
|
|
|
/// 0...1, estimated number of packets that were sent to us, but we failed to receive.
|
|
/// <0 if we haven't received any sequenced packets and so we don't have any way to estimate this.
|
|
float m_flPacketsDroppedPct;
|
|
|
|
/// Packets received with a sequence number abnormality, other than basic packet loss. (Duplicated, out of order, lurch.)
|
|
/// <0 if we haven't received any sequenced packets and so we don't have any way to estimate this.
|
|
float m_flPacketsWeirdSequenceNumberPct;
|
|
|
|
/// Peak jitter
|
|
int m_usecMaxJitter;
|
|
|
|
/// Current sending rate, this can be low at connection start until the slow start
|
|
/// ramps it up. It's adjusted as packets are lost and congestion is encountered during
|
|
/// the connection
|
|
int m_nSendRate;
|
|
|
|
/// How many pending bytes are waiting to be sent. This is data that is currently waiting
|
|
/// to be sent and in outgoing buffers. If this is zero, then the connection is idle
|
|
/// and all pending data has been sent. Note that in case of packet loss any pending
|
|
/// reliable data might be re-sent. This does not include data that has been sent and is
|
|
/// waiting for acknowledgment.
|
|
int m_nPendingBytes;
|
|
|
|
inline void Clear() { SteamDatagramLinkInstantaneousStats_Clear( this ); }
|
|
};
|
|
|
|
/// Stats for the lifetime of a connection.
|
|
/// Should match CMsgSteamDatagramLinkLifetimeStats
|
|
struct SteamDatagramLinkLifetimeStats
|
|
{
|
|
/// Reset all values to zero / unknown status
|
|
inline void Clear() { return SteamDatagramLinkLifetimeStats_Clear( this ); }
|
|
|
|
//
|
|
// Lifetime counters.
|
|
// NOTE: Average packet loss, etc can be deduced from this.
|
|
//
|
|
int64 m_nPacketsSent;
|
|
int64 m_nBytesSent;
|
|
int64 m_nPacketsRecv; // total number of packets received, some of which might not have had a sequence number. Don't use this number to try to estimate lifetime packet loss, use m_nPacketsRecvSequenced
|
|
int64 m_nBytesRecv;
|
|
int64 m_nPktsRecvSequenced; // packets that we received that had a sequence number.
|
|
int64 m_nPktsRecvDropped;
|
|
int64 m_nPktsRecvOutOfOrder;
|
|
int64 m_nPktsRecvDuplicate;
|
|
int64 m_nPktsRecvSequenceNumberLurch;
|
|
|
|
// SNP message counters
|
|
int64 m_nMessagesSentReliable;
|
|
int64 m_nMessagesSentUnreliable;
|
|
int64 m_nMessagesRecvReliable;
|
|
int64 m_nMessagesRecvUnreliable;
|
|
|
|
//
|
|
// Ping distribution
|
|
//
|
|
int m_nPingHistogram25; // 0..25
|
|
int m_nPingHistogram50; // 26..50
|
|
int m_nPingHistogram75; // 51..75
|
|
int m_nPingHistogram100; // etc
|
|
int m_nPingHistogram125;
|
|
int m_nPingHistogram150;
|
|
int m_nPingHistogram200;
|
|
int m_nPingHistogram300;
|
|
int m_nPingHistogramMax; // >300
|
|
inline int PingHistogramTotalCount() const { return SteamDatagramLinkLifetimeStats_PingHistogramTotalCount( this ); }
|
|
|
|
// Distribution.
|
|
// NOTE: Some of these might be -1 if we didn't have enough data to make a meaningful estimate!
|
|
// It takes fewer samples to make an estimate of the median than the 98th percentile!
|
|
short m_nPingNtile5th; // 5% of ping samples were <= Nms
|
|
short m_nPingNtile50th; // 50% of ping samples were <= Nms
|
|
short m_nPingNtile75th; // 70% of ping samples were <= Nms
|
|
short m_nPingNtile95th; // 95% of ping samples were <= Nms
|
|
short m_nPingNtile98th; // 98% of ping samples were <= Nms
|
|
short m__pad1;
|
|
|
|
|
|
//
|
|
// Connection quality distribution
|
|
//
|
|
int m_nQualityHistogram100; // This means everything was perfect. If we delivered over 100 packets in the interval and were less than perfect, but greater than 99.5%, we will use 99% instead.
|
|
int m_nQualityHistogram99; // 99%+
|
|
int m_nQualityHistogram97;
|
|
int m_nQualityHistogram95;
|
|
int m_nQualityHistogram90;
|
|
int m_nQualityHistogram75;
|
|
int m_nQualityHistogram50;
|
|
int m_nQualityHistogram1;
|
|
int m_nQualityHistogramDead; // we received nothing during the interval; it looks like the connection dropped
|
|
inline int QualityHistogramTotalCount() const { return SteamDatagramLinkLifetimeStats_QualityHistogramTotalCount( this ); }
|
|
|
|
// Distribution. Some might be -1, see above for why.
|
|
short m_nQualityNtile2nd; // 2% of measurement intervals had quality <= N%
|
|
short m_nQualityNtile5th; // 5% of measurement intervals had quality <= N%
|
|
short m_nQualityNtile25th; // 25% of measurement intervals had quality <= N%
|
|
short m_nQualityNtile50th; // 50% of measurement intervals had quality <= N%
|
|
|
|
// Jitter histogram
|
|
int m_nJitterHistogramNegligible;
|
|
int m_nJitterHistogram1;
|
|
int m_nJitterHistogram2;
|
|
int m_nJitterHistogram5;
|
|
int m_nJitterHistogram10;
|
|
int m_nJitterHistogram20;
|
|
inline int JitterHistogramTotalCount() const { return SteamDatagramLinkLifetimeStats_JitterHistogramTotalCount( this ); }
|
|
|
|
//
|
|
// Connection transmit speed histogram
|
|
//
|
|
int m_nTXSpeedMax; // Max speed we hit
|
|
|
|
int m_nTXSpeedHistogram16; // Speed at kb/s
|
|
int m_nTXSpeedHistogram32;
|
|
int m_nTXSpeedHistogram64;
|
|
int m_nTXSpeedHistogram128;
|
|
int m_nTXSpeedHistogram256;
|
|
int m_nTXSpeedHistogram512;
|
|
int m_nTXSpeedHistogram1024;
|
|
int m_nTXSpeedHistogramMax;
|
|
inline int TXSpeedHistogramTotalCount() const { return SteamDatagramLinkLifetimeStats_TXSpeedHistogramTotalCount( this ); }
|
|
|
|
// Distribution. Some might be -1, see above for why.
|
|
int m_nTXSpeedNtile5th; // 5% of transmit samples were <= N kb/s
|
|
int m_nTXSpeedNtile50th; // 50% of transmit samples were <= N kb/s
|
|
int m_nTXSpeedNtile75th; // 75% of transmit samples were <= N kb/s
|
|
int m_nTXSpeedNtile95th; // 95% of transmit samples were <= N kb/s
|
|
int m_nTXSpeedNtile98th; // 98% of transmit samples were <= N kb/s
|
|
|
|
//
|
|
// Connection receive speed histogram
|
|
//
|
|
int m_nRXSpeedMax; // Max speed we hit that formed the histogram
|
|
|
|
int m_nRXSpeedHistogram16; // Speed at kb/s
|
|
int m_nRXSpeedHistogram32;
|
|
int m_nRXSpeedHistogram64;
|
|
int m_nRXSpeedHistogram128;
|
|
int m_nRXSpeedHistogram256;
|
|
int m_nRXSpeedHistogram512;
|
|
int m_nRXSpeedHistogram1024;
|
|
int m_nRXSpeedHistogramMax;
|
|
inline int RXSpeedHistogramTotalCount() const { return SteamDatagramLinkLifetimeStats_RXSpeedHistogramTotalCount( this ); }
|
|
|
|
// Distribution. Some might be -1, see above for why.
|
|
int m_nRXSpeedNtile5th; // 5% of transmit samples were <= N kb/s
|
|
int m_nRXSpeedNtile50th; // 50% of transmit samples were <= N kb/s
|
|
int m_nRXSpeedNtile75th; // 75% of transmit samples were <= N kb/s
|
|
int m_nRXSpeedNtile95th; // 95% of transmit samples were <= N kb/s
|
|
int m_nRXSpeedNtile98th; // 98% of transmit samples were <= N kb/s
|
|
|
|
};
|
|
|
|
/// Link stats. Pretty much everything you might possibly want to know about the connection
|
|
struct SteamDatagramLinkStats
|
|
{
|
|
|
|
/// Latest instantaneous stats, calculated locally
|
|
SteamDatagramLinkInstantaneousStats m_latest;
|
|
|
|
/// Peak values for each instantaneous stat
|
|
//SteamDatagramLinkInstantaneousStats m_peak;
|
|
|
|
/// Lifetime stats, calculated locally
|
|
SteamDatagramLinkLifetimeStats m_lifetime;
|
|
|
|
/// Latest instantaneous stats received from remote host.
|
|
/// (E.g. "sent" means they are reporting what they sent.)
|
|
SteamDatagramLinkInstantaneousStats m_latestRemote;
|
|
|
|
/// How many seconds ago did we receive m_latestRemote?
|
|
/// This will be <0 if the data is not valid!
|
|
float m_flAgeLatestRemote;
|
|
|
|
/// Latest lifetime stats received from remote host.
|
|
SteamDatagramLinkLifetimeStats m_lifetimeRemote;
|
|
|
|
/// How many seconds ago did we receive the lifetime stats?
|
|
/// This will be <0 if the data is not valid!
|
|
float m_flAgeLifetimeRemote;
|
|
|
|
/// Reset everything to unknown/initial state.
|
|
inline void Clear() { SteamDatagramLinkStats_Clear( this ); }
|
|
};
|
|
|
|
/// Status of a particular network resource
|
|
enum ESteamDatagramAvailability
|
|
{
|
|
k_ESteamDatagramAvailability_CannotTry = -3, // A dependent resource is missing, so this service is unavailable. (E.g. we cannot talk to routers because Internet is down or we don't have the network config.)
|
|
k_ESteamDatagramAvailability_Failed = -2, // We have tried for enough time that we would expect to have been successful by now. We have never been successful
|
|
k_ESteamDatagramAvailability_Previously = -1, // We tried and were successful at one time, but now it looks like we have a problem
|
|
k_ESteamDatagramAvailability_Unknown = 0, // Unknown, or not applicable in this context
|
|
k_ESteamDatagramAvailability_NeverTried = 1, // We don't know because we haven't ever checked
|
|
k_ESteamDatagramAvailability_Attempting = 2, // We're trying now, but are not yet successful. This is not an error, but it's not success, either.
|
|
k_ESteamDatagramAvailability_Current = 3, // Resource is online.
|
|
};
|
|
|
|
/// Describe detailed state of current connection
|
|
struct SteamNetworkingDetailedConnectionStatus
|
|
{
|
|
/// Basic connection info
|
|
SteamNetConnectionInfo_t m_info;
|
|
|
|
/// Do we have a valid network configuration? We cannot do anything without this.
|
|
ESteamDatagramAvailability m_eAvailNetworkConfig;
|
|
|
|
// /// Does it look like we have a connection to the Internet at all?
|
|
// EAvailability m_eAvailInternet;
|
|
|
|
/// Successful communication with a box on the routing network.
|
|
/// This will be marked as failed if there is a general internet
|
|
/// connection.
|
|
ESteamDatagramAvailability m_eAvailAnyRouterCommunication;
|
|
|
|
/// End-to-end communication with the remote host.
|
|
//ESteamDatagramAvailability m_eAvailEndToEnd;
|
|
|
|
/// Stats for end-to-end link to the gameserver
|
|
SteamDatagramLinkStats m_statsEndToEnd;
|
|
|
|
/// Currently selected front router, if any.
|
|
/// Note that PoP ID can be found in the SteamNetConnectionInfo_t
|
|
char m_szPrimaryRouterName[64];
|
|
uint32 m_unPrimaryRouterIP;
|
|
uint16 m_unPrimaryRouterPort;
|
|
|
|
/// Stats for "front" link to current router
|
|
SteamDatagramLinkStats m_statsPrimaryRouter;
|
|
|
|
/// Back ping time as reported by primary.
|
|
/// (The front ping is in m_statsPrimaryRouter,
|
|
/// and usually the front ping plus the back ping should
|
|
/// approximately equal the end-to-end ping)
|
|
int m_nPrimaryRouterBackPing;
|
|
|
|
/// Currently selected back router, if any
|
|
SteamNetworkingPOPID m_idBackupRouterCluster;
|
|
char m_szBackupRouterName[64];
|
|
uint32 m_unBackupRouterIP;
|
|
uint16 m_unBackupRouterPort;
|
|
|
|
/// Ping times to backup router, if any
|
|
int m_nBackupRouterFrontPing, m_nBackupRouterBackPing;
|
|
|
|
/// Clear everything to an unknown state
|
|
inline void Clear() { SteamNetworkingDetailedConnectionStatus_Clear( this ); }
|
|
|
|
/// Print into a buffer.
|
|
/// 0 = OK
|
|
/// >1 = buffer was null or too small (in which case truncation happened).
|
|
/// Pass a buffer of at least N bytes.
|
|
inline int Print( char *pszBuf, int cbBuf ) const { return SteamNetworkingDetailedConnectionStatus_Print( this, pszBuf, cbBuf ); }
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
#endif // STEAMDATAGRAM_STATS_H
|