optimize receiving speed. removed one data copy

RevenantX · RevenantX · commit b30de86187ce · 2021-02-15T22:09:52.000+02:00
diff --git a/LiteNetLib/NetManager.cs b/LiteNetLib/NetManager.cs
@@ -147,7 +147,7 @@ object IEnumerator.Current
 #if DEBUG
         private struct IncomingData
         {
-            public byte[] Data;
+            public NetPacket Data;
             public IPEndPoint EndPoint;
             public DateTime TimeWhenGet;
         }
@@ -720,7 +720,7 @@ private void ProcessDelayedPackets()
                         var incomingData = _pingSimulationList[i];
                         if (incomingData.TimeWhenGet <= time)
                         {
-                            DataReceived(incomingData.Data, incomingData.Data.Length, incomingData.EndPoint);
+                            DataReceived(incomingData.Data, incomingData.EndPoint);
                             _pingSimulationList.RemoveAt(i);
                             i--;
                         }
@@ -789,7 +789,7 @@ public void ManualReceive()
             ProcessDelayedPackets();
         }
 
-        internal void OnMessageReceived(byte[] data, int length, SocketError errorCode, IPEndPoint remoteEndPoint)
+        internal void OnMessageReceived(NetPacket packet, SocketError errorCode, IPEndPoint remoteEndPoint)
         {
             if (errorCode != 0)
             {
@@ -808,14 +808,11 @@ internal void OnMessageReceived(byte[] data, int length, SocketError errorCode,
                 int latency = _randomGenerator.Next(SimulationMinLatency, SimulationMaxLatency);
                 if (latency > MinLatencyThreshold)
                 {
-                    byte[] holdedData = new byte[length];
-                    Buffer.BlockCopy(data, 0, holdedData, 0, length);
-
                     lock (_pingSimulationList)
                     {
                         _pingSimulationList.Add(new IncomingData
                         {
-                            Data = holdedData,
+                            Data = packet,
                             EndPoint = remoteEndPoint,
                             TimeWhenGet = DateTime.UtcNow.AddMilliseconds(latency)
                         });
@@ -828,7 +825,7 @@ internal void OnMessageReceived(byte[] data, int length, SocketError errorCode,
             try
             {
                 //ProcessEvents
-                DataReceived(data, length, remoteEndPoint);
+                DataReceived(packet, remoteEndPoint);
             }
             catch(Exception e)
             {
@@ -963,27 +960,27 @@ private void ProcessConnectRequest(
             CreateEvent(NetEvent.EType.ConnectionRequest, connectionRequest: req);
         }
 
-        private void DataReceived(byte[] reusableBuffer, int count, IPEndPoint remoteEndPoint)
+        private void DataReceived(NetPacket packet, IPEndPoint remoteEndPoint)
         {
             if (EnableStatistics)
             {
                 Statistics.IncrementPacketsReceived();
-                Statistics.AddBytesReceived(count);
+                Statistics.AddBytesReceived(packet.Size);
             }
 
             if (_ntpRequests.Count > 0)
             {
                 NtpRequest request;
                 if (_ntpRequests.TryGetValue(remoteEndPoint, out request))
                 {
-                    if (count < 48)
+                    if (packet.Size < 48)
                     {
-                        NetDebug.Write(NetLogLevel.Trace, "NTP response too short: {}", count);
+                        NetDebug.Write(NetLogLevel.Trace, "NTP response too short: {}", packet.Size);
                         return;
                     }
 
-                    byte[] copiedData = new byte[count];
-                    Buffer.BlockCopy(reusableBuffer, 0, copiedData, 0, count);
+                    byte[] copiedData = new byte[packet.Size];
+                    Buffer.BlockCopy(packet.RawData, 0, copiedData, 0, packet.Size);
                     NtpPacket ntpPacket = NtpPacket.FromServerResponse(copiedData, DateTime.UtcNow);
                     try
                     {
@@ -1005,24 +1002,18 @@ private void DataReceived(byte[] reusableBuffer, int count, IPEndPoint remoteEnd
                 }
             }
 
-            int start = 0;
             if (_extraPacketLayer != null)
             {
-                _extraPacketLayer.ProcessInboundPacket(remoteEndPoint, ref reusableBuffer, ref start, ref count);
-                if (count == 0)
+                int start = 0;
+                _extraPacketLayer.ProcessInboundPacket(remoteEndPoint, ref packet.RawData, ref start, ref packet.Size);
+                if (packet.Size == 0)
                     return;
             }
 
-            //empty packet
-            if (reusableBuffer[start] == (byte) PacketProperty.Empty)
-                return;
-
-            //Try read packet
-            NetPacket packet = NetPacketPool.GetPacket(count);
-            if (!packet.FromBytes(reusableBuffer, start, count))
+            if (!packet.Verify())
             {
-                NetPacketPool.Recycle(packet);
                 NetDebug.WriteError("[NM] DataReceived: bad!");
+                NetPacketPool.Recycle(packet);
                 return;
             }
 
diff --git a/LiteNetLib/NetPacket.cs b/LiteNetLib/NetPacket.cs
@@ -151,28 +151,14 @@ public int GetHeaderSize()
             return HeaderSizes[RawData[0] & 0x1F];
         }
 
-        //Packet constructor from byte array
-        public bool FromBytes(byte[] data, int start, int packetSize)
+        public bool Verify()
         {
-            //Reading property
-            byte property = (byte)(data[start] & 0x1F);
-            bool fragmented = (data[start] & 0x80) != 0;
-
+            byte property = (byte)(RawData[0] & 0x1F);
             if (property > LastProperty)
                 return false;
-
             int headerSize = HeaderSizes[property];
-
-            if (packetSize < headerSize ||
-               (fragmented && packetSize < headerSize + NetConstants.FragmentHeaderSize) ||
-               data.Length < start + packetSize)
-            {
-                return false;
-            }
-
-            Buffer.BlockCopy(data, start, RawData, 0, packetSize);
-            Size = (ushort)packetSize;
-            return true;
+            bool fragmented = (RawData[0] & 0x80) != 0;
+            return Size >= headerSize && (!fragmented || Size >= headerSize + NetConstants.FragmentHeaderSize);
         }
     }
 
diff --git a/LiteNetLib/NetPeer.cs b/LiteNetLib/NetPeer.cs
@@ -920,7 +920,10 @@ internal void ProcessPacket(NetPacket packet)
                         ushort size = BitConverter.ToUInt16(packet.RawData, pos);
                         pos += 2;
                         NetPacket mergedPacket = _packetPool.GetPacket(size);
-                        if (!mergedPacket.FromBytes(packet.RawData, pos, size))
+                        Buffer.BlockCopy(packet.RawData, pos, mergedPacket.RawData, 0, size);
+                        mergedPacket.Size = size;
+
+                        if (!mergedPacket.Verify() || packet.RawData.Length < pos + size)
                         {
                             _packetPool.Recycle(packet);
                             break;
diff --git a/LiteNetLib/NetSocket.cs b/LiteNetLib/NetSocket.cs
@@ -158,7 +158,7 @@ private bool ProcessError(SocketException ex, EndPoint bufferEndPoint)
                 default:
                     NetDebug.WriteError("[R]Error code: {0} - {1}", (int)ex.SocketErrorCode,
                         ex.ToString());
-                    _listener.OnMessageReceived(null, 0, ex.SocketErrorCode, (IPEndPoint)bufferEndPoint);
+                    _listener.OnMessageReceived(null, ex.SocketErrorCode, (IPEndPoint)bufferEndPoint);
                     break;
             }
             return false;
@@ -182,11 +182,12 @@ private bool ManualReceive(Socket socket, EndPoint bufferEndPoint, byte[] receiv
                     return false;
                 while (available > 0)
                 {
-                    result = socket.ReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None,
+                    var packet = _listener.NetPacketPool.GetPacket(NetConstants.MaxPacketSize);
+                    packet.Size = socket.ReceiveFrom(packet.RawData, 0, NetConstants.MaxPacketSize, SocketFlags.None,
                         ref bufferEndPoint);
                     NetDebug.Write(NetLogLevel.Trace, "[R]Received data from {0}, result: {1}", bufferEndPoint.ToString(), result);
-                    _listener.OnMessageReceived(receiveBuffer, result, 0, (IPEndPoint)bufferEndPoint);
-                    available -= result;
+                    _listener.OnMessageReceived(packet, 0, (IPEndPoint)bufferEndPoint);
+                    available -= packet.Size;
                 }
             }
             catch (SocketException ex)
@@ -204,18 +205,19 @@ private void ReceiveLogic(object state)
         {
             Socket socket = (Socket)state;
             EndPoint bufferEndPoint = new IPEndPoint(socket.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, 0);
-            byte[] receiveBuffer = new byte[NetConstants.MaxPacketSize];
 
             while (IsActive())
             {
                 int result;
+                NetPacket packet;
 
                 //Reading data
                 try
                 {
                     if (socket.Available == 0 && !socket.Poll(ReceivePollingTime, SelectMode.SelectRead))
                         continue;
-                    result = socket.ReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None,
+                    packet = _listener.NetPacketPool.GetPacket(NetConstants.MaxPacketSize);
+                    packet.Size = socket.ReceiveFrom(packet.RawData, 0, NetConstants.MaxPacketSize, SocketFlags.None,
                         ref bufferEndPoint);
                 }
                 catch (SocketException ex)
@@ -231,7 +233,7 @@ private void ReceiveLogic(object state)
 
                 //All ok!
                 NetDebug.Write(NetLogLevel.Trace, "[R]Received data from {0}, result: {1}", bufferEndPoint.ToString(), result);
-                _listener.OnMessageReceived(receiveBuffer, result, 0, (IPEndPoint)bufferEndPoint);
+                _listener.OnMessageReceived(packet, 0, (IPEndPoint)bufferEndPoint);
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ object IEnumerator.Current`
`147`	`147`	`#if DEBUG`
`148`	`148`	`private struct IncomingData`
`149`	`149`	`{`
`150`		`- public byte[] Data;`
	`150`	`+ public NetPacket Data;`
`151`	`151`	`public IPEndPoint EndPoint;`
`152`	`152`	`public DateTime TimeWhenGet;`
`153`	`153`	`}`
`@@ -720,7 +720,7 @@ private void ProcessDelayedPackets()`
`720`	`720`	`var incomingData = _pingSimulationList[i];`
`721`	`721`	`if (incomingData.TimeWhenGet <= time)`
`722`	`722`	`{`
`723`		`- DataReceived(incomingData.Data, incomingData.Data.Length, incomingData.EndPoint);`
	`723`	`+ DataReceived(incomingData.Data, incomingData.EndPoint);`
`724`	`724`	`_pingSimulationList.RemoveAt(i);`
`725`	`725`	`i--;`
`726`	`726`	`}`
`@@ -789,7 +789,7 @@ public void ManualReceive()`
`789`	`789`	`ProcessDelayedPackets();`
`790`	`790`	`}`
`791`	`791`
`792`		`- internal void OnMessageReceived(byte[] data, int length, SocketError errorCode, IPEndPoint remoteEndPoint)`
	`792`	`+ internal void OnMessageReceived(NetPacket packet, SocketError errorCode, IPEndPoint remoteEndPoint)`
`793`	`793`	`{`
`794`	`794`	`if (errorCode != 0)`
`795`	`795`	`{`
`@@ -808,14 +808,11 @@ internal void OnMessageReceived(byte[] data, int length, SocketError errorCode,`
`808`	`808`	`int latency = _randomGenerator.Next(SimulationMinLatency, SimulationMaxLatency);`
`809`	`809`	`if (latency > MinLatencyThreshold)`
`810`	`810`	`{`
`811`		`- byte[] holdedData = new byte[length];`
`812`		`- Buffer.BlockCopy(data, 0, holdedData, 0, length);`
`813`		`-`
`814`	`811`	`lock (_pingSimulationList)`
`815`	`812`	`{`
`816`	`813`	`_pingSimulationList.Add(new IncomingData`
`817`	`814`	`{`
`818`		`- Data = holdedData,`
	`815`	`+ Data = packet,`
`819`	`816`	`EndPoint = remoteEndPoint,`
`820`	`817`	`TimeWhenGet = DateTime.UtcNow.AddMilliseconds(latency)`
`821`	`818`	`});`
`@@ -828,7 +825,7 @@ internal void OnMessageReceived(byte[] data, int length, SocketError errorCode,`
`828`	`825`	`try`
`829`	`826`	`{`
`830`	`827`	`//ProcessEvents`
`831`		`- DataReceived(data, length, remoteEndPoint);`
	`828`	`+ DataReceived(packet, remoteEndPoint);`
`832`	`829`	`}`
`833`	`830`	`catch(Exception e)`
`834`	`831`	`{`
`@@ -963,27 +960,27 @@ private void ProcessConnectRequest(`
`963`	`960`	`CreateEvent(NetEvent.EType.ConnectionRequest, connectionRequest: req);`
`964`	`961`	`}`
`965`	`962`
`966`		`- private void DataReceived(byte[] reusableBuffer, int count, IPEndPoint remoteEndPoint)`
	`963`	`+ private void DataReceived(NetPacket packet, IPEndPoint remoteEndPoint)`
`967`	`964`	`{`
`968`	`965`	`if (EnableStatistics)`
`969`	`966`	`{`
`970`	`967`	`Statistics.IncrementPacketsReceived();`
`971`		`- Statistics.AddBytesReceived(count);`
	`968`	`+ Statistics.AddBytesReceived(packet.Size);`
`972`	`969`	`}`
`973`	`970`
`974`	`971`	`if (_ntpRequests.Count > 0)`
`975`	`972`	`{`
`976`	`973`	`NtpRequest request;`
`977`	`974`	`if (_ntpRequests.TryGetValue(remoteEndPoint, out request))`
`978`	`975`	`{`
`979`		`- if (count < 48)`
	`976`	`+ if (packet.Size < 48)`
`980`	`977`	`{`
`981`		`- NetDebug.Write(NetLogLevel.Trace, "NTP response too short: {}", count);`
	`978`	`+ NetDebug.Write(NetLogLevel.Trace, "NTP response too short: {}", packet.Size);`
`982`	`979`	`return;`
`983`	`980`	`}`
`984`	`981`
`985`		`- byte[] copiedData = new byte[count];`
`986`		`- Buffer.BlockCopy(reusableBuffer, 0, copiedData, 0, count);`
	`982`	`+ byte[] copiedData = new byte[packet.Size];`
	`983`	`+ Buffer.BlockCopy(packet.RawData, 0, copiedData, 0, packet.Size);`
`987`	`984`	`NtpPacket ntpPacket = NtpPacket.FromServerResponse(copiedData, DateTime.UtcNow);`
`988`	`985`	`try`
`989`	`986`	`{`
`@@ -1005,24 +1002,18 @@ private void DataReceived(byte[] reusableBuffer, int count, IPEndPoint remoteEnd`
`1005`	`1002`	`}`
`1006`	`1003`	`}`
`1007`	`1004`
`1008`		`- int start = 0;`
`1009`	`1005`	`if (_extraPacketLayer != null)`
`1010`	`1006`	`{`
`1011`		`- _extraPacketLayer.ProcessInboundPacket(remoteEndPoint, ref reusableBuffer, ref start, ref count);`
`1012`		`- if (count == 0)`
	`1007`	`+ int start = 0;`
	`1008`	`+ _extraPacketLayer.ProcessInboundPacket(remoteEndPoint, ref packet.RawData, ref start, ref packet.Size);`
	`1009`	`+ if (packet.Size == 0)`
`1013`	`1010`	`return;`
`1014`	`1011`	`}`
`1015`	`1012`
`1016`		`- //empty packet`
`1017`		`- if (reusableBuffer[start] == (byte) PacketProperty.Empty)`
`1018`		`- return;`
`1019`		`-`
`1020`		`- //Try read packet`
`1021`		`- NetPacket packet = NetPacketPool.GetPacket(count);`
`1022`		`- if (!packet.FromBytes(reusableBuffer, start, count))`
	`1013`	`+ if (!packet.Verify())`
`1023`	`1014`	`{`
`1024`		`- NetPacketPool.Recycle(packet);`
`1025`	`1015`	`NetDebug.WriteError("[NM] DataReceived: bad!");`
	`1016`	`+ NetPacketPool.Recycle(packet);`
`1026`	`1017`	`return;`
`1027`	`1018`	`}`
`1028`	`1019`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ private bool ProcessError(SocketException ex, EndPoint bufferEndPoint)`
`158`	`158`	`default:`
`159`	`159`	`NetDebug.WriteError("[R]Error code: {0} - {1}", (int)ex.SocketErrorCode,`
`160`	`160`	`ex.ToString());`
`161`		`- _listener.OnMessageReceived(null, 0, ex.SocketErrorCode, (IPEndPoint)bufferEndPoint);`
	`161`	`+ _listener.OnMessageReceived(null, ex.SocketErrorCode, (IPEndPoint)bufferEndPoint);`
`162`	`162`	`break;`
`163`	`163`	`}`
`164`	`164`	`return false;`
`@@ -182,11 +182,12 @@ private bool ManualReceive(Socket socket, EndPoint bufferEndPoint, byte[] receiv`
`182`	`182`	`return false;`
`183`	`183`	`while (available > 0)`
`184`	`184`	`{`
`185`		`- result = socket.ReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None,`
	`185`	`+ var packet = _listener.NetPacketPool.GetPacket(NetConstants.MaxPacketSize);`
	`186`	`+ packet.Size = socket.ReceiveFrom(packet.RawData, 0, NetConstants.MaxPacketSize, SocketFlags.None,`
`186`	`187`	`ref bufferEndPoint);`
`187`	`188`	`NetDebug.Write(NetLogLevel.Trace, "[R]Received data from {0}, result: {1}", bufferEndPoint.ToString(), result);`
`188`		`- _listener.OnMessageReceived(receiveBuffer, result, 0, (IPEndPoint)bufferEndPoint);`
`189`		`- available -= result;`
	`189`	`+ _listener.OnMessageReceived(packet, 0, (IPEndPoint)bufferEndPoint);`
	`190`	`+ available -= packet.Size;`
`190`	`191`	`}`
`191`	`192`	`}`
`192`	`193`	`catch (SocketException ex)`
`@@ -204,18 +205,19 @@ private void ReceiveLogic(object state)`
`204`	`205`	`{`
`205`	`206`	`Socket socket = (Socket)state;`
`206`	`207`	`EndPoint bufferEndPoint = new IPEndPoint(socket.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, 0);`
`207`		`- byte[] receiveBuffer = new byte[NetConstants.MaxPacketSize];`
`208`	`208`
`209`	`209`	`while (IsActive())`
`210`	`210`	`{`
`211`	`211`	`int result;`
	`212`	`+ NetPacket packet;`
`212`	`213`
`213`	`214`	`//Reading data`
`214`	`215`	`try`
`215`	`216`	`{`
`216`	`217`	`if (socket.Available == 0 && !socket.Poll(ReceivePollingTime, SelectMode.SelectRead))`
`217`	`218`	`continue;`
`218`		`- result = socket.ReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None,`
	`219`	`+ packet = _listener.NetPacketPool.GetPacket(NetConstants.MaxPacketSize);`
	`220`	`+ packet.Size = socket.ReceiveFrom(packet.RawData, 0, NetConstants.MaxPacketSize, SocketFlags.None,`
`219`	`221`	`ref bufferEndPoint);`
`220`	`222`	`}`
`221`	`223`	`catch (SocketException ex)`
`@@ -231,7 +233,7 @@ private void ReceiveLogic(object state)`
`231`	`233`
`232`	`234`	`//All ok!`
`233`	`235`	`NetDebug.Write(NetLogLevel.Trace, "[R]Received data from {0}, result: {1}", bufferEndPoint.ToString(), result);`
`234`		`- _listener.OnMessageReceived(receiveBuffer, result, 0, (IPEndPoint)bufferEndPoint);`
	`236`	`+ _listener.OnMessageReceived(packet, 0, (IPEndPoint)bufferEndPoint);`
`235`	`237`	`}`
`236`	`238`	`}`
`237`	`239`