perf!: network transform performance improvements (#1283)

* perf checkpoint
* simplified component change check, cleaned up one-tick-behind check

Author: mattwalsh-unity

com.unity.netcode.gameobjects/Components/Interpolator/BufferedLinearInterpolator.cs

@@ -4,62 +4,35 @@
 
 namespace Unity.Netcode
 {
+
     /// <summary>
     /// Solves for incoming values that are jittered
     /// Partially solves for message loss. Unclamped lerping helps hide this, but not completely
     /// </summary>
     /// <typeparam name="T"></typeparam>
     internal abstract class BufferedLinearInterpolator<T> where T : struct
     {
-        // interface for mock testing, abstracting away external systems
-        internal interface IInterpolatorTime
-        {
-            double BufferedServerTime { get; }
-            double BufferedServerFixedTime { get; }
-            uint TickRate { get; }
-        }
-
-        private class InterpolatorTime : IInterpolatorTime
-        {
-            private readonly NetworkManager m_Manager;
-            public InterpolatorTime(NetworkManager manager)
-            {
-                m_Manager = manager;
-            }
-            public double BufferedServerTime => m_Manager.ServerTime.Time;
-            public double BufferedServerFixedTime => m_Manager.ServerTime.FixedTime;
-            public uint TickRate => m_Manager.ServerTime.TickRate;
-        }
-
-        internal IInterpolatorTime InterpolatorTimeProxy;
-
         private struct BufferedItem
         {
             public T Item;
-            public NetworkTime TimeSent;
+            public double TimeSent;
 
-            public BufferedItem(T item, NetworkTime timeSent)
+            public BufferedItem(T item, double timeSent)
             {
                 Item = item;
                 TimeSent = timeSent;
             }
         }
 
-        private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator
 
-        /// <summary>
-        /// Override this if you want configurable buffering, right now using ServerTick's own global buffering
-        /// </summary>
-        private double ServerTimeBeingHandledForBuffering => InterpolatorTimeProxy.BufferedServerTime;
-
-        private double RenderTime => InterpolatorTimeProxy.BufferedServerTime - 1f / InterpolatorTimeProxy.TickRate;
+        private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator
 
         private T m_InterpStartValue;
         private T m_CurrentInterpValue;
         private T m_InterpEndValue;
 
-        private NetworkTime m_EndTimeConsumed;
-        private NetworkTime m_StartTimeConsumed;
+        private double m_EndTimeConsumed;
+        private double m_StartTimeConsumed;
 
         private readonly List<BufferedItem> m_Buffer = new List<BufferedItem>(k_BufferCountLimit);
 
@@ -96,47 +69,44 @@ public BufferedItem(T item, NetworkTime timeSent)
 
         private bool InvalidState => m_Buffer.Count == 0 && m_LifetimeConsumedCount == 0;
 
-        internal BufferedLinearInterpolator(NetworkManager manager)
-        {
-            InterpolatorTimeProxy = new InterpolatorTime(manager);
-        }
-
-        internal BufferedLinearInterpolator(IInterpolatorTime proxy)
-        {
-            InterpolatorTimeProxy = proxy;
-        }
-
-        public void ResetTo(T targetValue)
+        public void ResetTo(T targetValue, double serverTime)
         {
             m_LifetimeConsumedCount = 1;
             m_InterpStartValue = targetValue;
             m_InterpEndValue = targetValue;
             m_CurrentInterpValue = targetValue;
             m_Buffer.Clear();
-            m_EndTimeConsumed = new NetworkTime(InterpolatorTimeProxy.TickRate, 0);
-            m_StartTimeConsumed = new NetworkTime(InterpolatorTimeProxy.TickRate, 0);
+            m_EndTimeConsumed = 0.0d;
+            m_StartTimeConsumed = 0.0d;
 
-            Update(0);
+            Update(0, serverTime, serverTime);
         }
 
 
         // todo if I have value 1, 2, 3 and I'm treating 1 to 3, I shouldn't interpolate between 1 and 3, I should interpolate from 1 to 2, then from 2 to 3 to get the best path
-        private void TryConsumeFromBuffer()
+        private void TryConsumeFromBuffer(double renderTime, double serverTime)
         {
             int consumedCount = 0;
             // only consume if we're ready
-            if (RenderTime >= m_EndTimeConsumed.Time)
+
+            //  this operation was measured as one of our most expensive, and we should put some thought into this.
+            //   NetworkTransform has (currently) 7 buffered linear interpolators (3 position, 3 scale, 1 rot), and
+            //   each has its own independent buffer and 'm_endTimeConsume'.  That means every frame I have to do 7x
+            //   these checks vs. if we tracked these values in a unified way
+            if (renderTime >= m_EndTimeConsumed)
             {
                 BufferedItem? itemToInterpolateTo = null;
                 // assumes we're using sequenced messages for netvar syncing
                 // buffer contains oldest values first, iterating from end to start to remove elements from list while iterating
+
+                // calling m_Buffer.Count shows up hot in the profiler.
                 for (int i = m_Buffer.Count - 1; i >= 0; i--) // todo stretch: consume ahead if we see we're missing values due to packet loss
                 {
                     var bufferedValue = m_Buffer[i];
                     // Consume when ready and interpolate to last value we can consume. This can consume multiple values from the buffer
-                    if (bufferedValue.TimeSent.Time <= ServerTimeBeingHandledForBuffering)
+                    if (bufferedValue.TimeSent <= serverTime)
                     {
-                        if (!itemToInterpolateTo.HasValue || bufferedValue.TimeSent.Time > itemToInterpolateTo.Value.TimeSent.Time)
+                        if (!itemToInterpolateTo.HasValue || bufferedValue.TimeSent > itemToInterpolateTo.Value.TimeSent)
                         {
                             if (m_LifetimeConsumedCount == 0)
                             {
@@ -151,7 +121,7 @@ private void TryConsumeFromBuffer()
                                 m_InterpStartValue = m_InterpEndValue;
                             }
 
-                            if (bufferedValue.TimeSent.Time > m_EndTimeConsumed.Time)
+                            if (bufferedValue.TimeSent > m_EndTimeConsumed)
                             {
                                 itemToInterpolateTo = bufferedValue;
                                 m_EndTimeConsumed = bufferedValue.TimeSent;
@@ -167,9 +137,27 @@ private void TryConsumeFromBuffer()
             }
         }
 
-        public T Update(float deltaTime)
+        /// <summary>
+        /// Convenience version of 'Update' mainly for testing
+        ///  the reason we don't want to always call this version is so that on the calling side we can compute
+        ///  the renderTime once for the many things being interpolated (and the many interpolators per object)
+        /// </summary>
+        /// <param name="deltaTime">time since call</param>
+        /// <param name="serverTime">current server time</param>
+        public T Update(float deltaTime, NetworkTime serverTime)
+        {
+            return Update(deltaTime, serverTime.TimeTicksAgo(1).Time, serverTime.Time);
+        }
+
+        /// <summary>
+        /// Call to update the state of the interpolators before reading out
+        /// </summary>
+        /// <param name="deltaTime">time since last call</param>
+        /// <param name="renderTime">our current time</param>
+        /// <param name="serverTime">current server time</param>
+        public T Update(float deltaTime, double renderTime, double serverTime)
         {
-            TryConsumeFromBuffer();
+            TryConsumeFromBuffer(renderTime, serverTime);
 
             if (InvalidState)
             {
@@ -184,14 +172,14 @@ public T Update(float deltaTime)
             if (m_LifetimeConsumedCount >= 1) // shouldn't interpolate between default values, let's wait to receive data first, should only interpolate between real measurements
             {
                 float t = 1.0f;
-                double range = m_EndTimeConsumed.Time - m_StartTimeConsumed.Time;
+                double range = m_EndTimeConsumed - m_StartTimeConsumed;
                 if (range > k_SmallValue)
                 {
-                    t = (float)((RenderTime - m_StartTimeConsumed.Time) / range);
+                    t = (float)((renderTime - m_StartTimeConsumed) / range);
 
                     if (t < 0.0f)
                     {
-                        throw new OverflowException($"t = {t} but must be >= 0. range {range}, RenderTime {RenderTime}, Start time {m_StartTimeConsumed.Time}, end time {m_EndTimeConsumed.Time}");
+                        throw new OverflowException($"t = {t} but must be >= 0. range {range}, RenderTime {renderTime}, Start time {m_StartTimeConsumed}, end time {m_EndTimeConsumed}");
                     }
 
                     if (t > 3.0f) // max extrapolation
@@ -211,24 +199,24 @@ public T Update(float deltaTime)
             return m_CurrentInterpValue;
         }
 
-        public void AddMeasurement(T newMeasurement, NetworkTime sentTime)
+        public void AddMeasurement(T newMeasurement, double sentTime)
         {
             m_NbItemsReceivedThisFrame++;
 
             // This situation can happen after a game is paused. When starting to receive again, the server will have sent a bunch of messages in the meantime
             // instead of going through thousands of value updates just to get a big teleport, we're giving up on interpolation and teleporting to the latest value
             if (m_NbItemsReceivedThisFrame > k_BufferCountLimit)
             {
-                if (m_LastBufferedItemReceived.TimeSent.Time < sentTime.Time)
+                if (m_LastBufferedItemReceived.TimeSent < sentTime)
                 {
                     m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime);
-                    ResetTo(newMeasurement);
+                    ResetTo(newMeasurement, sentTime);
                 }
 
                 return;
             }
 
-            if (sentTime.Time > m_EndTimeConsumed.Time || m_LifetimeConsumedCount == 0) // treat only if value is newer than the one being interpolated to right now
+            if (sentTime > m_EndTimeConsumed || m_LifetimeConsumedCount == 0) // treat only if value is newer than the one being interpolated to right now
             {
                 m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime);
                 m_Buffer.Add(m_LastBufferedItemReceived);
@@ -244,6 +232,7 @@ public T GetInterpolatedValue()
         protected abstract T InterpolateUnclamped(T start, T end, float time);
     }
 
+
     internal class BufferedLinearInterpolatorFloat : BufferedLinearInterpolator<float>
     {
         protected override float InterpolateUnclamped(float start, float end, float time)
@@ -255,14 +244,6 @@ protected override float Interpolate(float start, float end, float time)
         {
             return Mathf.Lerp(start, end, time);
         }
-
-        public BufferedLinearInterpolatorFloat(NetworkManager manager) : base(manager)
-        {
-        }
-
-        public BufferedLinearInterpolatorFloat(IInterpolatorTime proxy) : base(proxy)
-        {
-        }
     }
 
     internal class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
@@ -276,9 +257,5 @@ protected override Quaternion Interpolate(Quaternion start, Quaternion end, floa
         {
             return Quaternion.SlerpUnclamped(start, end, time);
         }
-
-        public BufferedLinearInterpolatorQuaternion(NetworkManager manager) : base(manager)
-        {
-        }
     }
 }