Merged master

Assets/Mirror/Components/NetworkTransformReliable/NetworkTransformReliable.cs

@@ -109,7 +109,6 @@ protected virtual void UpdateClient()
                 // only while we have snapshots
                 if (clientSnapshots.Count > 0)
                 {
-
                     // step the interpolation without touching time.
                     // NetworkClient is responsible for time globally.
                     SnapshotInterpolation.StepInterpolation(
@@ -122,7 +121,6 @@ protected virtual void UpdateClient()
                     // interpolate & apply
                     TransformSnapshot computed = TransformSnapshot.Interpolate(from, to, t);
                     Apply(computed, to);
-
                 }
             }
         }

Assets/Mirror/Components/NetworkTransformUnreliable/NetworkTransform.cs

@@ -46,7 +46,7 @@ void Update()
             else if (isClient) UpdateClient();
         }
 
-        void UpdateServer()
+        void UpdateServerBroadcast()
         {
             // broadcast to all clients each 'sendInterval'
             // (client with authority will drop the rpc)
@@ -118,7 +118,10 @@ void UpdateServer()
                 }
 #endif
             }
+        }
 
+        void UpdateServerInterpolation()
+        {
             // apply buffered snapshots IF client authority
             // -> in server authority, server moves the object
             //    so no need to apply any snapshots there.
@@ -131,8 +134,8 @@ void UpdateServer()
                 connectionToClient != null &&
                 !isOwned)
             {
-                if (serverSnapshots.Count > 0)
+                if (serverSnapshots.Count == 0) return;
-                {
+
                 // step the transform interpolation without touching time.
                 // NetworkClient is responsible for time globally.
                 SnapshotInterpolation.StepInterpolation(
@@ -147,12 +150,17 @@ void UpdateServer()
                 Apply(computed, to);
             }
         }
+
+        void UpdateServer()
+        {
+            // broadcast to all clients each 'sendInterval'
+            UpdateServerBroadcast();
+
+            // apply buffered snapshots IF client authority
+            UpdateServerInterpolation();
         }
 
-        void UpdateClient()
+        void UpdateClientBroadcast()
-        {
-            // client authority, and local player (= allowed to move myself)?
-            if (IsClientWithAuthority)
         {
             // https://github.com/vis2k/Mirror/pull/2992/
             if (!NetworkClient.ready) return;
@@ -217,13 +225,12 @@ void UpdateClient()
 #endif
             }
         }
-            // for all other clients (and for local player if !authority),
+
-            // we need to apply snapshots from the buffer
+        void UpdateClientInterpolation()
-            else
         {
             // only while we have snapshots
-                if (clientSnapshots.Count > 0)
+            if (clientSnapshots.Count == 0) return;
-                {
+
             // step the interpolation without touching time.
             // NetworkClient is responsible for time globally.
             SnapshotInterpolation.StepInterpolation(
@@ -237,6 +244,19 @@ void UpdateClient()
             TransformSnapshot computed = TransformSnapshot.Interpolate(from, to, t);
             Apply(computed, to);
         }
+
+        void UpdateClient()
+        {
+            // client authority, and local player (= allowed to move myself)?
+            if (IsClientWithAuthority)
+            {
+                UpdateClientBroadcast();
+            }
+            // for all other clients (and for local player if !authority),
+            // we need to apply snapshots from the buffer
+            else
+            {
+                UpdateClientInterpolation();
             }
         }
 

Assets/Mirror/Transports/KCP/kcp2k/VERSION.txt

@@ -1,3 +1,11 @@
+V1.33 [2023-03-14]
+- perf: KcpServer/Client RawReceive now call socket.Poll to avoid non-blocking
+  socket's allocating a new SocketException in case they WouldBlock.
+  fixes https://github.com/MirrorNetworking/Mirror/issues/3413
+- perf: KcpServer/Client RawSend now call socket.Poll to avoid non-blocking
+  socket's allocating a new SocketException in case they WouldBlock.
+  fixes https://github.com/MirrorNetworking/Mirror/issues/3413
+
 V1.32 [2023-03-12]
 - fix: KcpPeer RawInput now doesn't disconnect in case of random internet noise
 

Assets/Mirror/Transports/KCP/kcp2k/highlevel/KcpClient.cs

@@ -131,6 +131,15 @@ protected virtual bool RawReceive(out ArraySegment<byte> segment)
 
             try
             {
+                // when using non-blocking sockets, ReceiveFrom may return WouldBlock.
+                // in C#, WouldBlock throws a SocketException, which is expected.
+                // unfortunately, creating the SocketException allocates in C#.
+                // let's poll first to avoid the WouldBlock allocation.
+                // note that this entirely to avoid allocations.
+                // non-blocking UDP doesn't need Poll in other languages.
+                // and the code still works without the Poll call.
+                if (!socket.Poll(0, SelectMode.SelectRead)) return false;
+
                 // ReceiveFrom allocates. we used bound Receive.
                 // returns amount of bytes written into buffer.
                 // throws SocketException if datagram was larger than buffer.
@@ -166,6 +175,15 @@ protected virtual void RawSend(ArraySegment<byte> data)
         {
             try
             {
+                // when using non-blocking sockets, SendTo may return WouldBlock.
+                // in C#, WouldBlock throws a SocketException, which is expected.
+                // unfortunately, creating the SocketException allocates in C#.
+                // let's poll first to avoid the WouldBlock allocation.
+                // note that this entirely to avoid allocations.
+                // non-blocking UDP doesn't need Poll in other languages.
+                // and the code still works without the Poll call.
+                if (!socket.Poll(0, SelectMode.SelectWrite)) return;
+
                 socket.Send(data.Array, data.Offset, data.Count, SocketFlags.None);
             }
             // for non-blocking sockets, SendTo may throw WouldBlock.

Assets/Mirror/Transports/KCP/kcp2k/highlevel/KcpServer.cs

@@ -154,6 +154,15 @@ protected virtual bool RawReceiveFrom(out ArraySegment<byte> segment, out int co
 
             try
             {
+                // when using non-blocking sockets, ReceiveFrom may return WouldBlock.
+                // in C#, WouldBlock throws a SocketException, which is expected.
+                // unfortunately, creating the SocketException allocates in C#.
+                // let's poll first to avoid the WouldBlock allocation.
+                // note that this entirely to avoid allocations.
+                // non-blocking UDP doesn't need Poll in other languages.
+                // and the code still works without the Poll call.
+                if (!socket.Poll(0, SelectMode.SelectRead)) return false;
+
                 // NOTE: ReceiveFrom allocates.
                 //   we pass our IPEndPoint to ReceiveFrom.
                 //   receive from calls newClientEP.Create(socketAddr).
@@ -206,11 +215,20 @@ protected virtual void RawSend(int connectionId, ArraySegment<byte> data)
                 return;
             }
 
+            try
+            {
+                // when using non-blocking sockets, SendTo may return WouldBlock.
+                // in C#, WouldBlock throws a SocketException, which is expected.
+                // unfortunately, creating the SocketException allocates in C#.
+                // let's poll first to avoid the WouldBlock allocation.
+                // note that this entirely to avoid allocations.
+                // non-blocking UDP doesn't need Poll in other languages.
+                // and the code still works without the Poll call.
+                if (!socket.Poll(0, SelectMode.SelectWrite)) return;
+
                 // send to the the endpoint.
                 // do not send to 'newClientEP', as that's always reused.
                 // fixes https://github.com/MirrorNetworking/Mirror/issues/3296
-            try
-            {
                 socket.SendTo(data.Array, data.Offset, data.Count, SocketFlags.None, connection.remoteEndPoint);
             }
             // for non-blocking sockets, SendTo may throw WouldBlock.