Make C extension Ractor-safe (xmalloc rmem pages, declare rb_ext_ractor_safe)

Author: ianks

ext/msgpack/rbinit.c

@@ -24,6 +24,14 @@
 
 RUBY_FUNC_EXPORTED void Init_msgpack(void)
 {
+    /*
+     * MSGPACK_RMEM_RACTOR_SAFE: the C methods no longer touch process-global
+     * mutable state (the s_rmem / s_stack_rmem page slabs were replaced with
+     * xmalloc/xfree in rmem.h). Declaring the extension Ractor-safe lets a
+     * MessagePack::Factory built inside a non-main Ractor call pack/unpack.
+     */
+    rb_ext_ractor_safe(true);
+
     VALUE mMessagePack = rb_define_module("MessagePack");
 
     MessagePack_Buffer_module_init(mMessagePack);

ext/msgpack/rmem.c

@@ -18,22 +18,20 @@
 
 #include "rmem.h"
 
+/*
+ * MSGPACK_RMEM_RACTOR_SAFE: pages are now served directly by xmalloc/xfree
+ * (see rmem.h). The process-global page slab is gone, so there is nothing to
+ * initialize or tear down here. These remain as no-ops to keep the
+ * static_init / static_destroy call sites and ABI unchanged.
+ */
 void msgpack_rmem_init(msgpack_rmem_t* pm)
 {
     memset(pm, 0, sizeof(msgpack_rmem_t));
-    pm->head.pages = xmalloc(MSGPACK_RMEM_PAGE_SIZE * 32);
-    pm->head.mask = 0xffffffff;  /* all bit is 1 = available */
 }
 
 void msgpack_rmem_destroy(msgpack_rmem_t* pm)
 {
-    msgpack_rmem_chunk_t* c = pm->array_first;
-    msgpack_rmem_chunk_t* cend = pm->array_last;
-    for(; c != cend; c++) {
-        xfree(c->pages);
-    }
-    xfree(pm->head.pages);
-    xfree(pm->array_first);
+    (void)pm;
 }
 
 void* _msgpack_rmem_alloc2(msgpack_rmem_t* pm)

ext/msgpack/rmem.h

@@ -74,34 +74,38 @@ static inline bool _msgpack_rmem_chunk_try_free(msgpack_rmem_chunk_t* c, void* m
     return false;
 }
 
+void _msgpack_rmem_chunk_free(msgpack_rmem_t* pm, msgpack_rmem_chunk_t* c);
+
+/*
+ * MSGPACK_RMEM_RACTOR_SAFE: the original implementation recycled fixed-size
+ * pages from a process-global slab (msgpack_rmem_t s_rmem / s_stack_rmem),
+ * mutating a shared bitmask with no locking. That made the C extension unsafe
+ * to call from multiple Ractors (or threads) in parallel, and the page slab
+ * could not declare rb_ext_ractor_safe(true).
+ *
+ * We instead hand out each page via Ruby's xmalloc/xfree. These are safe to
+ * call from any Ractor's execution context, and freeing during GC sweep on a
+ * different thread than the allocator (the common case for Unpacker_free's
+ * RUBY_TYPED_FREE_IMMEDIATELY dfree callback) is correct. Pages are still
+ * contiguous MSGPACK_RMEM_PAGE_SIZE blocks, so the buffer's intra-page
+ * sub-allocation bookkeeping (rmem_owner / rmem_last / rmem_end) is unchanged.
+ *
+ * Trade-off: we lose the per-slab page-recycling fast path. The system
+ * allocator (jemalloc in production Ruby) services these 4 KiB allocations from
+ * per-thread arenas, so the overhead is small and, crucially, identical for
+ * serial and pooled decode paths.
+ */
 static inline void* msgpack_rmem_alloc(msgpack_rmem_t* pm)
 {
-    if(_msgpack_rmem_chunk_available(&pm->head)) {
-        return _msgpack_rmem_chunk_alloc(&pm->head);
-    }
-    return _msgpack_rmem_alloc2(pm);
+    (void)pm;
+    return xmalloc(MSGPACK_RMEM_PAGE_SIZE);
 }
 
-void _msgpack_rmem_chunk_free(msgpack_rmem_t* pm, msgpack_rmem_chunk_t* c);
-
 static inline bool msgpack_rmem_free(msgpack_rmem_t* pm, void* mem)
 {
-    if(_msgpack_rmem_chunk_try_free(&pm->head, mem)) {
-        return true;
-    }
-
-    /* search from last */
-    msgpack_rmem_chunk_t* c = pm->array_last - 1;
-    msgpack_rmem_chunk_t* before_first = pm->array_first - 1;
-    for(; c != before_first; c--) {
-        if(_msgpack_rmem_chunk_try_free(c, mem)) {
-            if(c != pm->array_first && c->mask == 0xffffffff) {
-                _msgpack_rmem_chunk_free(pm, c);
-            }
-            return true;
-        }
-    }
-    return false;
+    (void)pm;
+    xfree(mem);
+    return true;
 }