Add message receive allocations test

Author: EmandM

com.unity.netcode.gameobjects/Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -47,7 +47,7 @@ internal struct NetworkVariableDeltaMessage : INetworkMessage
 
         private Dictionary<ulong, List<int>> m_ForwardUpdates;
 
-        private List<int> m_UpdatedNetworkVariables;
+        private NativeList<int> m_UpdatedNetworkVariables;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void WriteNetworkVariable(ref FastBufferWriter writer, ref NetworkVariableBase networkVariable, bool ensureNetworkVariableLengthSafety, int nonfragmentedSize, int fragmentedSize)
@@ -217,7 +217,7 @@ public void Handle(ref NetworkContext context)
             var networkBehaviour = networkObject.GetNetworkBehaviourAtOrderIndex(NetworkBehaviourIndex);
             var isServerAndDeltaForwarding = m_ReceivedMessageVersion >= k_ServerDeltaForwardingAndNetworkDelivery && networkManager.IsServer;
             var markNetworkVariableDirty = m_ReceivedMessageVersion >= k_ServerDeltaForwardingAndNetworkDelivery ? false : networkManager.IsServer;
-            m_UpdatedNetworkVariables = new List<int>();
+            m_UpdatedNetworkVariables = new NativeList<int>(Allocator.Temp);
 
             if (networkBehaviour == null)
             {
@@ -396,9 +396,9 @@ public void Handle(ref NetworkContext context)
             // When a server forwards delta updates to connected clients, it needs to preserve the previous value
             // until it is done serializing all valid NetworkVariable field deltas (relative to each client). This
             // is invoked after it is done forwarding the deltas.
-            foreach (var fieldIndex in m_UpdatedNetworkVariables)
+            for (int i = 0; i < m_UpdatedNetworkVariables.Length; i++)
             {
-                networkBehaviour.NetworkVariableFields[fieldIndex].PostDeltaRead();
+                networkBehaviour.NetworkVariableFields[m_UpdatedNetworkVariables[i]].PostDeltaRead();
             }
         }
     }

com.unity.netcode.gameobjects/Tests/Runtime/Helpers/MessageCatcher.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Unity.Collections;
+using UnityEngine;
 
 namespace Unity.Netcode.RuntimeTests
 {
@@ -25,14 +26,20 @@ private struct TriggerData
 
         public void ReleaseMessages()
         {
-
             foreach (var caughtSpawn in m_CaughtMessages)
             {
                 // Reader will be disposed within HandleMessage
                 m_OwnerNetworkManager.ConnectionManager.MessageManager.HandleMessage(caughtSpawn.Header, caughtSpawn.Reader, caughtSpawn.SenderId, caughtSpawn.Timestamp, caughtSpawn.SerializedHeaderSize);
             }
         }
 
+        public void HandleCaughtMessage(int index)
+        {
+            var caughtMessage = m_CaughtMessages[index];
+            // Reader will be disposed within HandleMessage
+            m_OwnerNetworkManager.ConnectionManager.MessageManager.HandleMessage(caughtMessage.Header, caughtMessage.Reader, caughtMessage.SenderId, caughtMessage.Timestamp, caughtMessage.SerializedHeaderSize);
+        }
+
         public int CaughtMessageCount => m_CaughtMessages.Count;
 
         public void OnBeforeSendMessage<T>(ulong clientId, ref T message, NetworkDelivery delivery) where T : INetworkMessage

com.unity.netcode.gameobjects/Tests/Runtime/Messaging/MessageReceiveAllocationTests.cs

@@ -0,0 +1,106 @@
+using System.Collections;
+using NUnit.Framework;
+using Unity.Netcode.TestHelpers.Runtime;
+using UnityEngine;
+using UnityEngine.TestTools;
+using UnityEngine.TestTools.Constraints;
+using Is = NUnit.Framework.Is;
+
+namespace Unity.Netcode.RuntimeTests
+{
+    internal class AllocationTestBehaviour : NetworkBehaviour
+    {
+        internal int RpcReceivedCount;
+
+        public NetworkVariable<int> TestVariable = new();
+
+        [Rpc(SendTo.NotMe)]
+        public void NotMeRpc()
+        {
+            RpcReceivedCount++;
+        }
+    }
+
+    [TestFixture(HostOrServer.Host)]
+    [TestFixture(HostOrServer.DAHost)]
+    internal class MessageReceiveAllocationTests : NetcodeIntegrationTest
+    {
+        protected override int NumberOfClients => 1;
+
+        public MessageReceiveAllocationTests(HostOrServer hostOrServer) : base(hostOrServer) {}
+
+        private GameObject m_Prefab;
+
+        protected override void OnServerAndClientsCreated()
+        {
+            m_Prefab = CreateNetworkObjectPrefab(nameof(AllocationTestBehaviour));
+            m_Prefab.AddComponent<AllocationTestBehaviour>();
+            base.OnServerAndClientsCreated();
+        }
+
+        [UnityTest]
+        public IEnumerator NoAllocationsOnMessageReceive()
+        {
+            var authority = GetAuthorityNetworkManager();
+            var nonAuthority = GetNonAuthorityNetworkManager();
+
+            var authorityInstance = SpawnObject(m_Prefab, authority);
+            var authorityComponent = authorityInstance.GetComponent<AllocationTestBehaviour>();
+            yield return WaitForSpawnedOnAllOrTimeOut(authorityInstance);
+            AssertOnTimeout("Timed out waiting for objects to spawn");
+
+            var nonAuthorityComponent = nonAuthority.SpawnManager.SpawnedObjects[authorityComponent.NetworkObjectId].GetComponent<AllocationTestBehaviour>();
+
+            /*
+             * RpcMessage
+             */
+            var rpcCatcher = new MessageCatcher<RpcMessage>(nonAuthority);
+            nonAuthority.ConnectionManager.MessageManager.Hook(rpcCatcher);
+
+            // Send the same message twice: the first is replayed as a warm-up.
+            // The second will follow the identical code path and is checked for allocations.
+            authorityComponent.NotMeRpc();
+            authorityComponent.NotMeRpc();
+            yield return WaitForConditionOrTimeOut(() => rpcCatcher.CaughtMessageCount == 2);
+            AssertOnTimeout($"Timed out waiting to catch all expected {nameof(RpcMessage)} messages. Expected: 2, Actual: {rpcCatcher.CaughtMessageCount}");
+
+            // Unhook first so the replayed messages are handled instead of being caught again
+            nonAuthority.ConnectionManager.MessageManager.Unhook(rpcCatcher);
+
+            rpcCatcher.HandleCaughtMessage(0);
+            Assert.AreEqual(1, nonAuthorityComponent.RpcReceivedCount);
+
+            Assert.That(() =>
+            {
+                rpcCatcher.HandleCaughtMessage(1);
+            }, Is.Not.AllocatingGCMemory());
+            Assert.AreEqual(2, nonAuthorityComponent.RpcReceivedCount);
+
+            /*
+             * NetworkVariableDeltaMessage
+             */
+            var deltaCatcher = new MessageCatcher<NetworkVariableDeltaMessage>(nonAuthority);
+            nonAuthority.ConnectionManager.MessageManager.Hook(deltaCatcher);
+
+            authorityComponent.TestVariable.Value = 1;
+            // Wait for the first change to be received client-side before sending the second change
+            yield return WaitForConditionOrTimeOut(() => deltaCatcher.CaughtMessageCount == 1);
+            authorityComponent.TestVariable.Value = 2;
+            yield return WaitForConditionOrTimeOut(() => deltaCatcher.CaughtMessageCount == 2);
+            AssertOnTimeout($"Timed out waiting to catch all expected {nameof(NetworkVariableDeltaMessage)} messages. Expected: 2, Actual: {deltaCatcher.CaughtMessageCount}");
+
+            // Unhook first so the replayed messages are handled instead of being caught again
+            nonAuthority.ConnectionManager.MessageManager.Unhook(deltaCatcher);
+
+            deltaCatcher.HandleCaughtMessage(0);
+            Assert.AreEqual(1, nonAuthorityComponent.TestVariable.Value);
+
+            Assert.That(() =>
+            {
+                deltaCatcher.HandleCaughtMessage(1);
+            }, Is.Not.AllocatingGCMemory());
+            Assert.AreEqual(2, nonAuthorityComponent.TestVariable.Value);
+        }
+
+    }
+}

com.unity.netcode.gameobjects/Tests/Runtime/Messaging/MessageReceiveAllocationTests.cs.meta

@@ -8,9 +8,9 @@
 using Unity.Netcode.TestHelpers.Runtime;
 using UnityEngine;
 using UnityEngine.TestTools;
-using Random = UnityEngine.Random;
 using UnityEngine.TestTools.Constraints;
 using Is = NUnit.Framework.Is;
+using Random = UnityEngine.Random;
 
 namespace Unity.Netcode.RuntimeTests
 {