Snapshot pypath, use ConcurrentDictionary for thunks and slot holders

filmor · Sep 14, 2026 · May 9, 2026 · May 9, 2026 · May 9, 2026 · May 9, 2026
commit f49ed1bd32833d557bb41efb0c170a81f3c1d6a3
diff --git a/src/runtime/AssemblyManager.cs b/src/runtime/AssemblyManager.cs
@@ -37,7 +37,9 @@ internal class AssemblyManager
 
         // modified from event handlers below, potentially triggered from different .NET threads
         private static readonly ConcurrentQueue<Assembly> assemblies = new();
-        internal static readonly List<string> pypath = new (capacity: 16);
+        // Snapshot; UpdatePath swaps under lock, readers iterate the captured ref.
+        internal static volatile IReadOnlyList<string> pypath = Array.Empty<string>();
+        private static readonly object _pypathLock = new();
         private AssemblyManager()
         {
         }
@@ -49,7 +51,7 @@ private AssemblyManager()
         /// </summary>
         internal static void Initialize()
         {
-            pypath.Clear();
+            pypath = Array.Empty<string>();
 
             AppDomain domain = AppDomain.CurrentDomain;
 
@@ -154,19 +156,20 @@ internal static void UpdatePath()
         {
             BorrowedReference list = Runtime.PySys_GetObject("path");
             var count = Runtime.PyList_Size(list);
-            if (count != pypath.Count)
+            if (count == pypath.Count) return;
+
+            lock (_pypathLock)
             {
-                pypath.Clear();
+                if (count == pypath.Count) return;
+                var fresh = new List<string>(checked((int)count));
                 probed.Clear();
                 for (var i = 0; i < count; i++)
                 {
                     BorrowedReference item = Runtime.PyList_GetItem(list, i);
                     string? path = Runtime.GetManagedString(item);
-                    if (path != null)
-                    {
-                        pypath.Add(path);
-                    }
+                    if (path != null) fresh.Add(path);
                 }
+                pypath = fresh;
             }
         }
 
@@ -196,7 +199,8 @@ public static string FindAssembly(string name)
 
         static IEnumerable<string> FindAssemblyCandidates(string name)
         {
-            foreach (string head in pypath)
+            var paths = pypath;
+            foreach (string head in paths)
             {
                 string path;
                 if (head == null || head.Length == 0)

diff --git a/src/runtime/Finalizer.cs b/src/runtime/Finalizer.cs
@@ -115,7 +115,8 @@ internal void ThrottledCollect()
             if (!started) throw new InvalidOperationException($"{nameof(PythonEngine)} is not initialized");
 
             if (!Enable || Interlocked.Increment(ref _throttled) < Threshold) return;
-            // Stale pointers on the queue would crash Py_DecRef during teardown.
+            // Defends against externally-driven Py_Finalize (e.g. host's atexit):
+            // queue pointers may already be freed, so skip the drain.
             if (Runtime._Py_IsFinalizing() == true) return;
             Interlocked.Exchange(ref _throttled, 0);
             this.Collect();
@@ -138,7 +139,7 @@ internal void AddFinalizedObject(ref IntPtr obj, int run
                 return;
             }
 
-            // Skip on FT: stale ob_ref_local read from the finalizer thread can crash.
+            // Skip on FT: the split refcount can race here and trip the assert spuriously.
             if (!Native.ABI.IsFreeThreaded)
             {
                 Debug.Assert(Runtime.Refcount(new BorrowedReference(obj)) > 0);

diff --git a/src/runtime/Interop.cs b/src/runtime/Interop.cs
@@ -141,7 +141,9 @@ internal static Type GetPrototype(MethodInfo method)
         }
 
 
-        internal static Dictionary<IntPtr, Delegate> allocatedThunks = new();
+        // Concurrent: documents the multi-writer contract previously enforced
+        // by callers happening to hold TypeManager._cacheCreateLock.
+        internal static ConcurrentDictionary<IntPtr, Delegate> allocatedThunks = new();
 
         internal static ThunkInfo GetThunk(MethodInfo method)
         {

diff --git a/src/runtime/Runtime.cs b/src/runtime/Runtime.cs
@@ -617,7 +617,7 @@ internal static unsafe void XIncref(BorrowedReference op)
         internal static unsafe void XDecref(StolenReference op)
         {
 #if DEBUG
-            // Racy on FT: stale ob_ref_local read may crash.
+            // Skip on FT: the split refcount can race here and trip the assert spuriously.
             Debug.Assert(op == null || Native.ABI.IsFreeThreaded || Refcount(new BorrowedReference(op.Pointer)) > 0);
             Debug.Assert(_isInitialized || Py_IsInitialized() != 0 || _Py_IsFinalizing() != false);
 #endif

diff --git a/src/runtime/TypeManager.cs b/src/runtime/TypeManager.cs
@@ -33,7 +33,9 @@ internal class TypeManager
         internal static readonly ConcurrentDictionary<MaybeType, PyType> cache = new();
         internal static readonly object _cacheCreateLock = new();
 
-        static readonly Dictionary<PyType, SlotsHolder> _slotsHolders = new(PythonReferenceComparer.Instance);
+        // Concurrent: documents the multi-writer contract previously enforced
+        // by callers happening to hold _cacheCreateLock.
+        static readonly ConcurrentDictionary<PyType, SlotsHolder> _slotsHolders = new(PythonReferenceComparer.Instance);
 
         // Slots which must be set
         private static readonly string[] _requiredSlots = new string[]
@@ -949,7 +951,7 @@ internal static SlotsHolder CreateSlotsHolder(PyType type)
         {
             type = new PyType(type);
             var holder = new SlotsHolder(type);
-            _slotsHolders.Add(type, holder);
+            _slotsHolders[type] = holder;
             return holder;
         }
     }