Refactored the way the ping (rtt) is taken to read it from ENet.

Author: AndreaCatania

core/net_utilities.cpp

@@ -8,12 +8,12 @@
 #include <limits>
 #include <memory>
 
-void NS::PeerData::set_latency(int p_latency) {
-	compressed_latency = std::round(float(std::clamp(p_latency, 0, 1000)) / 4.0);
+void NS::PeerData::set_latency(float p_latency) {
+	compressed_latency = std::round(std::clamp(p_latency, 0.f, 1000.0f) / 4.0);
 }
 
-int NS::PeerData::get_latency() const {
-	return int(compressed_latency) * 4;
+float NS::PeerData::get_latency() const {
+	return compressed_latency * 4.0;
 }
 
 void NS::PeerData::make_controller() {

core/net_utilities.h

@@ -438,18 +438,37 @@ struct PeerData {
 	PeerAuthorityData authority_data;
 
 private:
+	/// Get latency (ping): The round trip time a packet takes to go and return back.
 	std::uint8_t compressed_latency = 0;
 
+	/// Get OUT packetloss in %
+	float out_packet_loss_percentage = 0.0;
+
+	/// Current jitter for this connection in milliseconds.
+	/// Jitter represents the average time divergence of all sent packets.
+	/// Ex:
+	/// - If the time between the sending and the reception of packets is always
+	///   100ms; the jitter will be 0.
+	/// - If the time difference is either 150ms or 100ms, the jitter will tend
+	///   towards 50ms.
+	float average_jitter_in_ms = 0.0;
+
 public:
 	// In ms
-	void set_latency(int p_ping);
+	void set_latency(float p_ping);
 
 	// In ms
-	int get_latency() const;
+	float get_latency() const;
 
 	void set_compressed_latency(std::uint8_t p_compressed_latency) { compressed_latency = p_compressed_latency; }
 	std::uint8_t get_compressed_latency() const { return compressed_latency; }
 
+	void set_out_packet_loss_percentage(float p_packet_loss) { out_packet_loss_percentage = p_packet_loss; }
+	float get_out_packet_loss_percentage() const { return out_packet_loss_percentage; }
+
+	void set_average_jitter_in_ms(float p_jitter_ms) { average_jitter_in_ms = p_jitter_ms; }
+	float get_average_jitter_in_ms() const { return average_jitter_in_ms; }
+
 	void make_controller();
 	PeerNetworkedController *get_controller() {
 		return controller.get();
@@ -466,9 +485,8 @@ struct PeerServerData {
 	// For new peers a full snapshot is needed.
 	bool need_full_snapshot = true;
 
-	// The latency, in ms, between this peer and the server.
-	std::chrono::high_resolution_clock::time_point latency_ping_timestamp;
-	bool latency_calculation_in_progress = false;
+	// How much time (seconds) from the latest net_stats update.
+	float netstats_update_sec = 0.0;
 };
 
 struct SyncGroup {

core/network_interface.h

@@ -2,6 +2,7 @@
 
 #include "core.h"
 #include "ensure.h"
+#include "net_utilities.h"
 #include "network_codec.h"
 #include <functional>
 #include <string>
@@ -46,7 +47,7 @@ class NetworkInterface {
 public:
 	virtual ~NetworkInterface() = default;
 
-public: // ---------------------------------------------------------------- APIs
+public: // ----------------------------------------------------------- Interface
 	virtual void clear() {
 		rpcs_info.clear();
 		rpc_last_sender = 0;
@@ -78,6 +79,12 @@ class NetworkInterface {
 	/// Can be used to verify if the local peer is the server.
 	virtual bool is_local_peer_server() const = 0;
 
+	/// This function is called by the `SceneSynchronizer` to update
+	/// the network `stats` for the given peer.
+	/// NOTE: This function is called only on the server.
+	virtual void server_update_net_stats(int p_peer, PeerData &r_peer_data) const = 0;
+
+public: // ---------------------------------------------------------------- APIs
 	/// Can be used to verify if the local peer is the authority of this unit.
 	virtual bool is_local_peer_authority_of_this_unit() const {
 		return get_unit_authority() == fetch_local_peer_id();

godot4/gd_network_interface.cpp

@@ -297,3 +297,42 @@ void GdNetworkInterface::gd_rpc_receive(const Vector<uint8_t> &p_buffer) {
 			owner->get_multiplayer()->get_remote_sender_id(),
 			db);
 }
+
+// Copied from `enet_packet_peer.h` to avoid including it, which is complex due to its dependency with enet.
+enum PeerStatistic {
+	PEER_PACKET_LOSS,
+	PEER_PACKET_LOSS_VARIANCE,
+	PEER_PACKET_LOSS_EPOCH,
+	PEER_ROUND_TRIP_TIME,
+	PEER_ROUND_TRIP_TIME_VARIANCE,
+	PEER_LAST_ROUND_TRIP_TIME,
+	PEER_LAST_ROUND_TRIP_TIME_VARIANCE,
+	PEER_PACKET_THROTTLE,
+	PEER_PACKET_THROTTLE_LIMIT,
+	PEER_PACKET_THROTTLE_COUNTER,
+	PEER_PACKET_THROTTLE_EPOCH,
+	PEER_PACKET_THROTTLE_ACCELERATION,
+	PEER_PACKET_THROTTLE_DECELERATION,
+	PEER_PACKET_THROTTLE_INTERVAL,
+};
+
+// Copied from enet.h to avoid including it.
+uint64_t ENET_PEER_PACKET_LOSS_SCALE = (1 << 16);
+
+void GdNetworkInterface::server_update_net_stats(int p_peer, NS::PeerData &r_peer_data) const {
+	// This function is always called on the server.
+	ASSERT_COND(is_local_peer_server());
+
+	ERR_FAIL_COND(!owner);
+	ERR_FAIL_COND(!owner->get_multiplayer().is_valid());
+	ERR_FAIL_COND(!owner->get_multiplayer()->get_multiplayer_peer().is_valid());
+
+	Ref<MultiplayerPeer> packet_peer = owner->get_multiplayer()->get_multiplayer_peer();
+	Ref<PacketPeer> enet_peer = packet_peer->call("get_peer", p_peer);
+	ERR_FAIL_COND(!enet_peer.is_valid());
+
+	// Using the GDScript bindings to read these so to avoid including `enet_packet_peer.h`, which is complex due to its dependency with enet.
+	r_peer_data.set_latency(enet_peer->call("get_statistic", PEER_ROUND_TRIP_TIME));
+	r_peer_data.set_out_packet_loss_percentage(double(enet_peer->call("get_statistic", PEER_PACKET_LOSS)) / double(ENET_PEER_PACKET_LOSS_SCALE));
+	r_peer_data.set_average_jitter_in_ms(enet_peer->call("get_statistic", PEER_ROUND_TRIP_TIME_VARIANCE));
+}

godot4/gd_network_interface.h

@@ -56,6 +56,8 @@ class GdNetworkInterface final : public NS::NetworkInterface,
 
 	virtual void rpc_send(int p_peer_recipient, bool p_reliable, DataBuffer &&p_buffer) override;
 	void gd_rpc_receive(const Vector<uint8_t> &p_args);
+
+	virtual void server_update_net_stats(int p_peer, NS::PeerData &r_peer_data) const override;
 };
 
 namespace NS_GD_Test {

scene_synchronizer.cpp

@@ -12,7 +12,6 @@
 #include "core/snapshot.h"
 #include "core/var_data.h"
 #include "data_buffer.h"
-#include <chrono>
 #include <limits>
 #include <string>
 #include <vector>
@@ -67,12 +66,6 @@ void SceneSynchronizerBase::setup(SynchronizerManager &p_synchronizer_interface)
 			[this](int p_peer) { on_peer_connected(p_peer); },
 			[this](int p_peer) { on_peer_disconnected(p_peer); });
 
-	rpc_handler_latency =
-			network_interface->rpc_config(
-					std::function<void()>(std::bind(&SceneSynchronizerBase::rpc_latency, this)),
-					true,
-					false);
-
 	rpc_handler_state =
 			network_interface->rpc_config(
 					std::function<void(DataBuffer &)>(std::bind(&SceneSynchronizerBase::rpc_receive_state, this, std::placeholders::_1)),
@@ -1092,18 +1085,6 @@ void SceneSynchronizerBase::notify_controller_control_mode_changed(PeerNetworked
 	}
 }
 
-void SceneSynchronizerBase::rpc_latency() {
-	if (is_client()) {
-		// This is a client, latency the server back.
-		rpc_handler_latency.rpc(get_network_interface(), get_network_interface().get_server_peer());
-	} else if (is_server()) {
-		const int sender_peer = get_network_interface().rpc_get_sender();
-		static_cast<ServerSynchronizer *>(synchronizer)->notify_latency_received(sender_peer);
-	} else {
-		ENSURE_MSG(false, "[FATAL] The rpc latency function was executed on a peer that is not a client nor a server. This is a bug.");
-	}
-}
-
 void SceneSynchronizerBase::rpc_receive_state(DataBuffer &p_snapshot) {
 	ENSURE_MSG(is_client(), "Only clients are suposed to receive the server snapshot.");
 	static_cast<ClientSynchronizer *>(synchronizer)->receive_snapshot(p_snapshot);
@@ -1732,7 +1713,7 @@ void ServerSynchronizer::process(double p_delta) {
 	}
 
 	process_trickled_sync(p_delta);
-	process_latency_update();
+	update_peers_net_statistics(p_delta);
 	process_adjust_clients_controller_tick_rate(p_delta);
 
 	SceneSynchronizerDebugger::singleton()->scene_sync_process_end(scene_synchronizer);
@@ -2368,46 +2349,29 @@ void ServerSynchronizer::process_trickled_sync(double p_delta) {
 	memdelete(tmp_buffer);
 }
 
-void ServerSynchronizer::process_latency_update() {
-	const std::chrono::high_resolution_clock::time_point now = std::chrono::high_resolution_clock::now();
-
+void ServerSynchronizer::update_peers_net_statistics(double p_delta) {
 	for (auto &[peer, peer_data] : scene_synchronizer->get_peers()) {
 		if (peer == scene_synchronizer->get_network_interface().fetch_local_peer_id()) {
 			// No need to update the ping for `self` (the server).
 			continue;
 		}
 
 		std::map<int, PeerServerData>::iterator peer_server_data_it = NS::MapFunc::insert_if_new(peers_data, peer, PeerServerData());
-		if (peer_server_data_it->second.latency_calculation_in_progress) {
+		peer_server_data_it->second.netstats_update_sec += p_delta;
+
+		if make_likely (peer_server_data_it->second.netstats_update_sec < scene_synchronizer->latency_update_rate) {
 			continue;
 		}
-		const auto interval = std::chrono::duration_cast<std::chrono::milliseconds>(now - peer_server_data_it->second.latency_ping_timestamp);
-		if (interval.count() >= (scene_synchronizer->latency_update_rate * 1000.0)) {
-			scene_synchronizer->rpc_handler_latency.rpc(
-					scene_synchronizer->get_network_interface(),
-					peer);
-			peer_server_data_it->second.latency_ping_timestamp = now;
-			peer_server_data_it->second.latency_calculation_in_progress = true;
-		}
-	}
-}
 
-void ServerSynchronizer::notify_latency_received(int p_peer) {
-	const std::chrono::high_resolution_clock::time_point now = std::chrono::high_resolution_clock::now();
-
-	std::map<int, PeerData>::iterator pd_it = NS::MapFunc::insert_if_new(scene_synchronizer->peer_data, p_peer, PeerData());
-	std::map<int, PeerServerData>::iterator psd_it = NS::MapFunc::insert_if_new(peers_data, p_peer, PeerServerData());
-
-	const auto rtt_interval = std::chrono::duration_cast<std::chrono::milliseconds>(now - psd_it->second.latency_ping_timestamp);
-	// Clamlatency to 1k as 1k ms latency is way too high to matter anyway.
-	const std::uint64_t rtt = rtt_interval.count();
-	pd_it->second.set_latency(rtt);
-	psd_it->second.latency_calculation_in_progress = false;
-	psd_it->second.latency_ping_timestamp = now;
+		// Time to update the network stats for this peer.
+		scene_synchronizer->get_network_interface().server_update_net_stats(peer, peer_data);
+		// Notify all sync groups about this peer having newly calculated latency.
+		for (auto &group : sync_groups) {
+			group.notify_peer_has_newly_calculated_latency(peer);
+		}
 
-	// Notify all sync groups about this peer having newly calculated latency.
-	for (auto &group : sync_groups) {
-		group.notify_peer_has_newly_calculated_latency(p_peer);
+		// Reset the timer.
+		peer_server_data_it->second.netstats_update_sec = 0.0;
 	}
 }
 

scene_synchronizer.h

@@ -162,7 +162,6 @@ class SceneSynchronizerBase {
 	class NetworkInterface *network_interface = nullptr;
 	SynchronizerManager *synchronizer_manager = nullptr;
 
-	RpcHandle<> rpc_handler_latency;
 	RpcHandle<DataBuffer &> rpc_handler_state;
 	RpcHandle<> rpc_handler_notify_need_full_snapshot;
 	RpcHandle<bool> rpc_handler_set_network_enabled;
@@ -348,7 +347,6 @@ class SceneSynchronizerBase {
 	bool is_variable_registered(ObjectLocalId p_id, const std::string &p_variable) const;
 
 public: // ---------------------------------------------------------------- RPCs
-	void rpc_latency();
 	void rpc_receive_state(DataBuffer &p_snapshot);
 	void rpc__notify_need_full_snapshot();
 	void rpc_set_network_enabled(bool p_enabled);
@@ -672,8 +670,7 @@ class ServerSynchronizer final : public Synchronizer {
 			DataBuffer &r_snapshot_db) const;
 
 	void process_trickled_sync(double p_delta);
-	void process_latency_update();
-	void notify_latency_received(int p_peer);
+	void update_peers_net_statistics(double p_delta);
 
 	/// This function updates the `tick_additional_fps` so that the `frames_inputs`
 	/// size is enough to reduce the missing packets to 0.

tests/local_network.cpp

@@ -195,6 +195,19 @@ void LocalNetworkInterface::rpc_send(int p_peer_recipient, bool p_reliable, Data
 	network->rpc_send(get_owner_name(), p_peer_recipient, p_reliable, std::move(p_data_buffer));
 }
 
+void LocalNetworkInterface::server_update_net_stats(int p_peer, PeerData &r_peer_data) const {
+	if (!network || !network->network_properties) {
+		r_peer_data.set_latency(0);
+		r_peer_data.set_out_packet_loss_percentage(0);
+		r_peer_data.set_average_jitter_in_ms(0);
+	} else {
+		r_peer_data.set_latency(network->network_properties->rtt_seconds * 1000.0);
+		r_peer_data.set_out_packet_loss_percentage(network->network_properties->packet_loss);
+		// There are no statistic about this, assuming 10% of rtt.
+		r_peer_data.set_average_jitter_in_ms(r_peer_data.get_latency() * 0.1);
+	}
+}
+
 NS_NAMESPACE_END
 
 /// Test that the LocalNetwork is able to sync stuff.

tests/local_network.h

@@ -109,6 +109,8 @@ class LocalNetworkInterface final : public NS::NetworkInterface {
 	virtual bool is_local_peer_server() const override;
 
 	virtual void rpc_send(int p_peer_recipient, bool p_reliable, DataBuffer &&p_data_buffer) override;
+
+	virtual void server_update_net_stats(int p_peer, PeerData &r_peer_data) const override;
 };
 
 NS_NAMESPACE_END