feat: snapshot. Adding RTT computation API.

com.unity.multiplayer.mlapi/Runtime/Core/SnapshotRTT.cs

@@ -0,0 +1,96 @@
+using System;
+using UnityEngine;
+
+namespace MLAPI
+{
+    internal class ConnectionRtt
+    {
+        internal const int RttSize = 5; // number of RTT to keep an average of (plus one)
+        internal const int RingSize = 64; // number of slots to use for RTT computations (max number of in-flight packets)
+
+        private double[] m_RttSendTimes; // times at which packet were sent for RTT computations
+        private int[] m_SendSequence; // tick, or other key, at which packets were sent (to allow matching)
+        private double[] m_MeasuredLatencies; // measured latencies (ring buffer)
+        private int m_LatenciesBegin = 0; // ring buffer begin
+        private int m_LatenciesEnd = 0; // ring buffer end
+
+        /// <summary>
+        /// Round-trip-time data
+        /// </summary>
+        public struct Rtt
+        {
+            public double BestSec; // best RTT
+            public double AverageSec; // average RTT
+            public double WorstSec; // worst RTT
+            public double LastSec; // latest ack'ed RTT
+            public int SampleCount; // number of contributing samples
+        }
+        public ConnectionRtt()
+        {
+            m_RttSendTimes = new double[RingSize];
+            m_SendSequence = new int[RingSize];
+            m_MeasuredLatencies = new double[RingSize];
+        }
+
+        /// <summary>
+        /// Returns the Round-trip-time computation for this client
+        /// </summary>
+        public Rtt GetRtt()
+        {
+            var ret = new Rtt(); // is this a memory alloc ? How do I get a stack alloc ?
+            var index = m_LatenciesBegin;
+            double total = 0.0;
+            ret.BestSec = m_MeasuredLatencies[m_LatenciesBegin];
+            ret.WorstSec = m_MeasuredLatencies[m_LatenciesBegin];
+
+            while (index != m_LatenciesEnd)
+            {
+                total += m_MeasuredLatencies[index];
+                ret.SampleCount++;
+                ret.BestSec = Math.Min(ret.BestSec, m_MeasuredLatencies[index]);
+                ret.WorstSec = Math.Max(ret.WorstSec, m_MeasuredLatencies[index]);
+                index = (index + 1) % RttSize;
+            }
+
+            if (ret.SampleCount != 0)
+            {
+                ret.AverageSec = total / ret.SampleCount;
+                // the latest RTT is one before m_LatenciesEnd
+                ret.LastSec = m_MeasuredLatencies[(m_LatenciesEnd + (RingSize - 1)) % RingSize];
+            }
+            else
+            {
+                ret.AverageSec = 0;
+                ret.BestSec = 0;
+                ret.WorstSec = 0;
+                ret.SampleCount = 0;
+                ret.LastSec = 0;
+            }
+
+            return ret;
+        }
+
+        internal void NotifySend(int sequence, double timeSec)
+        {
+            m_RttSendTimes[sequence % RingSize] = timeSec;
+            m_SendSequence[sequence % RingSize] = sequence;
+        }
+
+        internal void NotifyAck(int sequence, double timeSec)
+        {
+            // if the same slot was not used by a later send
+            if (m_SendSequence[sequence % RingSize] == sequence)
+            {
+                double latency = timeSec - m_RttSendTimes[sequence % RingSize];
+
+                m_MeasuredLatencies[m_LatenciesEnd] = latency;
+                m_LatenciesEnd = (m_LatenciesEnd + 1) % RttSize;
+
+                if (m_LatenciesEnd == m_LatenciesBegin)
+                {
+                    m_LatenciesBegin = (m_LatenciesBegin + 1) % RttSize;
+                }
+            }
+        }
+    }
+}

com.unity.multiplayer.mlapi/Runtime/Core/SnapshotSystem.cs

@@ -2,13 +2,11 @@
 using System.Collections.Generic;
 using System.IO;
 using MLAPI.Configuration;
-using MLAPI.Messaging;
 using MLAPI.NetworkVariable;
 using MLAPI.Serialization;
 using MLAPI.Serialization.Pooled;
 using MLAPI.Transports;
 using UnityEngine;
-using UnityEngine.UIElements;
 
 namespace MLAPI
 {
@@ -275,9 +273,20 @@ public class SnapshotSystem : INetworkUpdateSystem, IDisposable
         private NetworkManager m_NetworkManager = NetworkManager.Singleton;
         private Snapshot m_Snapshot = new Snapshot(NetworkManager.Singleton, false);
         private Dictionary<ulong, Snapshot> m_ClientReceivedSnapshot = new Dictionary<ulong, Snapshot>();
+        private Dictionary<ulong, ConnectionRtt> m_ClientRtts = new Dictionary<ulong, ConnectionRtt>();
 
         private ushort m_CurrentTick = 0;
 
+        internal ConnectionRtt GetConnectionRtt(ulong clientId)
+        {
+            if (!m_ClientRtts.ContainsKey(clientId))
+            {
+                m_ClientRtts.Add(clientId, new ConnectionRtt());
+            }
+
+            return m_ClientRtts[clientId];
+        }
+
         /// <summary>
         /// Constructor
         /// </summary>

com.unity.multiplayer.mlapi/Tests/Editor/SnapshotRttTests.cs

@@ -0,0 +1,75 @@
+using MLAPI;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace MLAPI.EditorTests
+{
+    public class SnapshotRttTests
+    {
+        private const double k_Epsilon = 0.0001;
+
+        [Test]
+        public void TestBasicRtt()
+        {
+            var snapshot = new SnapshotSystem();
+            var client1 = snapshot.GetConnectionRtt(0);
+
+            client1.NotifySend(0, 0.0);
+            client1.NotifySend(1, 10.0);
+
+            client1.NotifyAck(1, 15.0);
+
+            client1.NotifySend(2, 20.0);
+            client1.NotifySend(3, 30.0);
+            client1.NotifySend(4, 32.0);
+
+            client1.NotifyAck(4, 38.0);
+            client1.NotifyAck(3, 40.0);
+
+            ConnectionRtt.Rtt ret = client1.GetRtt();
+            Assert.True(ret.AverageSec < 7.0 + k_Epsilon);
+            Assert.True(ret.AverageSec > 7.0 - k_Epsilon);
+            Assert.True(ret.WorstSec < 10.0 + k_Epsilon);
+            Assert.True(ret.WorstSec > 10.0 - k_Epsilon);
+            Assert.True(ret.BestSec < 5.0 + k_Epsilon);
+            Assert.True(ret.BestSec > 5.0 - k_Epsilon);
+
+            // note: `last` latency is latest received Ack, not latest sent sequence.
+            Assert.True(ret.LastSec < 10.0 + k_Epsilon);
+            Assert.True(ret.LastSec > 10.0 - k_Epsilon);
+        }
+
+        [Test]
+        public void TestEdgeCasesRtt()
+        {
+            var snapshot = new SnapshotSystem();
+            var client1 = snapshot.GetConnectionRtt(0);
+            var iterationCount = ConnectionRtt.RingSize * 3;
+            var extraCount = ConnectionRtt.RingSize * 2;
+
+            // feed in some messages
+            for (var iteration = 0; iteration < iterationCount; iteration++)
+            {
+                client1.NotifySend(iteration, 25.0 * iteration);
+            }
+            // ack some random ones in there (1 out of each 9), always 7.0 later
+            for (var iteration = 0; iteration < iterationCount; iteration += 9)
+            {
+                client1.NotifyAck(iteration, 25.0 * iteration + 7.0);
+            }
+            // ack some unused key, to check it doesn't throw off the values
+            for (var iteration = iterationCount; iteration < iterationCount + extraCount; iteration++)
+            {
+                client1.NotifyAck(iteration, 42.0);
+            }
+
+            ConnectionRtt.Rtt ret = client1.GetRtt();
+            Assert.True(ret.AverageSec < 7.0 + k_Epsilon);
+            Assert.True(ret.AverageSec > 7.0 - k_Epsilon);
+            Assert.True(ret.WorstSec < 7.0 + k_Epsilon);
+            Assert.True(ret.WorstSec > 7.0 - k_Epsilon);
+            Assert.True(ret.BestSec < 7.0 + k_Epsilon);
+            Assert.True(ret.BestSec > 7.0 - k_Epsilon);
+        }
+    }
+}