Single epoll thread per 28 cores

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

@@ -58,29 +58,29 @@ public bool TryRegister(SafeSocketHandle socket, out Interop.Error error)
 
         private static int GetEnginesCount()
         {
+            // The responsibility of SocketAsyncEngine is to get notifications from epoll|kqueue
+            // and schedule corresponding work items to ThreadPool (socket reads and writes).
+            //
+            // Using TechEmpower benchmarks that generate a LOT of SMALL socket reads and writes under a VERY HIGH load
+            // we have observed that a single engine is capable of keeping busy up to thirty x64 and eight ARM64 CPU Cores.
+            //
+            // The vast majority of real-life scenarios is never going to generate such a huge load (hundreds of thousands of requests per second)
+            // and having a single producer should be almost always enough.
+            //
+            // We want to be sure that we can handle extreme loads and that's why we have decided to use these values.
+            //
+            // It's impossible to predict all possible scenarios so we have added a possibility to configure this value using environment variables.
             if (uint.TryParse(Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_SOCKETS_THREAD_COUNT"), out uint count))
             {
                 return (int)count;
             }
 
-            // the data that stands behind this heuristic can be found at https://github.com/dotnet/runtime/pull/35800#issuecomment-624719500
-            // the goal is to have a single epoll thread per every 28 cores
-            const int coresPerSingleEpollThread = 28;
-            int result = Environment.ProcessorCount / coresPerSingleEpollThread;
-
-            // and "round" it up, in a way that 29 cores gets 2 epoll threads
-            if (Environment.ProcessorCount % coresPerSingleEpollThread != 0)
-            {
-                result += 1;
-            }
-
-            // and double that for ARM where some operations like memory barriers are more expensive and we need more producer threads
-            if (RuntimeInformation.ProcessArchitecture == Architecture.Arm64 || RuntimeInformation.ProcessArchitecture == Architecture.Arm)
-            {
-                result *= 2;
-            }
+            Architecture architecture = RuntimeInformation.ProcessArchitecture;
+            int coresPerEngine = architecture == Architecture.Arm64 || architecture == Architecture.Arm
+                ? 8
+                : 30;
 
-            return Math.Min(result, Environment.ProcessorCount / 2);
+            return Math.Max(1, (int)Math.Round(Environment.ProcessorCount / (double)coresPerEngine));
         }
 
         //