You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
298 lines
12 KiB
298 lines
12 KiB
//====== 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
|
|
|