perf: Reuse static array when sending data to transport to avoid FastBufferWriter.ToArray() GC (#1324) (#1345)

* perf: Reuse static array when sending data to transport to avoid FastBufferWriter.ToArray() GC
* Added failsafe if the value is too large.

Co-authored-by: Jaedyn Draper <284434+ShadauxCat@users.noreply.github.com>
Co-authored-by: Matt Walsh <69258106+mattwalsh-unity@users.noreply.github.com>

Author: 3 people

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -149,14 +149,9 @@ public NetworkManagerMessageSender(NetworkManager manager)
 
             public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
             {
-
-                var length = batchData.Length;
-                //TODO: Transport needs to have a way to send it data without copying and allocating here.
-                var bytes = batchData.ToArray();
-                var sendBuffer = new ArraySegment<byte>(bytes, 0, length);
+                var sendBuffer = batchData.ToTempByteArray();
 
                 m_NetworkManager.NetworkConfig.NetworkTransport.Send(clientId, sendBuffer, delivery);
-
             }
         }
 

com.unity.netcode.gameobjects/Runtime/Serialization/FastBufferWriter.cs

@@ -24,6 +24,8 @@ internal struct WriterHandle
 
         internal readonly unsafe WriterHandle* Handle;
 
+        private static byte[] s_ByteArrayCache = new byte[65535];
+
         /// <summary>
         /// The current write position
         /// </summary>
@@ -78,6 +80,10 @@ internal unsafe void CommitBitwiseWrites(int amount)
         /// <param name="maxSize">Maximum size the buffer can grow to. If less than size, buffer cannot grow.</param>
         public unsafe FastBufferWriter(int size, Allocator allocator, int maxSize = -1)
         {
+            // Allocating both the Handle struct and the buffer in a single allocation - sizeof(WriterHandle) + size
+            // The buffer for the initial allocation is the next block of memory after the handle itself.
+            // If the buffer grows, a new buffer will be allocated and the handle pointer pointed at the new location...
+            // The original buffer won't be deallocated until the writer is destroyed since it's part of the handle allocation.
             Handle = (WriterHandle*)UnsafeUtility.Malloc(sizeof(WriterHandle) + size, UnsafeUtility.AlignOf<WriterHandle>(), allocator);
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             UnsafeUtility.MemSet(Handle, 0, sizeof(WriterHandle) + size);
@@ -349,6 +355,29 @@ public unsafe byte[] ToArray()
             return ret;
         }
 
+        /// <summary>
+        /// Uses a static cached array to create an array segment with no allocations.
+        /// This array can only be used until the next time ToTempByteArray() is called on ANY FastBufferWriter,
+        /// as the cached buffer is shared by all of them and will be overwritten.
+        /// As such, this should be used with care.
+        /// </summary>
+        /// <returns></returns>
+        internal unsafe ArraySegment<byte> ToTempByteArray()
+        {
+            var length = Length;
+            if (length > s_ByteArrayCache.Length)
+            {
+                return new ArraySegment<byte>(ToArray(), 0, length);
+            }
+
+            fixed (byte* b = s_ByteArrayCache)
+            {
+                UnsafeUtility.MemCpy(b, Handle->BufferPointer, length);
+            }
+
+            return new ArraySegment<byte>(s_ByteArrayCache, 0, length);
+        }
+
         /// <summary>
         /// Gets a direct pointer to the underlying buffer
         /// </summary>