feat: Enable fragmentation for unreliable delivery (UTP) (1.0.0) (#1515)

* Add fragmentation to the unreliable sequenced pipeline

* Add fragmentation for unreliable delivery

* Test multiple delivery methods in adapter tests

* Update CHANGELOG with latest change

* Make the standard script happy...

Author: simon-lemay-unity

com.unity.netcode.adapter.utp/CHANGELOG.md

@@ -7,6 +7,7 @@ All notable changes to this package will be documented in this file. The format
 
 - Removed 'Maximum Packet Size' configuration field in the inspector. This would cause confusion since the maximum packet size is in effect always the MTU (1400 bytes on most platforms).
 - Updated com.unity.transport to 1.0.0-pre.8
+- All delivery methods now support fragmentation, meaning the 'Send Queue Batch Size' setting (which controls the maximum payload size) now applies to all delivery methods, not just reliable ones.
 
 
 ### Fixed

com.unity.netcode.adapter.utp/Runtime/UnityTransport.cs

@@ -16,7 +16,12 @@ namespace Unity.Netcode
     /// </summary>
     public interface INetworkStreamDriverConstructor
     {
-        void CreateDriver(UnityTransport transport, out NetworkDriver driver, out NetworkPipeline unreliableSequencedPipeline, out NetworkPipeline reliableSequencedFragmentedPipeline);
+        void CreateDriver(
+            UnityTransport transport,
+            out NetworkDriver driver,
+            out NetworkPipeline unreliableFragmentedPipeline,
+            out NetworkPipeline unreliableSequencedFragmentedPipeline,
+            out NetworkPipeline reliableSequencedFragmentedPipeline);
     }
 
     public static class ErrorUtilities
@@ -141,7 +146,8 @@ public static implicit operator ConnectionAddressData(NetworkEndPoint d) =>
         private NetworkConnection m_ServerConnection;
         private ulong m_ServerClientId;
 
-        private NetworkPipeline m_UnreliableSequencedPipeline;
+        private NetworkPipeline m_UnreliableFragmentedPipeline;
+        private NetworkPipeline m_UnreliableSequencedFragmentedPipeline;
         private NetworkPipeline m_ReliableSequencedFragmentedPipeline;
 
         public override ulong ServerClientId => m_ServerClientId;
@@ -194,7 +200,12 @@ public SimulatorUtility.Parameters ClientSimulatorParameters
 
         private void InitDriver()
         {
-            DriverConstructor.CreateDriver(this, out m_Driver, out m_UnreliableSequencedPipeline, out m_ReliableSequencedFragmentedPipeline);
+            DriverConstructor.CreateDriver(
+                this,
+                out m_Driver,
+                out m_UnreliableFragmentedPipeline,
+                out m_UnreliableSequencedFragmentedPipeline,
+                out m_ReliableSequencedFragmentedPipeline);
         }
 
         private void DisposeDriver()
@@ -210,10 +221,10 @@ private NetworkPipeline SelectSendPipeline(NetworkDelivery delivery, int size)
             switch (delivery)
             {
                 case NetworkDelivery.Unreliable:
-                    return NetworkPipeline.Null;
+                    return m_UnreliableFragmentedPipeline;
 
                 case NetworkDelivery.UnreliableSequenced:
-                    return m_UnreliableSequencedPipeline;
+                    return m_UnreliableSequencedFragmentedPipeline;
 
                 case NetworkDelivery.Reliable:
                 case NetworkDelivery.ReliableSequenced:
@@ -647,7 +658,6 @@ public override void Send(ulong clientId, ArraySegment<byte> payload, NetworkDel
                 {
                     // If data is too large to be batched, flush it out immediately. This happens with large initial spawn packets from Netcode for Gameobjects.
                     Debug.LogWarning($"Event of size {payload.Count} too large to fit in send queue (of size {m_SendQueueBatchSize}). Trying to send directly. This could be the initial payload!");
-                    Debug.Assert(networkDelivery == NetworkDelivery.ReliableFragmentedSequenced); // Messages like this, should always be sent via the fragmented pipeline.
                     SendMessageInstantly(sendTarget.ClientId, payload, pipeline);
                 }
             }
@@ -728,10 +738,6 @@ private void SendBatchedMessageAndClearQueue(SendTarget sendTarget, SendQueue se
         {
             NetworkPipeline pipeline = sendTarget.NetworkPipeline;
             var payloadSize = sendQueue.Count + 1; // 1 extra byte to tell whether the message is batched or not
-            if (payloadSize > NetworkParameterConstants.MTU) // If this is bigger than MTU then force it to be sent via the FragmentedReliableSequencedPipeline
-            {
-                pipeline = m_ReliableSequencedFragmentedPipeline;
-            }
 
             var sendBuffer = sendQueue.GetData();
             SendBatchedMessage(sendTarget.ClientId, ref sendBuffer, pipeline);
@@ -795,7 +801,10 @@ public override void Shutdown()
             m_ServerClientId = 0;
         }
 
-        public void CreateDriver(UnityTransport transport, out NetworkDriver driver, out NetworkPipeline unreliableSequencedPipeline, out NetworkPipeline reliableSequencedFragmentedPipeline)
+        public void CreateDriver(UnityTransport transport, out NetworkDriver driver,
+            out NetworkPipeline unreliableFragmentedPipeline,
+            out NetworkPipeline unreliableSequencedFragmentedPipeline,
+            out NetworkPipeline reliableSequencedFragmentedPipeline)
         {
             var maxFrameTimeMS = 0;
 
@@ -817,7 +826,12 @@ public void CreateDriver(UnityTransport transport, out NetworkDriver driver, out
 #if UNITY_EDITOR || DEVELOPMENT_BUILD
             if (simulatorParams.PacketDelayMs > 0 || simulatorParams.PacketDropInterval > 0)
             {
-                unreliableSequencedPipeline = driver.CreatePipeline(
+                unreliableFragmentedPipeline = driver.CreatePipeline(
+                    typeof(FragmentationPipelineStage),
+                    typeof(SimulatorPipelineStage),
+                    typeof(SimulatorPipelineStageInSend));
+                unreliableSequencedFragmentedPipeline = driver.CreatePipeline(
+                    typeof(FragmentationPipelineStage),
                     typeof(UnreliableSequencedPipelineStage),
                     typeof(SimulatorPipelineStage),
                     typeof(SimulatorPipelineStageInSend));
@@ -830,7 +844,10 @@ public void CreateDriver(UnityTransport transport, out NetworkDriver driver, out
             else
 #endif
             {
-                unreliableSequencedPipeline = driver.CreatePipeline(typeof(UnreliableSequencedPipelineStage));
+                unreliableFragmentedPipeline = driver.CreatePipeline(
+                    typeof(FragmentationPipelineStage));
+                unreliableSequencedFragmentedPipeline = driver.CreatePipeline(
+                    typeof(FragmentationPipelineStage), typeof(UnreliableSequencedPipelineStage));
                 reliableSequencedFragmentedPipeline = driver.CreatePipeline(
                     typeof(FragmentationPipelineStage), typeof(ReliableSequencedPipelineStage)
                 );

com.unity.netcode.adapter.utp/Tests/Runtime/TransportTests.cs

@@ -12,6 +12,14 @@ namespace Unity.Netcode.UTP.RuntimeTests
 {
     public class TransportTests
     {
+        // No need to test all reliable delivery methods since they all map to the same pipeline.
+        private static readonly NetworkDelivery[] k_DeliveryParameters =
+        {
+            NetworkDelivery.Unreliable,
+            NetworkDelivery.UnreliableSequenced,
+            NetworkDelivery.Reliable
+        };
+
         private UnityTransport m_Server, m_Client1, m_Client2;
         private List<TransportEvent> m_ServerEvents, m_Client1Events, m_Client2Events;
 
@@ -46,7 +54,7 @@ public IEnumerator Cleanup()
 
         // Check if can make a simple data exchange.
         [UnityTest]
-        public IEnumerator PingPong()
+        public IEnumerator PingPong([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
         {
             InitializeTransport(out m_Server, out m_ServerEvents);
             InitializeTransport(out m_Client1, out m_Client1Events);
@@ -57,28 +65,25 @@ public IEnumerator PingPong()
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
 
             var ping = new ArraySegment<byte>(Encoding.ASCII.GetBytes("ping"));
-            m_Client1.Send(m_Client1.ServerClientId, ping, NetworkDelivery.ReliableSequenced);
+            m_Client1.Send(m_Client1.ServerClientId, ping, delivery);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
 
             Assert.That(m_ServerEvents[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("ping")));
 
             var pong = new ArraySegment<byte>(Encoding.ASCII.GetBytes("pong"));
-            m_Server.Send(m_ServerEvents[0].ClientID, pong, NetworkDelivery.ReliableSequenced);
+            m_Server.Send(m_ServerEvents[0].ClientID, pong, delivery);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_Client1Events);
 
             Assert.That(m_Client1Events[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("pong")));
 
-            // server.Shutdown();
-            // client.Shutdown();
-
             yield return null;
         }
 
         // Check if can make a simple data exchange (both ways at a time).
         [UnityTest]
-        public IEnumerator PingPongSimultaneous()
+        public IEnumerator PingPongSimultaneous([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
         {
             InitializeTransport(out m_Server, out m_ServerEvents);
             InitializeTransport(out m_Client1, out m_Client1Events);
@@ -89,8 +94,8 @@ public IEnumerator PingPongSimultaneous()
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
 
             var ping = new ArraySegment<byte>(Encoding.ASCII.GetBytes("ping"));
-            m_Server.Send(m_ServerEvents[0].ClientID, ping, NetworkDelivery.ReliableSequenced);
-            m_Client1.Send(m_Client1.ServerClientId, ping, NetworkDelivery.ReliableSequenced);
+            m_Server.Send(m_ServerEvents[0].ClientID, ping, delivery);
+            m_Client1.Send(m_Client1.ServerClientId, ping, delivery);
 
             // Once one event is in the other should be too.
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
@@ -99,8 +104,8 @@ public IEnumerator PingPongSimultaneous()
             Assert.That(m_Client1Events[1].Data, Is.EquivalentTo(Encoding.ASCII.GetBytes("ping")));
 
             var pong = new ArraySegment<byte>(Encoding.ASCII.GetBytes("pong"));
-            m_Server.Send(m_ServerEvents[0].ClientID, pong, NetworkDelivery.ReliableSequenced);
-            m_Client1.Send(m_Client1.ServerClientId, pong, NetworkDelivery.ReliableSequenced);
+            m_Server.Send(m_ServerEvents[0].ClientID, pong, delivery);
+            m_Client1.Send(m_Client1.ServerClientId, pong, delivery);
 
             // Once one event is in the other should be too.
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
@@ -112,7 +117,7 @@ public IEnumerator PingPongSimultaneous()
         }
 
         [UnityTest]
-        public IEnumerator FilledSendQueueSingleSend()
+        public IEnumerator FilledSendQueueSingleSend([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
         {
             InitializeTransport(out m_Server, out m_ServerEvents);
             InitializeTransport(out m_Client1, out m_Client1Events);
@@ -123,15 +128,15 @@ public IEnumerator FilledSendQueueSingleSend()
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
 
             var payload = new ArraySegment<byte>(new byte[UnityTransport.InitialBatchQueueSize]);
-            m_Client1.Send(m_Client1.ServerClientId, payload, NetworkDelivery.ReliableFragmentedSequenced);
+            m_Client1.Send(m_Client1.ServerClientId, payload, delivery);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
 
             yield return null;
         }
 
         [UnityTest]
-        public IEnumerator FilledSendQueueMultipleSends()
+        public IEnumerator FilledSendQueueMultipleSends([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
         {
             InitializeTransport(out m_Server, out m_ServerEvents);
             InitializeTransport(out m_Client1, out m_Client1Events);
@@ -149,7 +154,7 @@ public IEnumerator FilledSendQueueMultipleSends()
                 // Without that we wouldn't fill the send queue; it would get flushed right when we
                 // try to send the last message.
                 var payload = new ArraySegment<byte>(new byte[1024 - 4]);
-                m_Client1.Send(m_Client1.ServerClientId, payload, NetworkDelivery.ReliableFragmentedSequenced);
+                m_Client1.Send(m_Client1.ServerClientId, payload, delivery);
             }
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
@@ -162,7 +167,7 @@ public IEnumerator FilledSendQueueMultipleSends()
 
         // Check making multiple sends to a client in a single frame.
         [UnityTest]
-        public IEnumerator MultipleSendsSingleFrame()
+        public IEnumerator MultipleSendsSingleFrame([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
         {
             InitializeTransport(out m_Server, out m_ServerEvents);
             InitializeTransport(out m_Client1, out m_Client1Events);
@@ -173,10 +178,10 @@ public IEnumerator MultipleSendsSingleFrame()
             yield return WaitForNetworkEvent(NetworkEvent.Connect, m_ServerEvents);
 
             var data1 = new ArraySegment<byte>(new byte[] { 11 });
-            m_Client1.Send(m_Client1.ServerClientId, data1, NetworkDelivery.ReliableSequenced);
+            m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
 
             var data2 = new ArraySegment<byte>(new byte[] { 22 });
-            m_Client1.Send(m_Client1.ServerClientId, data2, NetworkDelivery.ReliableSequenced);
+            m_Client1.Send(m_Client1.ServerClientId, data2, delivery);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
 
@@ -191,7 +196,7 @@ public IEnumerator MultipleSendsSingleFrame()
 
         // Check sending data to multiple clients.
         [UnityTest]
-        public IEnumerator SendMultipleClients()
+        public IEnumerator SendMultipleClients([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
         {
             InitializeTransport(out m_Server, out m_ServerEvents);
             InitializeTransport(out m_Client1, out m_Client1Events);
@@ -207,10 +212,10 @@ public IEnumerator SendMultipleClients()
             Assert.AreEqual(2, m_ServerEvents.Count);
 
             var data1 = new ArraySegment<byte>(new byte[] { 11 });
-            m_Server.Send(m_ServerEvents[0].ClientID, data1, NetworkDelivery.ReliableSequenced);
+            m_Server.Send(m_ServerEvents[0].ClientID, data1, delivery);
 
             var data2 = new ArraySegment<byte>(new byte[] { 22 });
-            m_Server.Send(m_ServerEvents[1].ClientID, data2, NetworkDelivery.ReliableSequenced);
+            m_Server.Send(m_ServerEvents[1].ClientID, data2, delivery);
 
             // Once one has received its data, the other should have too.
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_Client1Events);
@@ -228,7 +233,7 @@ public IEnumerator SendMultipleClients()
 
         // Check receiving data from multiple clients.
         [UnityTest]
-        public IEnumerator ReceiveMultipleClients()
+        public IEnumerator ReceiveMultipleClients([ValueSource("k_DeliveryParameters")] NetworkDelivery delivery)
         {
             InitializeTransport(out m_Server, out m_ServerEvents);
             InitializeTransport(out m_Client1, out m_Client1Events);
@@ -244,10 +249,10 @@ public IEnumerator ReceiveMultipleClients()
             Assert.AreEqual(1, m_Client2Events.Count);
 
             var data1 = new ArraySegment<byte>(new byte[] { 11 });
-            m_Client1.Send(m_Client1.ServerClientId, data1, NetworkDelivery.ReliableSequenced);
+            m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
 
             var data2 = new ArraySegment<byte>(new byte[] { 22 });
-            m_Client2.Send(m_Client2.ServerClientId, data2, NetworkDelivery.ReliableSequenced);
+            m_Client2.Send(m_Client2.ServerClientId, data2, delivery);
 
             yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);