Made the library much reactive to network health changes.

Refactored the way the library keeps the server input frame buffer count
as smaller as possible depending on the net conditions.
Now it uses proper statistics from the NetworkInterface, instead to
guess it based on the missing inputs.

Exposes new API to get the peer:
- latency jitter
- packet loss

Author: AndreaCatania

core/net_utilities.h

@@ -46,6 +46,13 @@
 
 NS_NAMESPACE_BEGIN
 
+namespace MathFunc {
+template <typename F>
+F lerp(F a, F b, F alpha) {
+	return a + alpha * (b - a);
+}
+} //namespace MathFunc
+
 namespace MapFunc {
 
 template <class K, class V>
@@ -254,174 +261,6 @@ struct ListenerHandle {
 };
 inline static const ListenerHandle nulllistenerhandle = { 0 };
 
-template <class T>
-class StatisticalRingBuffer {
-	LocalVector<T> data;
-	uint32_t index = 0;
-
-	T avg_sum = 0;
-
-public:
-	StatisticalRingBuffer(uint32_t p_size, T p_default);
-	void resize(uint32_t p_size, T p_default);
-	void reset(T p_default);
-
-	void push(T p_value);
-
-	/// Maximum value.
-	T max() const;
-
-	/// Minumum value.
-	T min(uint32_t p_consider_last = UINT32_MAX) const;
-
-	/// Median value.
-	T average() const;
-	T average_rounded() const;
-
-	T get_deviation(T p_mean) const;
-
-private:
-	// Used to avoid accumulate precision loss.
-	void force_recompute_avg_sum();
-};
-
-template <class T>
-StatisticalRingBuffer<T>::StatisticalRingBuffer(uint32_t p_size, T p_default) {
-	resize(p_size, p_default);
-}
-
-template <class T>
-void StatisticalRingBuffer<T>::resize(uint32_t p_size, T p_default) {
-	data.resize(p_size);
-
-	reset(p_default);
-}
-
-template <class T>
-void StatisticalRingBuffer<T>::reset(T p_default) {
-	for (uint32_t i = 0; i < data.size(); i += 1) {
-		data[i] = p_default;
-	}
-
-	index = 0;
-	force_recompute_avg_sum();
-}
-
-template <class T>
-void StatisticalRingBuffer<T>::push(T p_value) {
-	avg_sum -= data[index];
-	avg_sum += p_value;
-	data[index] = p_value;
-
-	index = (index + 1) % data.size();
-	if (index == 0) {
-		// Each cycle recompute the sum.
-		force_recompute_avg_sum();
-	}
-}
-
-template <class T>
-T StatisticalRingBuffer<T>::max() const {
-	CRASH_COND(data.size() == 0);
-
-	T a = data[0];
-	for (uint32_t i = 1; i < data.size(); i += 1) {
-		a = MAX(a, data[i]);
-	}
-	return a;
-}
-
-template <class T>
-T StatisticalRingBuffer<T>::min(uint32_t p_consider_last) const {
-	CRASH_COND(data.size() == 0);
-	p_consider_last = MIN(p_consider_last, data.size());
-
-	const uint32_t youngest = (index == 0 ? data.size() : index) - 1;
-	const uint32_t oldest = (index + (data.size() - p_consider_last)) % data.size();
-
-	T a = data[oldest];
-
-	uint32_t i = oldest;
-	do {
-		i = (i + 1) % data.size();
-		a = MIN(a, data[i]);
-	} while (i != youngest);
-
-	return a;
-}
-
-template <class T>
-T StatisticalRingBuffer<T>::average() const {
-	CRASH_COND(data.size() == 0);
-
-#ifdef DEBUG_ENABLED
-	T a = data[0];
-	for (uint32_t i = 1; i < data.size(); i += 1) {
-		a += data[i];
-	}
-	a = a / T(data.size());
-	T b = avg_sum / T(data.size());
-	const T difference = a > b ? a - b : b - a;
-	ERR_FAIL_COND_V_MSG(difference > (std::numeric_limits<T>::epsilon() * 4.0), b, "The `avg_sum` accumulated a sensible precision loss: " + rtos(difference));
-	return b;
-#else
-	// Divide it by the buffer size is wrong when the buffer is not yet fully
-	// initialized. However, this is wrong just for the first run.
-	// I'm leaving it as is because solve it mean do more operations. All this
-	// just to get the right value for the first few frames.
-	return avg_sum / T(data.size());
-#endif
-}
-
-template <class T>
-T StatisticalRingBuffer<T>::average_rounded() const {
-	CRASH_COND(data.size() == 0);
-
-#ifdef DEBUG_ENABLED
-	T a = data[0];
-	for (uint32_t i = 1; i < data.size(); i += 1) {
-		a += data[i];
-	}
-	a = round(double(a) / double(data.size()));
-	T b = round(double(avg_sum) / double(data.size()));
-	const T difference = a > b ? a - b : b - a;
-	ERR_FAIL_COND_V_MSG(difference > (std::numeric_limits<T>::epsilon() * 4.0), b, "The `avg_sum` accumulated a sensible precision loss: " + rtos(difference));
-	return b;
-#else
-	// Divide it by the buffer size is wrong when the buffer is not yet fully
-	// initialized. However, this is wrong just for the first run.
-	// I'm leaving it as is because solve it mean do more operations. All this
-	// just to get the right value for the first few frames.
-	return round(double(avg_sum) / double(data.size()));
-#endif
-}
-
-template <class T>
-T StatisticalRingBuffer<T>::get_deviation(T p_mean) const {
-	if (data.size() <= 0) {
-		return T();
-	}
-
-	double r = 0;
-	for (uint32_t i = 0; i < data.size(); i += 1) {
-		r += pow(double(data[i]) - double(p_mean), 2.0);
-	}
-
-	return sqrt(r / double(data.size()));
-}
-
-template <class T>
-void StatisticalRingBuffer<T>::force_recompute_avg_sum() {
-#ifdef DEBUG_ENABLED
-	// This class is not supposed to be used with 0 size.
-	CRASH_COND(data.size() <= 0);
-#endif
-	avg_sum = data[0];
-	for (uint32_t i = 1; i < data.size(); i += 1) {
-		avg_sum += data[i];
-	}
-}
-
 // These data are used by the server and are never synchronized.
 struct PeerAuthorityData {
 	// Used to know if the peer is enabled.
@@ -451,7 +290,7 @@ struct PeerData {
 	///   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;
+	float latency_jitter_ms = 0.0;
 
 public:
 	// In ms
@@ -463,11 +302,11 @@ struct PeerData {
 	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; }
+	void set_out_packet_loss_percentage(float p_packet_loss) { out_packet_loss_percentage = std::clamp(p_packet_loss, 0.0f, 1.0f); }
 	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 set_latency_jitter_ms(float p_jitter_ms) { latency_jitter_ms = p_jitter_ms; }
+	float get_latency_jitter_ms() const { return latency_jitter_ms; }
 
 	void make_controller();
 	PeerNetworkedController *get_controller() {
@@ -485,8 +324,11 @@ struct PeerServerData {
 	// For new peers a full snapshot is needed.
 	bool need_full_snapshot = true;
 
-	// How much time (seconds) from the latest net_stats update.
-	float netstats_update_sec = 0.0;
+	// How much time (seconds) from the latest latency update sent via snapshot.
+	float latency_update_via_snapshot_sec = 0.0;
+
+	// How much time (seconds) from the latest update sent to the client.
+	float netstats_peer_update_sec = 0.0;
 };
 
 struct SyncGroup {

core/peer_networked_controller.cpp

@@ -123,30 +123,6 @@ int PeerNetworkedController::get_max_redundant_inputs() const {
 	return max_redundant_inputs;
 }
 
-void PeerNetworkedController::set_network_traced_frames(int p_size) {
-	network_traced_frames = p_size;
-}
-
-int PeerNetworkedController::get_network_traced_frames() const {
-	return network_traced_frames;
-}
-
-void PeerNetworkedController::set_min_frames_delay(int p_val) {
-	min_frames_delay = p_val;
-}
-
-int PeerNetworkedController::get_min_frames_delay() const {
-	return min_frames_delay;
-}
-
-void PeerNetworkedController::set_max_frames_delay(int p_val) {
-	max_frames_delay = p_val;
-}
-
-int PeerNetworkedController::get_max_frames_delay() const {
-	return max_frames_delay;
-}
-
 FrameIndex PeerNetworkedController::get_current_frame_index() const {
 	ENSURE_V(controller, FrameIndex::NONE);
 	return controller->get_current_frame_index();
@@ -747,11 +723,8 @@ bool RemotelyControlledController::receive_inputs(const Vector<uint8_t> &p_data)
 }
 
 ServerController::ServerController(
-		PeerNetworkedController *p_peer_controller,
-		int p_traced_frames) :
-		RemotelyControlledController(p_peer_controller),
-		network_watcher(p_traced_frames, 0),
-		consecutive_input_watcher(p_traced_frames, 0) {
+		PeerNetworkedController *p_peer_controller) :
+		RemotelyControlledController(p_peer_controller) {
 }
 
 void ServerController::process(double p_delta) {
@@ -765,7 +738,6 @@ void ServerController::process(double p_delta) {
 				consecutive_inputs += 1;
 			}
 		}
-		consecutive_input_watcher.push(consecutive_inputs);
 	}
 }
 
@@ -777,35 +749,10 @@ void ServerController::on_peer_update(bool p_peer_enabled) {
 
 	// ~~ Reset everything to avoid accumulate old data. ~~
 	RemotelyControlledController::on_peer_update(p_peer_enabled);
-
-	additional_fps_notif_timer = 0.0;
-	previous_frame_received_timestamp = UINT32_MAX;
-	network_watcher.reset(0.0);
-	consecutive_input_watcher.reset(0.0);
 }
 
 void ServerController::set_frame_input(const FrameInput &p_frame_snapshot, bool p_first_input) {
-	// If `previous_frame_received_timestamp` is bigger: the controller was
-	// disabled, so nothing to do.
-	if (previous_frame_received_timestamp < p_frame_snapshot.received_timestamp) {
-		const uint32_t frame_delta_ms = peer_controller->scene_synchronizer->get_fixed_frame_delta() * 1000.0;
-
-		const uint32_t receival_time = p_frame_snapshot.received_timestamp - previous_frame_received_timestamp;
-		const uint32_t network_time = receival_time > frame_delta_ms ? receival_time - frame_delta_ms : 0;
-
-		network_watcher.push(network_time);
-	}
-
 	RemotelyControlledController::set_frame_input(p_frame_snapshot, p_first_input);
-
-	if (p_first_input) {
-		// Reset the watcher, as this is the first input.
-		network_watcher.reset(0);
-		consecutive_input_watcher.reset(0.0);
-		previous_frame_received_timestamp = UINT32_MAX;
-	} else {
-		previous_frame_received_timestamp = p_frame_snapshot.received_timestamp;
-	}
 }
 
 void ServerController::notify_send_state() {
@@ -840,50 +787,9 @@ int ceil_with_tolerance(double p_value, double p_tolerance) {
 	return std::ceil(p_value - p_tolerance);
 }
 
-std::int8_t ServerController::compute_client_tick_rate_distance_to_optimal() {
-	const float min_frames_delay = peer_controller->get_min_frames_delay();
-	const float max_frames_delay = peer_controller->get_max_frames_delay();
-	const double fixed_frame_delta = peer_controller->scene_synchronizer->get_fixed_frame_delta();
-
-	// `worst_receival_time` is in ms and indicates the maximum time passed to receive a consecutive
-	// input in the last `network_traced_frames` frames.
-	const std::uint32_t worst_receival_time_ms = network_watcher.max();
-
-	const double worst_receival_time = double(worst_receival_time_ms) / 1000.0;
-
-	const int optimal_frame_delay_unclamped = ceil_with_tolerance(
-			worst_receival_time / fixed_frame_delta,
-			fixed_frame_delta * 0.05); // Tolerance of 5% of frame time.
-
-	const int optimal_frame_delay = CLAMP(optimal_frame_delay_unclamped, min_frames_delay, max_frames_delay);
-
-	const int consecutive_inputs = consecutive_input_watcher.average_rounded();
-
-	const std::int8_t distance_to_optimal = CLAMP(optimal_frame_delay - consecutive_inputs, INT8_MIN, INT8_MAX);
-
-#ifdef DEBUG_ENABLED
-	const bool debug = ProjectSettings::get_singleton()->get_setting("NetworkSynchronizer/debug_server_speedup");
-	const int current_frame_delay = consecutive_inputs;
-	if (debug) {
-		SceneSynchronizerDebugger::singleton()->print(
-				INFO,
-				"Worst receival time (ms): `" + std::to_string(worst_receival_time_ms) +
-						"` Optimal frame delay: `" + std::to_string(optimal_frame_delay) +
-						"` Current frame delay: `" + std::to_string(current_frame_delay) +
-						"` Distance to optimal: `" + std::to_string(distance_to_optimal) +
-						"`",
-				"NetController",
-				true);
-	}
-	peer_controller->event_client_speedup_adjusted.broadcast(worst_receival_time_ms, optimal_frame_delay, current_frame_delay, distance_to_optimal);
-#endif
-
-	return distance_to_optimal;
-}
-
 AutonomousServerController::AutonomousServerController(
 		PeerNetworkedController *p_peer_controller) :
-		ServerController(p_peer_controller, 1) {
+		ServerController(p_peer_controller) {
 }
 
 bool AutonomousServerController::receive_inputs(const Vector<uint8_t> &p_data) {
@@ -1403,7 +1309,7 @@ int DollController::fetch_optimal_queued_inputs() const {
 	//
 	// TODO: At the moment this value is fixed to the min_frame_delay, but at some
 	// point we will want to change this value dynamically depending on packet loss.
-	return peer_controller->get_min_frames_delay();
+	return peer_controller->scene_synchronizer->get_min_server_input_buffer_size();
 }
 
 bool DollController::fetch_next_input(double p_delta) {