Adapt the free-threaded build to mimalloc v2.5.2

mimalloc v2.1.4 replaced the list of abandoned segments with per-arena
bitmaps and introduced sub-processes (mi_subproc_t) to keep abandoned
segments of separate interpreters apart. Use them instead of the
CPython-specific mi_abandoned_pool_t:

- Each interpreter owns a mi_subproc_t created in init_interpreter().
  It is never deleted because abandoned segments may still reference it
  after the interpreter is gone.
- tstate_mimalloc_bind() sets tld->segments.subproc and uses the
  upstream _mi_heap_init() signature.
- The GC and sys.getallocatedblocks() visit abandoned segments with
  _mi_abandoned_visit_blocks_unlocked() while STW.

Author: corona10

Include/internal/pycore_mimalloc.h

@@ -52,9 +52,11 @@ extern "C++" {
 
 #ifdef Py_GIL_DISABLED
 struct _mimalloc_interp_state {
-    // When exiting, threads place any segments with live blocks in this
-    // shared pool for other threads to claim and reuse.
-    mi_abandoned_pool_t abandoned_pool;
+    // When exiting, threads abandon any segments with live blocks. The
+    // abandoned segments are tracked per mimalloc sub-process so that other
+    // threads of the same interpreter can claim and reuse them, and so that
+    // the GC can visit them.
+    mi_subproc_t *subproc;
 };
 
 struct _mimalloc_thread_state {

Objects/obmalloc.c

@@ -1823,10 +1823,10 @@ get_mimalloc_allocated_blocks(PyInterpreterState *interp)
         }
     }
 
-    mi_abandoned_pool_t *pool = &interp->mimalloc.abandoned_pool;
-    for (uint8_t tag = 0; tag < _Py_MIMALLOC_HEAP_COUNT; tag++) {
-        _mi_abandoned_pool_visit_blocks(pool, tag, false, &count_blocks,
-                                        &allocated_blocks);
+    mi_subproc_t *subproc = interp->mimalloc.subproc;
+    for (int tag = 0; tag < _Py_MIMALLOC_HEAP_COUNT; tag++) {
+        _mi_abandoned_visit_blocks_unlocked(subproc, tag, false, &count_blocks,
+                                            &allocated_blocks);
     }
 #else
     // TODO(sgross): this only counts the current thread's blocks.

Python/gc_free_threading.c

@@ -399,16 +399,17 @@ gc_visit_heaps_lock_held(PyInterpreterState *interp, mi_block_visit_fun *visitor
         }
     }
 
-    // visit blocks in the per-interpreter abandoned pool (from dead threads)
-    mi_abandoned_pool_t *pool = &interp->mimalloc.abandoned_pool;
+    // visit blocks in abandoned segments (from dead threads) of the
+    // per-interpreter mimalloc sub-process.
+    mi_subproc_t *subproc = interp->mimalloc.subproc;
     arg->offset = offset_base;
-    if (!_mi_abandoned_pool_visit_blocks(pool, _Py_MIMALLOC_HEAP_GC, true,
-                                         visitor, arg)) {
+    if (!_mi_abandoned_visit_blocks_unlocked(subproc, _Py_MIMALLOC_HEAP_GC,
+                                             true, visitor, arg)) {
         return -1;
     }
     arg->offset = offset_pre;
-    if (!_mi_abandoned_pool_visit_blocks(pool, _Py_MIMALLOC_HEAP_GC_PRE, true,
-                                         visitor, arg)) {
+    if (!_mi_abandoned_visit_blocks_unlocked(subproc, _Py_MIMALLOC_HEAP_GC_PRE,
+                                             true, visitor, arg)) {
         return -1;
     }
     return 0;

Python/pystate.c

@@ -573,6 +573,11 @@ init_interpreter(PyInterpreterState *interp,
     PyConfig_InitPythonConfig(&interp->config);
 #ifdef Py_GIL_DISABLED
     _Py_brc_init_state(interp);
+
+    interp->mimalloc.subproc = mi_subproc_new();
+    if (interp->mimalloc.subproc == NULL) {
+        return _PyStatus_NO_MEMORY();
+    }
 #endif
 
     llist_init(&interp->mem_free_queue.head);
@@ -3325,10 +3330,11 @@ tstate_mimalloc_bind(PyThreadState *tstate)
     _mi_tld_init(tld, &mts->heaps[_Py_MIMALLOC_HEAP_MEM]);
     llist_init(&mts->page_list);
 
-    // Exiting threads push any remaining in-use segments to the abandoned
-    // pool to be re-claimed later by other threads. We use per-interpreter
-    // pools to keep Python objects from different interpreters separate.
-    tld->segments.abandoned = &tstate->interp->mimalloc.abandoned_pool;
+    // Exiting threads abandon any remaining in-use segments to be re-claimed
+    // later by other threads. We use a per-interpreter mimalloc sub-process
+    // to keep Python objects from different interpreters separate.
+    assert(tstate->interp->mimalloc.subproc != NULL);
+    tld->segments.subproc = tstate->interp->mimalloc.subproc;
 
     // Don't fill in the first N bytes up to ob_type in debug builds. We may
     // access ob_tid and the refcount fields in the dict and list lock-less
@@ -3346,7 +3352,7 @@ tstate_mimalloc_bind(PyThreadState *tstate)
 
     // Initialize each heap
     for (uint8_t i = 0; i < _Py_MIMALLOC_HEAP_COUNT; i++) {
-        _mi_heap_init_ex(&mts->heaps[i], tld, _mi_arena_id_none(), false, i);
+        _mi_heap_init(&mts->heaps[i], tld, _mi_arena_id_none(), false, i);
         mts->heaps[i].debug_offset = (uint8_t)debug_offsets[i];
     }