Atomic type creation in ReflectedClrType.GetOrCreate / TypeManager.GetType

greateggsgreg · greateggsgreg · commit 2f08c98633cd · 2026-05-09T17:59:42.000-04:00
Both type-creation paths had a classic check-then-act race:

  if (!cache.TryGetValue(t, out var pyType))
  {
      pyType = AllocateClass(t);
      cache.Add(t, pyType);   // throws under contention, partial type otherwise
      InitializeClass(...);
  }

Two threads racing past the TryGetValue could both call AllocateClass
and one would throw on Dictionary.Add ("duplicate key").  Worse, the
cache add happens *before* InitializeClass populates members so a
third thread's outside-the-lock fast path could observe a partially-
initialised type and fail with AttributeError on members not yet added
(reproducible under free-threaded Python with concurrent attribute
access on built-in CLR types).

Convert ClassManager.cache and TypeManager.cache to ConcurrentDictionary
and serialise the multi-step initialisation behind a lock.

ReflectedClrType.GetOrCreate uses a two-cache design:

- `cache`            - only fully-initialised types; safe to read on the
                       outside-the-lock fast path.
- `_inProgressCache` - partial types being built inside the lock; visible
                       only to the building thread, so self-referential
                       class definitions (which recurse into GetOrCreate
                       for the same type chain) still resolve.

Cross-thread access cannot reach the in-progress cache because acquiring
the lock is required, so other threads always see fully-ready types.

The serialisation snapshot copies remain Dictionary&lt;,&gt; on the wire for
binary compatibility.
diff --git a/src/runtime/ClassManager.cs b/src/runtime/ClassManager.cs
@@ -33,7 +33,13 @@ internal class ClassManager
                                                              BindingFlags.Public |
                                                              BindingFlags.NonPublic;
 
-        internal static Dictionary<MaybeType, ReflectedClrType> cache = new(capacity: 128);
+        // Two-cache design for thread-safe type creation:
+        //   `cache`            — only fully-initialised types; safe to read without the lock.
+        //   `_inProgressCache` — partial types being built inside the lock; visible only
+        //                        to the building thread (for self-referential definitions).
+        internal static System.Collections.Concurrent.ConcurrentDictionary<MaybeType, ReflectedClrType> cache = new();
+        internal static readonly System.Collections.Concurrent.ConcurrentDictionary<MaybeType, ReflectedClrType> _inProgressCache = new();
+        internal static readonly object _cacheCreateLock = new();
         private static readonly Type dtype;
 
         private ClassManager()
@@ -103,13 +109,13 @@ internal static ClassManagerState SaveRuntimeData()
             return new()
             {
                 Contexts = contexts,
-                Cache = cache,
+                Cache = new Dictionary<MaybeType, ReflectedClrType>(cache),
             };
         }
 
         internal static void RestoreRuntimeData(ClassManagerState storage)
         {
-            cache = storage.Cache;
+            cache = new System.Collections.Concurrent.ConcurrentDictionary<MaybeType, ReflectedClrType>(storage.Cache);
             var invalidClasses = new List<KeyValuePair<MaybeType, ReflectedClrType>>();
             var contexts = storage.Contexts;
             foreach (var pair in cache)
diff --git a/src/runtime/TypeManager.cs b/src/runtime/TypeManager.cs
@@ -26,7 +26,9 @@ internal class TypeManager
 
 
         private const BindingFlags tbFlags = BindingFlags.Public | BindingFlags.Static;
-        private static readonly Dictionary<MaybeType, PyType> cache = new();
+        // Thread-safe cache; multi-step creation in GetType is serialised via _cacheCreateLock.
+        internal static readonly System.Collections.Concurrent.ConcurrentDictionary<MaybeType, PyType> cache = new();
+        internal static readonly object _cacheCreateLock = new();
 
         static readonly Dictionary<PyType, SlotsHolder> _slotsHolders = new(PythonReferenceComparer.Instance);
 
@@ -75,7 +77,7 @@ internal static void RemoveTypes()
         internal static TypeManagerState SaveRuntimeData()
             => new()
             {
-                Cache = cache,
+                Cache = new Dictionary<MaybeType, PyType>(cache),
             };
 
         internal static void RestoreRuntimeData(TypeManagerState storage)
@@ -94,14 +96,15 @@ internal static void RestoreRuntimeData(TypeManagerState storage)
 
         internal static PyType GetType(Type type)
         {
-            // Note that these types are cached with a refcount of 1, so they
-            // effectively exist until the CPython runtime is finalized.
-            if (!cache.TryGetValue(type, out var pyType))
+            // Cached with refcount 1; effectively lives until the CPython runtime is finalised.
+            if (cache.TryGetValue(type, out var pyType)) return pyType;
+            lock (_cacheCreateLock)
             {
+                if (cache.TryGetValue(type, out pyType)) return pyType;
                 pyType = CreateType(type);
                 cache[type] = pyType;
+                return pyType;
             }
-            return pyType;
         }
         /// <summary>
         /// Given a managed Type derived from ExtensionType, get the handle to
diff --git a/src/runtime/Types/ReflectedClrType.cs b/src/runtime/Types/ReflectedClrType.cs
@@ -25,36 +25,44 @@ internal ReflectedClrType(BorrowedReference original) : base(original) { }
     /// </remarks>
     public static ReflectedClrType GetOrCreate(Type type)
     {
+        // Fast path: `cache` holds only fully-initialised types.
         if (ClassManager.cache.TryGetValue(type, out var pyType))
-        {
             return pyType;
-        }
 
-        try
+        lock (ClassManager._cacheCreateLock)
         {
-            // Ensure, that matching Python type exists first.
-            // It is required for self-referential classes
-            // (e.g. with members, that refer to the same class)
-            pyType = AllocateClass(type);
-            ClassManager.cache.Add(type, pyType);
-
-            var impl = ClassManager.CreateClass(type);
+            // Re-check now that we hold the lock; another thread may have finished.
+            if (ClassManager.cache.TryGetValue(type, out pyType))
+                return pyType;
+            // Reentrant call from the same thread (self-referential class) sees the
+            // partial type that the outer frame allocated.
+            if (ClassManager._inProgressCache.TryGetValue(type, out pyType))
+                return pyType;
+
+            try
+            {
+                pyType = AllocateClass(type);
+                ClassManager._inProgressCache[type] = pyType;
 
-            TypeManager.InitializeClassCore(type, pyType, impl);
+                var impl = ClassManager.CreateClass(type);
+                TypeManager.InitializeClassCore(type, pyType, impl);
+                ClassManager.InitClassBase(type, impl, pyType);
+                TypeManager.InitializeClass(pyType, impl, type);
 
-            ClassManager.InitClassBase(type, impl, pyType);
+                // Publish the completed type so the fast path can see it.
+                ClassManager.cache[type] = pyType;
+            }
+            catch (Exception e)
+            {
+                throw new InternalPythonnetException($"Failed to create Python type for {type.FullName}", e);
+            }
+            finally
+            {
+                ClassManager._inProgressCache.TryRemove(type, out _);
+            }
 
-            // Now we force initialize the Python type object to reflect the given
-            // managed type, filling the Python type slots with thunks that
-            // point to the managed methods providing the implementation.
-            TypeManager.InitializeClass(pyType, impl, type);
-        }
-        catch (Exception e)
-        {
-            throw new InternalPythonnetException($"Failed to create Python type for {type.FullName}", e);
+            return pyType;
         }
-
-        return pyType;
     }
 
     internal void Restore(Dictionary<string, object?> context)
