Single epoll thread per 28 cores

src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncContext.Unix.cs

@@ -1986,7 +1986,8 @@ public SocketError SendFileAsync(SafeFileHandle fileHandle, long offset, long co
         // be scheduled instead. It's not functionally incorrect to schedule the release of a synchronous operation, just it may
         // lead to thread pool starvation issues if the synchronous operations are blocking thread pool threads (typically not
         // advised) and more threads are not immediately available to run work items that would release those operations.
-        public unsafe Interop.Sys.SocketEvents HandleSyncEventsSpeculatively(Interop.Sys.SocketEvents events)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Interop.Sys.SocketEvents HandleSyncEventsSpeculatively(Interop.Sys.SocketEvents events)
         {
             if ((events & Interop.Sys.SocketEvents.Error) != 0)
             {
@@ -2067,4 +2068,16 @@ public static void OutputTrace(string s)
 
         public static string IdOf(object o) => o == null ? "(null)" : $"{o.GetType().Name}#{o.GetHashCode():X2}";
     }
+
+    // struct wrapper is used in order to improve the performance of the epoll thread hot path by up to 3% of some TechEmpower benchmarks
+    // the goal is to have a dedicated generic instantiation and using:
+    // System.Collections.Dictionary`2[System.IntPtr,System.Net.Sockets.SocketAsyncContextWrapper]::TryGetValueInternal(!0,int32,!1&)
+    // instead of:
+    // System.Collections.Dictionary`2[System.IntPtr,System.__Canon]::TryGetValueInternal(!0,int32,!1&)
+    internal readonly struct SocketAsyncContextWrapper
+    {
+        public SocketAsyncContextWrapper(SocketAsyncContext context) => Context = context;
+
+        internal SocketAsyncContext Context { get; }
+    }
 }

src/libraries/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEngine.Unix.cs

@@ -2,13 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
 using System.Threading;
-using System.Threading.Tasks;
 
 namespace System.Net.Sockets
 {
@@ -56,16 +54,21 @@ public bool TryRegister(SafeSocketHandle socket, out Interop.Error error)
 
         private static readonly object s_lock = new object();
 
-        // In debug builds, force there to be 2 engines. In release builds, use half the number of processors when
-        // there are at least 6. The lower bound is to avoid using multiple engines on systems which aren't servers.
-#pragma warning disable CA1802 // const works for debug, but needs to be static readonly for release
-        private static readonly int s_engineCount =
+        private static readonly int s_engineCount = GetEnginesCount();
+
+        private static int GetEnginesCount()
+        {
+            if (uint.TryParse(Environment.GetEnvironmentVariable("SYSTEM_NET_SOCKETS_ENGINE_COUNT"), out uint count))
+            {
+                return (int)count;
+            }
+
 #if DEBUG
-            2;
+            return 2; // use two engines to make sure that this code path is covered with tests
 #else
-            Environment.ProcessorCount >= 6 ? Environment.ProcessorCount / 2 : 1;
+            return 1; // having a single epoll thread is optimal
 #endif
-#pragma warning restore CA1802
+        }
 
         //
         // The current engines. We replace an engine when it runs out of "handle" values.
@@ -127,9 +130,9 @@ public bool TryRegister(SafeSocketHandle socket, out Interop.Error error)
         private IntPtr _outstandingHandles;
 
         //
-        // Maps handle values to SocketAsyncContext instances.
+        // Maps handle values to SocketAsyncContext instances. Must be used under a lock!
         //
-        private readonly ConcurrentDictionary<IntPtr, SocketAsyncContext> _handleToContextMap = new ConcurrentDictionary<IntPtr, SocketAsyncContext>();
+        private readonly Dictionary<IntPtr, SocketAsyncContextWrapper> _handleToContextMap = new Dictionary<IntPtr, SocketAsyncContextWrapper>();
 
         //
         // Queue of events generated by EventLoop() that would be processed by the thread pool
@@ -208,7 +211,11 @@ private IntPtr AllocateHandle(SocketAsyncContext context)
             Debug.Assert(!IsFull, "Expected !IsFull");
 
             IntPtr handle = _nextHandle;
-            _handleToContextMap.TryAdd(handle, context);
+            lock (_handleToContextMap)
+            {
+                Debug.Assert(handle != ShutdownHandle, "ShutdownHandle must not be added to the dictionary");
+                _handleToContextMap.TryAdd(handle, new SocketAsyncContextWrapper(context));
+            }
 
             _nextHandle = IntPtr.Add(_nextHandle, 1);
             _outstandingHandles = IntPtr.Add(_outstandingHandles, 1);
@@ -225,7 +232,14 @@ private void FreeHandle(IntPtr handle)
 
             lock (s_lock)
             {
-                if (_handleToContextMap.TryRemove(handle, out _))
+                bool removed = false;
+
+                lock (_handleToContextMap)
+                {
+                    removed = _handleToContextMap.Remove(handle, out _);
+                }
+
+                if (removed)
                 {
                     _outstandingHandles = IntPtr.Subtract(_outstandingHandles, 1);
                     Debug.Assert(_outstandingHandles.ToInt64() >= 0, $"Unexpected _outstandingHandles: {_outstandingHandles}");
@@ -318,8 +332,10 @@ private void EventLoop()
             {
                 bool shutdown = false;
                 Interop.Sys.SocketEvent* buffer = _buffer;
-                ConcurrentDictionary<IntPtr, SocketAsyncContext> handleToContextMap = _handleToContextMap;
+                Dictionary<IntPtr, SocketAsyncContextWrapper> handleToContextMap = _handleToContextMap;
                 ConcurrentQueue<SocketIOEvent> eventQueue = _eventQueue;
+                IntPtr shutdownHandle = ShutdownHandle;
+                SocketAsyncContext? context = null;
                 while (!shutdown)
                 {
                     int numEvents = EventBufferCount;
@@ -333,21 +349,17 @@ private void EventLoop()
                     Debug.Assert(numEvents > 0, $"Unexpected numEvents: {numEvents}");
 
                     bool enqueuedEvent = false;
-                    for (int i = 0; i < numEvents; i++)
+                    lock (_handleToContextMap)
                     {
-                        IntPtr handle = buffer[i].Data;
-                        if (handle == ShutdownHandle)
-                        {
-                            shutdown = true;
-                        }
-                        else
+                        foreach (var socketEvent in new ReadOnlySpan<Interop.Sys.SocketEvent>(buffer, numEvents))
                         {
-                            Debug.Assert(handle.ToInt64() < MaxHandles.ToInt64(), $"Unexpected values: handle={handle}, MaxHandles={MaxHandles}");
-                            handleToContextMap.TryGetValue(handle, out SocketAsyncContext? context);
-                            if (context != null)
+                            IntPtr handle = socketEvent.Data;
+
+                            if (handleToContextMap.TryGetValue(handle, out SocketAsyncContextWrapper contextWrapper) && (context = contextWrapper.Context) != null)
                             {
-                                Interop.Sys.SocketEvents events = buffer[i].Events;
-                                events = context.HandleSyncEventsSpeculatively(events);
+                                Debug.Assert(handle.ToInt64() < MaxHandles.ToInt64(), $"Unexpected values: handle={handle}, MaxHandles={MaxHandles}");
+
+                                Interop.Sys.SocketEvents events = context.HandleSyncEventsSpeculatively(socketEvent.Events);
                                 if (events != Interop.Sys.SocketEvents.None)
                                 {
                                     var ev = new SocketIOEvent(context, events);
@@ -365,6 +377,10 @@ private void EventLoop()
                                 // such code may keep the stack location live for longer than necessary
                                 context = null;
                             }
+                            else if (handle == shutdownHandle)
+                            {
+                                shutdown = true;
+                            }
                         }
                     }