Increase HTTP connection pool minimum to 64

The connection pool was previously sized to Environment.ProcessorCount (e.g., 8
on an 8-core machine). HTTP object downloads are I/O-bound, not CPU-bound, so
CPU count is a poor proxy for optimal connection concurrency. Under burst
workloads like git checkout, 8 connections saturate almost instantly.

Set a floor of 64 connections (or ProcessorCount if higher). This provides
more headroom before pool exhaustion during burst object download scenarios.

Work item: 60167591

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Tyrie Vella

GVFS/GVFS.Common/GVFSConstants.cs

@@ -46,6 +46,8 @@ public static class GitConfig
 
             public const string ShowHydrationStatus = GVFSPrefix + "show-hydration-status";
             public const bool ShowHydrationStatusDefault = false;
+
+            public const string MaxHttpConnectionsConfig = GVFSPrefix + "max-http-connections";
         }
 
         public static class LocalGVFSConfig

GVFS/GVFS.Common/Http/HttpRequestor.cs

@@ -17,8 +17,11 @@ namespace GVFS.Common.Http
 {
     public abstract class HttpRequestor : IDisposable
     {
+        private const int MinConnectionLimit = 64;
+
         private static long requestCount = 0;
         private static SemaphoreSlim availableConnections;
+        private static int connectionLimitConfigured = 0;
 
         private readonly ProductInfoHeaderValue userAgentHeader;
 
@@ -34,8 +37,13 @@ static HttpRequestor()
             using (var machineConfigLock = GetMachineConfigLock())
             {
                 ServicePointManager.SecurityProtocol = ServicePointManager.SecurityProtocol | SecurityProtocolType.Tls12;
-                ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount;
-                availableConnections = new SemaphoreSlim(ServicePointManager.DefaultConnectionLimit);
+
+                // HTTP downloads are I/O-bound, not CPU-bound, so ProcessorCount is too low
+                // for burst workloads (e.g., checkout triggering many object downloads).
+                // This default can be overridden via git config gvfs.max-http-connections.
+                int connectionLimit = Math.Max(Environment.ProcessorCount, MinConnectionLimit);
+                ServicePointManager.DefaultConnectionLimit = connectionLimit;
+                availableConnections = new SemaphoreSlim(connectionLimit);
             }
         }
 
@@ -47,6 +55,13 @@ protected HttpRequestor(ITracer tracer, RetryConfig retryConfig, Enlistment enli
 
             this.Tracer = tracer;
 
+            // On first instantiation, check git config for a custom connection limit.
+            // This runs before any requests are made (during mount initialization).
+            if (Interlocked.CompareExchange(ref connectionLimitConfigured, 1, 0) == 0)
+            {
+                TryApplyConnectionLimitFromConfig(tracer, enlistment);
+            }
+
             HttpClientHandler httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
 
             this.authentication.ConfigureHttpClientHandlerSslIfNeeded(this.Tracer, httpClientHandler, enlistment.CreateGitProcess());
@@ -337,6 +352,31 @@ private static bool TryGetResponseMessageFromHttpRequestException(HttpRequestExc
 
         }
 
+        private static void TryApplyConnectionLimitFromConfig(ITracer tracer, Enlistment enlistment)
+        {
+            try
+            {
+                GitProcess.ConfigResult result = enlistment.CreateGitProcess().GetFromConfig(GVFSConstants.GitConfig.MaxHttpConnectionsConfig);
+                string error;
+                int configuredLimit;
+                if (result.TryParseAsInt(0, MinConnectionLimit, out configuredLimit, out error) && configuredLimit > 0)
+                {
+                    ServicePointManager.DefaultConnectionLimit = configuredLimit;
+                    availableConnections = new SemaphoreSlim(configuredLimit);
+
+                    EventMetadata metadata = new EventMetadata();
+                    metadata.Add("configuredLimit", configuredLimit);
+                    tracer.RelatedEvent(EventLevel.Informational, "HttpRequestor_ConnectionLimitConfigured", metadata);
+                }
+            }
+            catch (Exception e)
+            {
+                EventMetadata metadata = new EventMetadata();
+                metadata.Add("Exception", e.ToString());
+                tracer.RelatedWarning(metadata, "HttpRequestor: Failed to read gvfs.max-http-connections config, using default");
+            }
+        }
+
         private static FileStream GetMachineConfigLock()
         {
             var machineConfigLocation = RuntimeEnvironment.SystemConfigurationFile;