perf: Avoid allocation when reading message payload (#912)

vis2k · web-flow · commit 11750a9e7a3f · 2019-06-19T14:11:17.000+02:00
* so far

* syntax

* add test

* more tests

* more tests

* convert messages

* use arraysegment in serialization and handle null case too
diff --git a/Assets/Mirror/Runtime/ClientScene.cs b/Assets/Mirror/Runtime/ClientScene.cs
@@ -330,18 +330,21 @@ public static GameObject FindLocalObject(uint netId)
             return null;
         }
 
-        static void ApplySpawnPayload(NetworkIdentity identity, Vector3 position, Quaternion rotation, Vector3 scale, byte[] payload, uint netId)
+        static void ApplySpawnPayload(NetworkIdentity identity, Vector3 position, Quaternion rotation, Vector3 scale, ArraySegment<byte> payload, uint netId)
         {
             if (!identity.gameObject.activeSelf)
             {
                 identity.gameObject.SetActive(true);
             }
-            
+
             // apply local values for VR support
             identity.transform.localPosition = position;
             identity.transform.localRotation = rotation;
-            identity.transform.localScale = scale;            
-            if (payload != null && payload.Length > 0)
+            identity.transform.localScale = scale;
+
+            // deserialize components if any payload
+            // (Count is 0 if there were no components)
+            if (payload.Count > 0)
             {
                 NetworkReader payloadReader = new NetworkReader(payload);
                 identity.OnUpdateVars(payloadReader, true);
@@ -453,7 +456,7 @@ internal static void OnSpawnSceneObject(NetworkConnection conn, SpawnSceneObject
                     foreach (KeyValuePair<ulong, NetworkIdentity> kvp in spawnableObjects)
                         Debug.Log("Spawnable: SceneId=" + kvp.Key + " name=" + kvp.Value.name);
                 }
-                
+
                 return;
             }
 
diff --git a/Assets/Mirror/Runtime/Messages.cs b/Assets/Mirror/Runtime/Messages.cs
@@ -183,22 +183,24 @@ class RemoteCallMessage : MessageBase
         public uint netId;
         public int componentIndex;
         public int functionHash;
-        public byte[] payload; // the parameters for the Cmd function
+        // the parameters for the Cmd function
+        // -> ArraySegment to avoid unnecessary allocations
+        public ArraySegment<byte> payload;
 
         public override void Deserialize(NetworkReader reader)
         {
             netId = reader.ReadPackedUInt32();
             componentIndex = (int)reader.ReadPackedUInt32();
             functionHash = reader.ReadInt32(); // hash is always 4 full bytes, WritePackedInt would send 1 extra byte here
-            payload = reader.ReadBytesAndSize();
+            payload = reader.ReadBytesAndSizeSegment();
         }
 
         public override void Serialize(NetworkWriter writer)
         {
             writer.WritePackedUInt32(netId);
             writer.WritePackedUInt32((uint)componentIndex);
             writer.Write(functionHash);
-            writer.WriteBytesAndSize(payload);
+            writer.WriteBytesAndSizeSegment(payload);
         }
     }
 
@@ -218,7 +220,9 @@ class SpawnPrefabMessage : MessageBase
         public Vector3 position;
         public Quaternion rotation;
         public Vector3 scale;
-        public byte[] payload;
+        // the serialized component data
+        // -> ArraySegment to avoid unnecessary allocations
+        public ArraySegment<byte> payload;
 
         public override void Deserialize(NetworkReader reader)
         {
@@ -228,7 +232,7 @@ public override void Deserialize(NetworkReader reader)
             position = reader.ReadVector3();
             rotation = reader.ReadQuaternion();
             scale = reader.ReadVector3();
-            payload = reader.ReadBytesAndSize();
+            payload = reader.ReadBytesAndSizeSegment();
         }
 
         public override void Serialize(NetworkWriter writer)
@@ -239,7 +243,7 @@ public override void Serialize(NetworkWriter writer)
             writer.Write(position);
             writer.Write(rotation);
             writer.Write(scale);
-            writer.WriteBytesAndSize(payload);
+            writer.WriteBytesAndSizeSegment(payload);
         }
     }
 
@@ -251,7 +255,9 @@ class SpawnSceneObjectMessage : MessageBase
         public Vector3 position;
         public Quaternion rotation;
         public Vector3 scale;
-        public byte[] payload;
+        // the serialized component data
+        // -> ArraySegment to avoid unnecessary allocations
+        public ArraySegment<byte> payload;
 
         public override void Deserialize(NetworkReader reader)
         {
@@ -261,7 +267,7 @@ public override void Deserialize(NetworkReader reader)
             position = reader.ReadVector3();
             rotation = reader.ReadQuaternion();
             scale = reader.ReadVector3();
-            payload = reader.ReadBytesAndSize();
+            payload = reader.ReadBytesAndSizeSegment();
         }
 
         public override void Serialize(NetworkWriter writer)
@@ -272,7 +278,7 @@ public override void Serialize(NetworkWriter writer)
             writer.Write(position);
             writer.Write(rotation);
             writer.Write(scale);
-            writer.WriteBytesAndSize(payload);
+            writer.WriteBytesAndSizeSegment(payload);
         }
     }
 
@@ -331,18 +337,20 @@ public override void Serialize(NetworkWriter writer)
     class UpdateVarsMessage : MessageBase
     {
         public uint netId;
-        public byte[] payload;
+        // the serialized component data
+        // -> ArraySegment to avoid unnecessary allocations
+        public ArraySegment<byte> payload;
 
         public override void Deserialize(NetworkReader reader)
         {
             netId = reader.ReadPackedUInt32();
-            payload = reader.ReadBytesAndSize();
+            payload = reader.ReadBytesAndSizeSegment();
         }
 
         public override void Serialize(NetworkWriter writer)
         {
             writer.WritePackedUInt32(netId);
-            writer.WriteBytesAndSize(payload);
+            writer.WriteBytesAndSizeSegment(payload);
         }
     }
 
diff --git a/Assets/Mirror/Runtime/NetworkBehaviour.cs b/Assets/Mirror/Runtime/NetworkBehaviour.cs
@@ -121,7 +121,7 @@ protected void SendCommandInternal(Type invokeClass, string cmdName, NetworkWrit
                 netId = netId,
                 componentIndex = ComponentIndex,
                 functionHash = GetMethodHash(invokeClass, cmdName), // type+func so Inventory.RpcUse != Equipment.RpcUse
-                payload = writer.ToArray()
+                payload = new ArraySegment<byte>(writer.ToArray()) // segment to avoid reader allocations
             };
 
             ClientScene.readyConnection.Send(message, channelId);
@@ -157,7 +157,7 @@ protected void SendRPCInternal(Type invokeClass, string rpcName, NetworkWriter w
                 netId = netId,
                 componentIndex = ComponentIndex,
                 functionHash = GetMethodHash(invokeClass, rpcName), // type+func so Inventory.RpcUse != Equipment.RpcUse
-                payload = writer.ToArray()
+                payload = new ArraySegment<byte>(writer.ToArray()) // segment to avoid reader allocations
             };
 
             NetworkServer.SendToReady(netIdentity, message, channelId);
@@ -196,7 +196,7 @@ protected void SendTargetRPCInternal(NetworkConnection conn, Type invokeClass, s
                 netId = netId,
                 componentIndex = ComponentIndex,
                 functionHash = GetMethodHash(invokeClass, rpcName), // type+func so Inventory.RpcUse != Equipment.RpcUse
-                payload = writer.ToArray()
+                payload = new ArraySegment<byte>(writer.ToArray()) // segment to avoid reader allocations
             };
 
             conn.Send(message, channelId);
@@ -225,7 +225,7 @@ protected void SendEventInternal(Type invokeClass, string eventName, NetworkWrit
                 netId = netId,
                 componentIndex = ComponentIndex,
                 functionHash = GetMethodHash(invokeClass, eventName), // type+func so Inventory.RpcUse != Equipment.RpcUse
-                payload = writer.ToArray()
+                payload = new ArraySegment<byte>(writer.ToArray()) // segment to avoid reader allocations
             };
 
             NetworkServer.SendToReady(netIdentity,message, channelId);
diff --git a/Assets/Mirror/Runtime/NetworkIdentity.cs b/Assets/Mirror/Runtime/NetworkIdentity.cs
@@ -1043,7 +1043,9 @@ internal void MirrorUpdate()
             {
                 // populate cached UpdateVarsMessage and send
                 varsMessage.netId = netId;
-                varsMessage.payload = payload;
+                // segment to avoid reader allocations.
+                // (never null because of our above check)
+                varsMessage.payload = new ArraySegment<byte>(payload);
                 NetworkServer.SendToReady(this, varsMessage);
             }
         }
diff --git a/Assets/Mirror/Runtime/NetworkReader.cs b/Assets/Mirror/Runtime/NetworkReader.cs
@@ -167,6 +167,21 @@ public byte[] ReadBytes(int count)
             return bytes;
         }
 
+        // useful to parse payloads etc. without allocating
+        public ArraySegment<byte> ReadBytesSegment(int count)
+        {
+            // check if within buffer limits
+            if (Position + count > buffer.Count)
+            {
+                throw new EndOfStreamException("ReadBytesSegment can't read " + count + " bytes because it would read past the end of the stream. " + ToString());
+            }
+
+            // return the segment
+            ArraySegment<byte> result = new ArraySegment<byte>(buffer.Array, buffer.Offset + Position, count);
+            Position += count;
+            return result;
+        }
+
         // Use checked() to force it to throw OverflowException if data is invalid
         // null support, see NetworkWriter
         public byte[] ReadBytesAndSize()
@@ -177,7 +192,15 @@ public byte[] ReadBytesAndSize()
             }
             return null;
         }
-        public ArraySegment<byte> ReadBytesAndSizeSegment() => new ArraySegment<byte>(ReadBytesAndSize());
+
+        public ArraySegment<byte> ReadBytesAndSizeSegment()
+        {
+            if (ReadBoolean())
+            {
+                return ReadBytesSegment((int)ReadPackedUInt32());
+            }
+            return default;
+        }
 
         // zigzag decoding https://gist.github.com/mfuerstenau/ba870a29e16536fdbaba
         public int ReadPackedInt32()
diff --git a/Assets/Mirror/Runtime/NetworkServer.cs b/Assets/Mirror/Runtime/NetworkServer.cs
@@ -836,6 +836,14 @@ internal static void SendSpawnMessage(NetworkIdentity identity, NetworkConnectio
 
             if (LogFilter.Debug) Debug.Log("Server SendSpawnMessage: name=" + identity.name + " sceneId=" + identity.sceneId.ToString("X") + " netid=" + identity.netId); // for easier debugging
 
+            // serialize all components with initialState = true
+            // (can be null if has none)
+            byte[] serialized = identity.OnSerializeAllSafely(true);
+
+            // convert to ArraySegment to avoid reader allocations
+            // (need to handle null case too)
+            ArraySegment<byte> segment = serialized != null ? new ArraySegment<byte>(serialized) : default;
+
             // 'identity' is a prefab that should be spawned
             if (identity.sceneId == 0)
             {
@@ -848,9 +856,7 @@ internal static void SendSpawnMessage(NetworkIdentity identity, NetworkConnectio
                     position = identity.transform.localPosition,
                     rotation = identity.transform.localRotation,
                     scale = identity.transform.localScale,
-
-                    // serialize all components with initialState = true
-                    payload = identity.OnSerializeAllSafely(true)
+                    payload = segment
                 };
 
                 // conn is != null when spawning it for a client
@@ -876,9 +882,7 @@ internal static void SendSpawnMessage(NetworkIdentity identity, NetworkConnectio
                     position = identity.transform.localPosition,
                     rotation = identity.transform.localRotation,
                     scale = identity.transform.localScale,
-
-                    // include synch data
-                    payload = identity.OnSerializeAllSafely(true)
+                    payload = segment
                 };
 
                 // conn is != null when spawning it for a client
diff --git a/Assets/Mirror/Tests/NetworkWriterTest.cs b/Assets/Mirror/Tests/NetworkWriterTest.cs
@@ -40,6 +40,51 @@ public void TestWritingHugeArray()
             Assert.That(deserialized.Length, Is.EqualTo(100000));
         }
 
+        [Test]
+        public void TestWritingBytesSegment()
+        {
+            byte[] data = {1, 2, 3};
+            NetworkWriter writer = new NetworkWriter();
+            writer.Write(data, 0, data.Length);
+
+            NetworkReader reader = new NetworkReader(writer.ToArray());
+            ArraySegment<byte> deserialized = reader.ReadBytesSegment(data.Length);
+            Assert.That(deserialized.Count, Is.EqualTo(data.Length));
+            for (int i = 0; i < data.Length; ++i)
+                Assert.That(deserialized.Array[deserialized.Offset + i], Is.EqualTo(data[i]));
+        }
+
+        // write byte[], read segment
+        [Test]
+        public void TestWritingBytesAndReadingSegment()
+        {
+            byte[] data = {1, 2, 3};
+            NetworkWriter writer = new NetworkWriter();
+            writer.WriteBytesAndSize(data);
+
+            NetworkReader reader = new NetworkReader(writer.ToArray());
+            ArraySegment<byte> deserialized = reader.ReadBytesAndSizeSegment();
+            Assert.That(deserialized.Count, Is.EqualTo(data.Length));
+            for (int i = 0; i < data.Length; ++i)
+                Assert.That(deserialized.Array[deserialized.Offset + i], Is.EqualTo(data[i]));
+        }
+
+        // write segment, read segment
+        [Test]
+        public void TestWritingSegmentAndReadingSegment()
+        {
+            byte[] data = {1, 2, 3, 4};
+            ArraySegment<byte> segment = new ArraySegment<byte>(data, 1, 1); // [2, 3]
+            NetworkWriter writer = new NetworkWriter();
+            writer.WriteBytesAndSizeSegment(segment);
+
+            NetworkReader reader = new NetworkReader(writer.ToArray());
+            ArraySegment<byte> deserialized = reader.ReadBytesAndSizeSegment();
+            Assert.That(deserialized.Count, Is.EqualTo(segment.Count));
+            for (int i = 0; i < segment.Count; ++i)
+                Assert.That(deserialized.Array[deserialized.Offset + i], Is.EqualTo(segment.Array[segment.Offset + i]));
+        }
+
         [Test]
         public void TestOverwritingData()
         {

Original file line number	Diff line number	Diff line change
`@@ -330,18 +330,21 @@ public static GameObject FindLocalObject(uint netId)`
`330`	`330`	`return null;`
`331`	`331`	`}`
`332`	`332`
`333`		`- static void ApplySpawnPayload(NetworkIdentity identity, Vector3 position, Quaternion rotation, Vector3 scale, byte[] payload, uint netId)`
	`333`	`+ static void ApplySpawnPayload(NetworkIdentity identity, Vector3 position, Quaternion rotation, Vector3 scale, ArraySegment<byte> payload, uint netId)`
`334`	`334`	`{`
`335`	`335`	`if (!identity.gameObject.activeSelf)`
`336`	`336`	`{`
`337`	`337`	`identity.gameObject.SetActive(true);`
`338`	`338`	`}`
`339`		`-`
	`339`	`+`
`340`	`340`	`// apply local values for VR support`
`341`	`341`	`identity.transform.localPosition = position;`
`342`	`342`	`identity.transform.localRotation = rotation;`
`343`		`- identity.transform.localScale = scale;`
`344`		`- if (payload != null && payload.Length > 0)`
	`343`	`+ identity.transform.localScale = scale;`
	`344`	`+`
	`345`	`+ // deserialize components if any payload`
	`346`	`+ // (Count is 0 if there were no components)`
	`347`	`+ if (payload.Count > 0)`
`345`	`348`	`{`
`346`	`349`	`NetworkReader payloadReader = new NetworkReader(payload);`
`347`	`350`	`identity.OnUpdateVars(payloadReader, true);`
`@@ -453,7 +456,7 @@ internal static void OnSpawnSceneObject(NetworkConnection conn, SpawnSceneObject`
`453`	`456`	`foreach (KeyValuePair<ulong, NetworkIdentity> kvp in spawnableObjects)`
`454`	`457`	`Debug.Log("Spawnable: SceneId=" + kvp.Key + " name=" + kvp.Value.name);`
`455`	`458`	`}`
`456`		`-`
	`459`	`+`
`457`	`460`	`return;`
`458`	`461`	`}`
`459`	`462`
Original file line number	Diff line number	Diff line change
`@@ -183,22 +183,24 @@ class RemoteCallMessage : MessageBase`
`183`	`183`	`public uint netId;`
`184`	`184`	`public int componentIndex;`
`185`	`185`	`public int functionHash;`
`186`		`- public byte[] payload; // the parameters for the Cmd function`
	`186`	`+ // the parameters for the Cmd function`
	`187`	`+ // -> ArraySegment to avoid unnecessary allocations`
	`188`	`+ public ArraySegment<byte> payload;`
`187`	`189`
`188`	`190`	`public override void Deserialize(NetworkReader reader)`
`189`	`191`	`{`
`190`	`192`	`netId = reader.ReadPackedUInt32();`
`191`	`193`	`componentIndex = (int)reader.ReadPackedUInt32();`
`192`	`194`	`functionHash = reader.ReadInt32(); // hash is always 4 full bytes, WritePackedInt would send 1 extra byte here`
`193`		`- payload = reader.ReadBytesAndSize();`
	`195`	`+ payload = reader.ReadBytesAndSizeSegment();`
`194`	`196`	`}`
`195`	`197`
`196`	`198`	`public override void Serialize(NetworkWriter writer)`
`197`	`199`	`{`
`198`	`200`	`writer.WritePackedUInt32(netId);`
`199`	`201`	`writer.WritePackedUInt32((uint)componentIndex);`
`200`	`202`	`writer.Write(functionHash);`
`201`		`- writer.WriteBytesAndSize(payload);`
	`203`	`+ writer.WriteBytesAndSizeSegment(payload);`
`202`	`204`	`}`
`203`	`205`	`}`
`204`	`206`
`@@ -218,7 +220,9 @@ class SpawnPrefabMessage : MessageBase`
`218`	`220`	`public Vector3 position;`
`219`	`221`	`public Quaternion rotation;`
`220`	`222`	`public Vector3 scale;`
`221`		`- public byte[] payload;`
	`223`	`+ // the serialized component data`
	`224`	`+ // -> ArraySegment to avoid unnecessary allocations`
	`225`	`+ public ArraySegment<byte> payload;`
`222`	`226`
`223`	`227`	`public override void Deserialize(NetworkReader reader)`
`224`	`228`	`{`
`@@ -228,7 +232,7 @@ public override void Deserialize(NetworkReader reader)`
`228`	`232`	`position = reader.ReadVector3();`
`229`	`233`	`rotation = reader.ReadQuaternion();`
`230`	`234`	`scale = reader.ReadVector3();`
`231`		`- payload = reader.ReadBytesAndSize();`
	`235`	`+ payload = reader.ReadBytesAndSizeSegment();`
`232`	`236`	`}`
`233`	`237`
`234`	`238`	`public override void Serialize(NetworkWriter writer)`
`@@ -239,7 +243,7 @@ public override void Serialize(NetworkWriter writer)`
`239`	`243`	`writer.Write(position);`
`240`	`244`	`writer.Write(rotation);`
`241`	`245`	`writer.Write(scale);`
`242`		`- writer.WriteBytesAndSize(payload);`
	`246`	`+ writer.WriteBytesAndSizeSegment(payload);`
`243`	`247`	`}`
`244`	`248`	`}`
`245`	`249`
`@@ -251,7 +255,9 @@ class SpawnSceneObjectMessage : MessageBase`
`251`	`255`	`public Vector3 position;`
`252`	`256`	`public Quaternion rotation;`
`253`	`257`	`public Vector3 scale;`
`254`		`- public byte[] payload;`
	`258`	`+ // the serialized component data`
	`259`	`+ // -> ArraySegment to avoid unnecessary allocations`
	`260`	`+ public ArraySegment<byte> payload;`
`255`	`261`
`256`	`262`	`public override void Deserialize(NetworkReader reader)`
`257`	`263`	`{`
`@@ -261,7 +267,7 @@ public override void Deserialize(NetworkReader reader)`
`261`	`267`	`position = reader.ReadVector3();`
`262`	`268`	`rotation = reader.ReadQuaternion();`
`263`	`269`	`scale = reader.ReadVector3();`
`264`		`- payload = reader.ReadBytesAndSize();`
	`270`	`+ payload = reader.ReadBytesAndSizeSegment();`
`265`	`271`	`}`
`266`	`272`
`267`	`273`	`public override void Serialize(NetworkWriter writer)`
`@@ -272,7 +278,7 @@ public override void Serialize(NetworkWriter writer)`
`272`	`278`	`writer.Write(position);`
`273`	`279`	`writer.Write(rotation);`
`274`	`280`	`writer.Write(scale);`
`275`		`- writer.WriteBytesAndSize(payload);`
	`281`	`+ writer.WriteBytesAndSizeSegment(payload);`
`276`	`282`	`}`
`277`	`283`	`}`
`278`	`284`
`@@ -331,18 +337,20 @@ public override void Serialize(NetworkWriter writer)`
`331`	`337`	`class UpdateVarsMessage : MessageBase`
`332`	`338`	`{`
`333`	`339`	`public uint netId;`
`334`		`- public byte[] payload;`
	`340`	`+ // the serialized component data`
	`341`	`+ // -> ArraySegment to avoid unnecessary allocations`
	`342`	`+ public ArraySegment<byte> payload;`
`335`	`343`
`336`	`344`	`public override void Deserialize(NetworkReader reader)`
`337`	`345`	`{`
`338`	`346`	`netId = reader.ReadPackedUInt32();`
`339`		`- payload = reader.ReadBytesAndSize();`
	`347`	`+ payload = reader.ReadBytesAndSizeSegment();`
`340`	`348`	`}`
`341`	`349`
`342`	`350`	`public override void Serialize(NetworkWriter writer)`
`343`	`351`	`{`
`344`	`352`	`writer.WritePackedUInt32(netId);`
`345`		`- writer.WriteBytesAndSize(payload);`
	`353`	`+ writer.WriteBytesAndSizeSegment(payload);`
`346`	`354`	`}`
`347`	`355`	`}`
`348`	`356`
Original file line number	Diff line number	Diff line change
`@@ -1043,7 +1043,9 @@ internal void MirrorUpdate()`
`1043`	`1043`	`{`
`1044`	`1044`	`// populate cached UpdateVarsMessage and send`
`1045`	`1045`	`varsMessage.netId = netId;`
`1046`		`- varsMessage.payload = payload;`
	`1046`	`+ // segment to avoid reader allocations.`
	`1047`	`+ // (never null because of our above check)`
	`1048`	`+ varsMessage.payload = new ArraySegment<byte>(payload);`
`1047`	`1049`	`NetworkServer.SendToReady(this, varsMessage);`
`1048`	`1050`	`}`
`1049`	`1051`	`}`