Remove unneeded lock, optimize connection statistics to be more x86 friendly

diff --git a/Hazel.sln b/Hazel.sln
index 8ca98400f80f4a927a8cf6a913a2c67b57effc2f..29e9e707fff51d0edec38594917dfa4e7e3e50b6 100644 (file)
--- a/Hazel.sln
+++ b/Hazel.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
+# Visual Studio 15
+VisualStudioVersion = 15.0.28307.539
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hazel", "Hazel\Hazel.csproj", "{02CFBD30-D77D-400F-94B2-700F60EFDD7F}"
 EndProject
@@ -9,6 +9,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hazel.UnitTests", "Hazel.Un
 EndProject
 Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Hazel.Documentation", "Hazel.Documentation\Hazel.Documentation.shfbproj", "{B90BB577-2080-4C22-AE86-FB0CCFB40920}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Benchmark", "Benchmark\Benchmark.csproj", "{009A1440-7A39-498F-B27A-ACDEF1FE74B6}"
+EndProject
 Global
        GlobalSection(SolutionConfigurationPlatforms) = preSolution
                Debug|Any CPU = Debug|Any CPU
@@ -26,8 +28,15 @@ Global
                {B90BB577-2080-4C22-AE86-FB0CCFB40920}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
                {B90BB577-2080-4C22-AE86-FB0CCFB40920}.Debug|Any CPU.Build.0 = Debug|Any CPU
                {B90BB577-2080-4C22-AE86-FB0CCFB40920}.Release|Any CPU.ActiveCfg = Release|Any CPU
+               {009A1440-7A39-498F-B27A-ACDEF1FE74B6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+               {009A1440-7A39-498F-B27A-ACDEF1FE74B6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+               {009A1440-7A39-498F-B27A-ACDEF1FE74B6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+               {009A1440-7A39-498F-B27A-ACDEF1FE74B6}.Release|Any CPU.Build.0 = Release|Any CPU
        EndGlobalSection
        GlobalSection(SolutionProperties) = preSolution
                HideSolutionNode = FALSE
        EndGlobalSection
+       GlobalSection(ExtensibilityGlobals) = postSolution
+               SolutionGuid = {8AC8C0A6-FB6B-4E63-9042-EDF10C6A51B8}
+       EndGlobalSection
 EndGlobal

diff --git a/Hazel/ConnectionStatistics.cs b/Hazel/ConnectionStatistics.cs
index be8770e087f8e6c95ea437f740c0dcf3673928e3..dc44c08eff199db5436aa66fb5764edbe7b0c70d 100644 (file)
--- a/Hazel/ConnectionStatistics.cs
+++ b/Hazel/ConnectionStatistics.cs
@@ -16,7 +16,7 @@ namespace Hazel
         /// <summary>
         ///     The total number of messages sent.
         /// </summary>
-        public long MessagesSent
+        public int MessagesSent
         {
             get
             {
@@ -32,18 +32,18 @@ namespace Hazel
         ///     each time that LogUnreliableSend is called by the Connection. Messages that caused an error are not 
         ///     counted and messages are only counted once all other operations in the send are complete.
         /// </remarks>
-        public long UnreliableMessagesSent
+        public int UnreliableMessagesSent
         {
             get
             {
-                return Interlocked.Read(ref unreliableMessagesSent);
+                return unreliableMessagesSent;
             }
         }
 
         /// <summary>
         ///     The number of unreliable messages sent.
         /// </summary>
-        long unreliableMessagesSent;
+        int unreliableMessagesSent;
 
         /// <summary>
         ///     The number of reliable messages sent.
@@ -53,18 +53,18 @@ namespace Hazel
         ///     each time that LogReliableSend is called by the Connection. Messages that caused an error are not 
         ///     counted and messages are only counted once all other operations in the send are complete.
         /// </remarks>
-        public long ReliableMessagesSent
+        public int ReliableMessagesSent
         {
             get
             {
-                return Interlocked.Read(ref reliableMessagesSent);
+                return reliableMessagesSent;
             }
         }
 
         /// <summary>
         ///     The number of unreliable messages sent.
         /// </summary>
-        long reliableMessagesSent;
+        int reliableMessagesSent;
 
         /// <summary>
         ///     The number of fragmented messages sent.
@@ -74,18 +74,18 @@ namespace Hazel
         ///     each time that LogFragmentedSend is called by the Connection. Messages that caused an error are not 
         ///     counted and messages are only counted once all other operations in the send are complete.
         /// </remarks>
-        public long FragmentedMessagesSent
+        public int FragmentedMessagesSent
         {
             get
             {
-                return Interlocked.Read(ref fragmentedMessagesSent);
+                return fragmentedMessagesSent;
             }
         }
 
         /// <summary>
         ///     The number of fragmented messages sent.
         /// </summary>
-        long fragmentedMessagesSent;
+        int fragmentedMessagesSent;
 
         /// <summary>
         ///     The number of acknowledgement messages sent.
@@ -95,18 +95,18 @@ namespace Hazel
         ///     each time that LogAcknowledgementSend is called by the Connection. Messages that caused an error are not 
         ///     counted and messages are only counted once all other operations in the send are complete.
         /// </remarks>
-        public long AcknowledgementMessagesSent
+        public int AcknowledgementMessagesSent
         {
             get
             {
-                return Interlocked.Read(ref acknowledgementMessagesSent);
+                return acknowledgementMessagesSent;
             }
         }
 
         /// <summary>
         ///     The number of acknowledgement messages sent.
         /// </summary>
-        long acknowledgementMessagesSent;
+        int acknowledgementMessagesSent;
 
         /// <summary>
         ///     The number of hello messages sent.
@@ -116,18 +116,18 @@ namespace Hazel
         ///     each time that LogHelloSend is called by the Connection. Messages that caused an error are not 
         ///     counted and messages are only counted once all other operations in the send are complete.
         /// </remarks>
-        public long HelloMessagesSent
+        public int HelloMessagesSent
         {
             get
             {
-                return Interlocked.Read(ref helloMessagesSent);
+                return helloMessagesSent;
             }
         }
 
         /// <summary>
         ///     The number of hello messages sent.
         /// </summary>
-        long helloMessagesSent;
+        int helloMessagesSent;
 
         /// <summary>
         ///     The number of bytes of data sent.
@@ -185,7 +185,7 @@ namespace Hazel
         /// <summary>
         ///     The total number of messages received.
         /// </summary>
-        public long MessagesReceived
+        public int MessagesReceived
         {
             get
             {
@@ -200,18 +200,18 @@ namespace Hazel
         ///     This is the number of unreliable messages that were received by the <see cref="Connection"/>, incremented
         ///     each time that LogUnreliableReceive is called by the Connection. Messages are counted before the receive event is invoked.
         /// </remarks>
-        public long UnreliableMessagesReceived
+        public int UnreliableMessagesReceived
         {
             get
             {
-                return Interlocked.Read(ref unreliableMessagesReceived);
+                return unreliableMessagesReceived;
             }
         }
 
         /// <summary>
         ///     The number of unreliable messages received.
         /// </summary>
-        long unreliableMessagesReceived;
+        int unreliableMessagesReceived;
 
         /// <summary>
         ///     The number of reliable messages received.
@@ -220,18 +220,18 @@ namespace Hazel
         ///     This is the number of reliable messages that were received by the <see cref="Connection"/>, incremented
         ///     each time that LogReliableReceive is called by the Connection. Messages are counted before the receive event is invoked.
         /// </remarks>
-        public long ReliableMessagesReceived
+        public int ReliableMessagesReceived
         {
             get
             {
-                return Interlocked.Read(ref reliableMessagesReceived);
+                return reliableMessagesReceived;
             }
         }
 
         /// <summary>
         ///     The number of reliable messages received.
         /// </summary>
-        long reliableMessagesReceived;
+        int reliableMessagesReceived;
 
         /// <summary>
         ///     The number of fragmented messages received.
@@ -240,18 +240,18 @@ namespace Hazel
         ///     This is the number of fragmented messages that were received by the <see cref="Connection"/>, incremented
         ///     each time that LogFragmentedReceive is called by the Connection. Messages are counted before the receive event is invoked.
         /// </remarks>
-        public long FragmentedMessagesReceived
+        public int FragmentedMessagesReceived
         {
             get
             {
-                return Interlocked.Read(ref fragmentedMessagesReceived);
+                return fragmentedMessagesReceived;
             }
         }
 
         /// <summary>
         ///     The number of fragmented messages received.
         /// </summary>
-        long fragmentedMessagesReceived;
+        int fragmentedMessagesReceived;
 
         /// <summary>
         ///     The number of acknowledgement messages received.
@@ -260,18 +260,18 @@ namespace Hazel
         ///     This is the number of acknowledgement messages that were received by the <see cref="Connection"/>, incremented
         ///     each time that LogAcknowledgemntReceive is called by the Connection. Messages are counted before the receive event is invoked.
         /// </remarks>
-        public long AcknowledgementMessagesReceived
+        public int AcknowledgementMessagesReceived
         {
             get
             {
-                return Interlocked.Read(ref acknowledgementMessagesReceived);
+                return acknowledgementMessagesReceived;
             }
         }
 
         /// <summary>
         ///     The number of acknowledgement messages received.
         /// </summary>
-        long acknowledgementMessagesReceived;
+        int acknowledgementMessagesReceived;
 
         /// <summary>
         ///     The number of hello messages received.
@@ -280,18 +280,18 @@ namespace Hazel
         ///     This is the number of hello messages that were received by the <see cref="Connection"/>, incremented
         ///     each time that LogHelloReceive is called by the Connection. Messages are counted before the receive event is invoked.
         /// </remarks>
-        public long HelloMessagesReceived
+        public int HelloMessagesReceived
         {
             get
             {
-                return Interlocked.Read(ref helloMessagesReceived);
+                return helloMessagesReceived;
             }
         }
 
         /// <summary>
         ///     The number of hello messages received.
         /// </summary>
-        long helloMessagesReceived;
+        int helloMessagesReceived;
 
         /// <summary>
         ///     The number of bytes of data received.

diff --git a/Hazel/Tcp/TcpConnection.cs b/Hazel/Tcp/TcpConnection.cs
index aaac6484cca1f963f879e6934aaa734fee4e268e..83ac080fad9d96b54425c9ac3319decbcdede35a 100644 (file)
--- a/Hazel/Tcp/TcpConnection.cs
+++ b/Hazel/Tcp/TcpConnection.cs
@@ -128,12 +128,10 @@ namespace Hazel.Tcp
 
             try
             {
-                this.sem.WaitOne();
                 socket.BeginSend(fullBytes, 0, fullBytes.Length, SocketFlags.None, FinishSend, null);
             }
             catch (Exception e)
             {
-                try { this.sem.Set(); } catch (ObjectDisposedException) { }
                 Disconnect("Could not send data as an occured: " + e.Message);
             }
 
@@ -157,19 +155,16 @@ namespace Hazel.Tcp
 
             try
             {
-                this.sem.WaitOne();
                 socket.BeginSend(fullBytes, 0, fullBytes.Length, SocketFlags.None, FinishSend, null);
             }
             catch (Exception e)
             {
-                try { this.sem.Set(); } catch (ObjectDisposedException) { }
                 Disconnect("Could not send data as an occured: " + e.Message);
             }
 
             Statistics.LogFragmentedSend(bytes.Length, fullBytes.Length);
         }
 
-        private AutoResetEvent sem = new AutoResetEvent(true);
         private void FinishSend(IAsyncResult ar)
         {
             try
@@ -177,10 +172,6 @@ namespace Hazel.Tcp
                 this.socket.EndSend(ar);
             }
             catch { }
-            finally
-            {
-                try { this.sem.Set(); } catch (ObjectDisposedException) { }
-            }
         }
 
         /// <summary>
@@ -278,6 +269,7 @@ namespace Hazel.Tcp
                     return;
                 }
             }
+            catch (ObjectDisposedException) { return; }
             catch (SocketException s)
             {
                 Disconnect("SocketException while reading body: " + s.Message);
@@ -347,16 +339,6 @@ namespace Hazel.Tcp
         {
             if (disposing)
             {
-                try
-                {
-                    if (this.sem != null)
-                    {
-                        this.sem.Dispose();
-                        this.sem = null;
-                    }
-                }
-                catch { }
-
                 lock (this)
                 {
                     State = ConnectionState.NotConnected;