Introduce RegexRunnerPool to reuse multiple RegexRunner instances at once under contention

src/libraries/System.Text.RegularExpressions/src/System.Text.RegularExpressions.csproj

@@ -52,6 +52,7 @@
     <Compile Include="System\Text\RegularExpressions\RegexRunner.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexRunnerFactory.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexRunnerMode.cs" />
+    <Compile Include="System\Text\RegularExpressions\RegexRunnerPool.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexTree.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexTreeAnalyzer.cs" />
     <Compile Include="System\Text\RegularExpressions\RegexWriter.cs" />

src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.cs

@@ -32,6 +32,7 @@ public partial class Regex : ISerializable
 
         private WeakReference<RegexReplacement?>? _replref;   // cached parsed replacement pattern
         private volatile RegexRunner? _runner;                // cached runner
+        private RegexRunnerPool? _runnerPool;                 // pool of cached runners to spill into
 
 #if DEBUG
         // These members aren't used from Regex(), but we want to keep them in debug builds for now,
@@ -421,7 +422,7 @@ protected void InitializeReferences()
                 ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length, ExceptionResource.LengthNotNegative);
             }
 
-            RegexRunner runner = Interlocked.Exchange(ref _runner, null) ?? CreateRunner();
+            RegexRunner runner = RentOrCreateRunner();
             try
             {
                 runner.InitializeTimeout(internalMatchTimeout);
@@ -453,7 +454,7 @@ protected void InitializeReferences()
             finally
             {
                 runner.runtext = null; // drop reference to text to avoid keeping it alive in a cache.
-                _runner = runner;
+                ReturnRunner(runner);
             }
         }
 
@@ -466,7 +467,7 @@ protected void InitializeReferences()
             // that takes in startat.
             Debug.Assert(startat <= input.Length);
 
-            RegexRunner runner = Interlocked.Exchange(ref _runner, null) ?? CreateRunner();
+            RegexRunner runner = RentOrCreateRunner();
             try
             {
                 runner.InitializeTimeout(internalMatchTimeout);
@@ -513,7 +514,7 @@ protected void InitializeReferences()
             }
             finally
             {
-                _runner = runner;
+                ReturnRunner(runner);
             }
         }
 
@@ -529,7 +530,7 @@ private void RunAllMatchesWithCallback<TState>(string? inputString, ReadOnlySpan
             Debug.Assert(inputString is null || inputSpan.SequenceEqual(inputString));
             Debug.Assert((uint)startat <= (uint)inputSpan.Length);
 
-            RegexRunner runner = Interlocked.Exchange(ref _runner, null) ?? CreateRunner();
+            RegexRunner runner = RentOrCreateRunner();
             try
             {
                 runner.runtext = inputString;
@@ -599,7 +600,7 @@ private void RunAllMatchesWithCallback<TState>(string? inputString, ReadOnlySpan
             finally
             {
                 runner.runtext = null; // drop reference to string to avoid keeping it alive in a cache.
-                _runner = runner;
+                ReturnRunner(runner);
             }
         }
 
@@ -643,11 +644,43 @@ private void RunAllMatchesWithCallback<TState>(string? inputString, ReadOnlySpan
             return RegularExpressions.Match.Empty;
         }
 
-        /// <summary>Creates a new runner instance.</summary>
-        private RegexRunner CreateRunner() =>
-            // The factory needs to be set by the ctor.  `factory` is a protected field, so it's possible a derived
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private RegexRunner RentOrCreateRunner()
+        {
+            RegexRunner? runner = Interlocked.Exchange(ref _runner, null);
+            if (runner != null)
+            {
+                return runner;
+            }
+
+            RegexRunnerPool? pool = _runnerPool;
+            if (pool != null && pool.TryGet(out runner))
+            {
+                return runner;
+            }
+
+            // The factory needs to be set by the ctor. `factory` is a protected field, so it's possible a derived
             // type nulls out the factory after we've set it, but that's the nature of the design.
-            factory!.CreateInstance();
+            return factory!.CreateInstance();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ReturnRunner(RegexRunner runner)
+        {
+            if (_runner is null)
+            {
+                // If we don't have a runner, then we can just store this one.
+                _runner = runner;
+            }
+            else
+            {
+                // If we reached here, it means that another operation has won the race and already stored a runner.
+                // Use this condition to detect contended runner usage and initialize a pool to store the runner in.
+                // Here, we may also lose the race and create more than one pool. This is acceptable as the goal is to
+                // reduce the number of ammortized allocations at reasonable cost rather than eliminating every single one.
+                (_runnerPool ??= new()).Return(runner);
+            }
+        }
 
         /// <summary>True if the <see cref="RegexOptions.Compiled"/> option was set.</summary>
         [Obsolete(Obsoletions.RegexExtensibilityImplMessage, DiagnosticId = Obsoletions.RegexExtensibilityDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]

src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexRunnerPool.cs

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+
+namespace System.Text.RegularExpressions
+{
+    internal sealed class RegexRunnerPool
+    {
+        private static readonly int s_maxCapacity = Math.Max(4, Environment.ProcessorCount);
+
+        private ConcurrentStack<RegexRunner> _storage = new();
+        private int _storedCount;
+
+        public bool TryGet([NotNullWhen(true)] out RegexRunner? runner)
+        {
+            if (_storage.TryPop(out runner))
+            {
+                Interlocked.Decrement(ref _storedCount);
+                return true;
+            }
+
+            return false;
+        }
+
+        public void Return(RegexRunner runner)
+        {
+            if (Interlocked.Increment(ref _storedCount) <= s_maxCapacity)
+            {
+                _storage.Push(runner);
+            }
+            else
+            {
+                Interlocked.Decrement(ref _storedCount);
+            }
+        }
+    }
+}