Trim concurrent overhead on hot paths from free-threading prep

DelegateManager.GetDispatcher now takes a lock-free fast path on cache hit (ConcurrentDictionary), avoiding the emit lock on every CLR delegate dispatch. InternString and ClassManager._inProgressCache revert to plain Dictionary since they are only written under existing single- threaded or locked paths, and ClassBase.ClearVisited becomes a per- thread HashSet (tp_clear recursion is intra-stack).
pythonnet · greateggsgreg · May 9, 2026 · May 9, 2026 · May 9, 2026 · May 9, 2026
commit d9b658dc283c3a9a5f291eac06730161d123e1d4
diff --git a/src/runtime/ClassManager.cs b/src/runtime/ClassManager.cs
@@ -35,10 +35,9 @@ internal class ClassManager
                                                              BindingFlags.NonPublic;
 
         // cache: fully-initialised types (lock-free reads).
-        // _inProgressCache: partial types visible only to the lock-holding builder
-        // for self-referential definitions.
+        // _inProgressCache: partial types; only accessed under _cacheCreateLock.
         internal static ConcurrentDictionary<MaybeType, ReflectedClrType> cache = new();
-        internal static readonly ConcurrentDictionary<MaybeType, ReflectedClrType> _inProgressCache = new();
+        internal static readonly Dictionary<MaybeType, ReflectedClrType> _inProgressCache = new();
         internal static readonly object _cacheCreateLock = new();
         private static readonly Type dtype;
 

diff --git a/src/runtime/DelegateManager.cs b/src/runtime/DelegateManager.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -15,8 +16,8 @@ namespace Python.Runtime
     /// </summary>
     internal class DelegateManager
     {
-        private readonly Dictionary<Type,Type> cache = new();
-        // Reflection.Emit is not thread-safe; serialise cache lookup + DefineType.
+        // Lock-free reads; Reflection.Emit (BuildDispatcher) is serialised.
+        private readonly ConcurrentDictionary<Type, Type> cache = new();
         private readonly object _emitLock = new();
         private readonly Type basetype = typeof(Dispatcher);
         private readonly Type arrayType = typeof(object[]);
@@ -39,9 +40,10 @@ public DelegateManager()
         /// </summary>
         private Type GetDispatcher(Type dtype)
         {
+            if (cache.TryGetValue(dtype, out Type item)) return item;
             lock (_emitLock)
             {
-                return cache.TryGetValue(dtype, out Type item) ? item : BuildDispatcher(dtype);
+                return cache.TryGetValue(dtype, out item) ? item : BuildDispatcher(dtype);
             }
         }
 

diff --git a/src/runtime/InternString.cs b/src/runtime/InternString.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -9,8 +8,9 @@ namespace Python.Runtime
 {
     static partial class InternString
     {
-        private static readonly ConcurrentDictionary<string, PyString> _string2interns = new();
-        private static readonly ConcurrentDictionary<IntPtr, string> _intern2strings = new();
+        // Populated only by Initialize (single-threaded); immutable until Shutdown.
+        private static readonly Dictionary<string, PyString> _string2interns = new();
+        private static readonly Dictionary<IntPtr, string> _intern2strings = new();
         const BindingFlags PyIdentifierFieldFlags = BindingFlags.Static | BindingFlags.NonPublic;
 
         static InternString()
@@ -76,11 +76,8 @@ public static bool TryGetInterned(BorrowedReference op, out string s)
 
         private static void SetIntern(string s, PyString op)
         {
-            // Initialize is single-threaded; TryAdd preserves the original
-            // single-write invariant via Debug.Assert without crashing release.
-            bool a = _string2interns.TryAdd(s, op);
-            bool b = _intern2strings.TryAdd(op.Reference.DangerousGetAddress(), s);
-            Debug.Assert(a && b);
+            _string2interns.Add(s, op);
+            _intern2strings.Add(op.Reference.DangerousGetAddress(), s);
         }
     }
 }
diff --git a/src/runtime/Types/ClassBase.cs b/src/runtime/Types/ClassBase.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -375,8 +374,8 @@ public static int tp_clear(BorrowedReference ob)
             return 0;
         }
 
-        // tp_clear re-entrancy guard.
-        static readonly ConcurrentDictionary<IntPtr, byte> ClearVisited = new();
+        // tp_clear re-entrancy guard; per-thread since recursion is intra-stack.
+        [ThreadStatic] static HashSet<IntPtr>? _clearVisited;
 
         internal static unsafe int BaseUnmanagedClear(BorrowedReference ob)
         {
@@ -392,12 +391,12 @@ internal static unsafe int BaseUnmanagedClear(BorrowedReference ob)
             if (clearPtr == TypeManager.subtype_clear)
             {
                 var addr = ob.DangerousGetAddress();
-                if (!ClearVisited.TryAdd(addr, 0))
+                var visited = _clearVisited ??= new HashSet<IntPtr>();
+                if (!visited.Add(addr))
                     return 0;
 
-                int res = clear(ob);
-                ClearVisited.TryRemove(addr, out _);
-                return res;
+                try { return clear(ob); }
+                finally { visited.Remove(addr); }
             }
             else
             {

diff --git a/src/runtime/Types/ReflectedClrType.cs b/src/runtime/Types/ReflectedClrType.cs
@@ -60,7 +60,7 @@ public static ReflectedClrType GetOrCreate(Type type)
             }
             finally
             {
-                ClassManager._inProgressCache.TryRemove(type, out _);
+                ClassManager._inProgressCache.Remove(type);
             }
 
             return pyType;
-Original file line number
+Diff line change
@@ Expand Up / @@ -60,7 +60,7 @@ public static ReflectedClrType GetOrCreate(Type type) @@
                 }
                 finally
                 {
-                    ClassManager._inProgressCache.TryRemove(type, out _);
+                    ClassManager._inProgressCache.Remove(type);
                 }
                 return pyType;
@@ Expand Down @@