From 1fd84201f074e8e0e25a45112f1269a6cb5f01d8 Mon Sep 17 00:00:00 2001 From: CyberNative AI LLC Date: Thu, 5 Nov 2026 05:20:40 -0800 Subject: [PATCH 1/2] Use TypedData in the container C extensions Data_Wrap_Struct and Data_Get_Struct are not available in Ruby 4.1 (4.1.0-preview1), so the bst, deque, rbtree_map and splaytree_map extensions fail to compile and gem install fails there. Switch them to TypedData_Wrap_Struct and TypedData_Get_Struct with one rb_data_type_t per class. The existing mark/free implementations are reused, with bst's callback signatures changed to void pointers. Flags are 0, preserving deferred custom-free behavior. TypedData exists in Ruby 1.9.2, and the positional initializer matches Ruby 2.3.8's header layout. Builds were tested on Ruby 3.1.7, 4.0.7 and 4.1.0-preview1; Ruby 2.3 through 3.0 and 3.2 through 3.4 were not run for this revision. --- ext/containers/bst/bst.c | 21 ++++++++++++++++----- ext/containers/deque/deque.c | 13 +++++++++++-- ext/containers/rbtree_map/rbtree.c | 13 +++++++++++-- ext/containers/splaytree_map/splaytree.c | 13 +++++++++++-- 4 files changed, 49 insertions(+), 11 deletions(-) diff --git a/ext/containers/bst/bst.c b/ext/containers/bst/bst.c index 38b07146..244b0d86 100644 --- a/ext/containers/bst/bst.c +++ b/ext/containers/bst/bst.c @@ -18,9 +18,18 @@ static VALUE bst_initialize(VALUE self) { return self; } +static void bst_mark(void *ptr); +static void bst_free(void *ptr); + +static const rb_data_type_t bst_type = { + "Containers::CBst", + {bst_mark, bst_free, 0,}, + 0, 0, 0 +}; + static bst* get_bst_from_self(VALUE self) { bst *tree; - Data_Get_Struct(self, bst, tree); + TypedData_Get_Struct(self, bst, &bst_type, tree); return tree; } @@ -162,7 +171,8 @@ static void recursively_mark_nodes(bst_node *node) { } } -static void bst_mark(bst *tree) { +static void bst_mark(void *ptr) { + bst *tree = ptr; if (tree) { recursively_mark_nodes(tree->root); } @@ -176,7 +186,8 @@ static void recursively_free_nodes(bst_node *node) { } } -static void bst_free(bst *tree) { +static void bst_free(void *ptr) { + bst *tree = ptr; if (tree) { recursively_free_nodes(tree->root); } @@ -192,7 +203,7 @@ static bst* create_bst(int (*compare_function)(VALUE, VALUE)) { static VALUE bst_alloc(VALUE klass) { bst *tree = create_bst(&bst_compare_function); - return Data_Wrap_Struct(klass, bst_mark, bst_free, tree); + return TypedData_Wrap_Struct(klass, &bst_type, tree); } static VALUE rb_bst_push_value(VALUE self, VALUE key, VALUE value) { @@ -225,7 +236,7 @@ static VALUE rb_bst_delete(VALUE self, VALUE key) { static VALUE rb_bst_size(VALUE self) { bst *tree; - Data_Get_Struct(self,bst,tree); + TypedData_Get_Struct(self, bst, &bst_type, tree); return INT2FIX(tree->size); } diff --git a/ext/containers/deque/deque.c b/ext/containers/deque/deque.c index c24ba30c..158d6ba6 100644 --- a/ext/containers/deque/deque.c +++ b/ext/containers/deque/deque.c @@ -34,9 +34,18 @@ void clear_deque(deque *a_deque) { return; } +static void deque_mark(void *ptr); +static void deque_free(void *ptr); + +static const rb_data_type_t deque_type = { + "Containers::CDeque", + {deque_mark, deque_free, 0,}, + 0, 0, 0 +}; + static deque* get_deque_from_self(VALUE self) { deque *a_deque; - Data_Get_Struct(self, deque, a_deque); + TypedData_Get_Struct(self, deque, &deque_type, a_deque); return a_deque; } @@ -77,7 +86,7 @@ static void deque_free(void *ptr) { static VALUE deque_alloc(VALUE klass) { deque *deque = create_deque(); - return Data_Wrap_Struct(klass, deque_mark, deque_free, deque); + return TypedData_Wrap_Struct(klass, &deque_type, deque); } static VALUE deque_push_front(VALUE self, VALUE obj) { diff --git a/ext/containers/rbtree_map/rbtree.c b/ext/containers/rbtree_map/rbtree.c index 24cf1e4d..5fe50113 100644 --- a/ext/containers/rbtree_map/rbtree.c +++ b/ext/containers/rbtree_map/rbtree.c @@ -36,9 +36,18 @@ static void recursively_free_nodes(rbtree_node *node) { return; } +static void rbtree_mark(void *ptr); +static void rbtree_free(void *ptr); + +static const rb_data_type_t rbtree_type = { + "Containers::CRBTreeMap", + {rbtree_mark, rbtree_free, 0,}, + 0, 0, 0 +}; + static rbtree* get_tree_from_self(VALUE self) { rbtree *tree; - Data_Get_Struct(self, rbtree, tree); + TypedData_Get_Struct(self, rbtree, &rbtree_type, tree); return tree; } @@ -355,7 +364,7 @@ static void rbtree_free(void *ptr) { static VALUE rbtree_alloc(VALUE klass) { rbtree *tree = create_rbtree(&rbtree_compare_function); - return Data_Wrap_Struct(klass, rbtree_mark, rbtree_free, tree); + return TypedData_Wrap_Struct(klass, &rbtree_type, tree); } static VALUE rbtree_push(VALUE self, VALUE key, VALUE value) { diff --git a/ext/containers/splaytree_map/splaytree.c b/ext/containers/splaytree_map/splaytree.c index a8a12e79..f5fb85c7 100644 --- a/ext/containers/splaytree_map/splaytree.c +++ b/ext/containers/splaytree_map/splaytree.c @@ -33,9 +33,18 @@ static void recursively_free_nodes(splaytree_node *node) { return; } +static void splaytree_mark(void *ptr); +static void splaytree_free(void *ptr); + +static const rb_data_type_t splaytree_type = { + "Containers::CSplayTreeMap", + {splaytree_mark, splaytree_free, 0,}, + 0, 0, 0 +}; + static splaytree* get_tree_from_self(VALUE self) { splaytree *tree; - Data_Get_Struct(self, splaytree, tree); + TypedData_Get_Struct(self, splaytree, &splaytree_type, tree); return tree; } @@ -298,7 +307,7 @@ static void splaytree_free(void *ptr) { static VALUE splaytree_alloc(VALUE klass) { splaytree *tree = create_splaytree(&splaytree_compare_function); - return Data_Wrap_Struct(klass, splaytree_mark, splaytree_free, tree); + return TypedData_Wrap_Struct(klass, &splaytree_type, tree); } static VALUE splaytree_push(VALUE self, VALUE key, VALUE value) { From 25cc65dea5dcca49966fa09aae4a23f9abc7df0d Mon Sep 17 00:00:00 2001 From: CyberNative AI LLC Date: Thu, 5 Nov 2026 05:24:39 -0800 Subject: [PATCH 2/2] Do not allocate in the RBTreeMap and SplayTreeMap mark functions rbtree_mark and splaytree_mark built a linked-list queue with ALLOC while the GC was marking. Starting with CRuby 3.3.0, ALLOC/xmalloc in these mark callbacks is fatal in the normal single-Ractor GC path, with "[BUG] Cannot malloc during GC". On Ruby 3.1.7, allocation in the mark callback can re-enter GC under GC.stress and abort with "[BUG] during_gc != 0". Mark the nodes without allocating. The red-black tree is balanced, so plain recursion is enough. A splay tree can be a long chain (for example after inserting sorted keys), so mark_nodes recurses into the smaller subtree and loops on the larger one, which keeps the stack depth logarithmic. The same keys and values are marked as before. --- ext/containers/rbtree_map/rbtree.c | 47 ++++++--------------- ext/containers/splaytree_map/splaytree.c | 53 ++++++++---------------- 2 files changed, 30 insertions(+), 70 deletions(-) diff --git a/ext/containers/rbtree_map/rbtree.c b/ext/containers/rbtree_map/rbtree.c index 5fe50113..b74474c8 100644 --- a/ext/containers/rbtree_map/rbtree.c +++ b/ext/containers/rbtree_map/rbtree.c @@ -22,11 +22,6 @@ typedef struct { rbtree_node *root; } rbtree; -typedef struct struct_ll_node { - rbtree_node *node; - struct struct_ll_node *next; -} ll_node; - static void recursively_free_nodes(rbtree_node *node) { if(node) { recursively_free_nodes(node->left); @@ -318,39 +313,21 @@ static VALUE rbtree_init(VALUE self) return self; } +/* Must not allocate: Ruby aborts on malloc during GC. A red-black tree is + balanced, so the recursion depth is logarithmic. */ +static void recursively_mark_nodes(rbtree_node *node) { + if(node) { + rb_gc_mark(node->key); + rb_gc_mark(node->value); + recursively_mark_nodes(node->left); + recursively_mark_nodes(node->right); + } +} + static void rbtree_mark(void *ptr) { - ll_node *current, *new, *last, *old; if (ptr) { rbtree *tree = ptr; - - if (tree->root) { - current = ALLOC(ll_node); - last = current; - current->node = tree->root; - current->next = NULL; - - while(current) { - rb_gc_mark(current->node->key); - rb_gc_mark(current->node->value); - if (current->node->left) { - new = ALLOC(ll_node); - new->node = current->node->left; - new->next = NULL; - last->next = new; - last = new; - } - if (current->node->right) { - new = ALLOC(ll_node); - new->node = current->node->right; - new->next = NULL; - last->next = new; - last = new; - } - old = current; - current = current->next; - xfree(old); - } - } + recursively_mark_nodes(tree->root); } } diff --git a/ext/containers/splaytree_map/splaytree.c b/ext/containers/splaytree_map/splaytree.c index f5fb85c7..5528613d 100644 --- a/ext/containers/splaytree_map/splaytree.c +++ b/ext/containers/splaytree_map/splaytree.c @@ -19,11 +19,6 @@ typedef struct { splaytree_node *root; } splaytree; -typedef struct struct_ll_node { - splaytree_node *node; - struct struct_ll_node *next; -} ll_node; - static void recursively_free_nodes(splaytree_node *node) { if(node) { recursively_free_nodes(node->left); @@ -261,39 +256,27 @@ static VALUE splaytree_init(VALUE self) return self; } +/* Must not allocate: Ruby aborts on malloc during GC. A splay tree can be + as deep as it is large, so recurse into the smaller subtree and loop on + the larger one to keep the C stack depth logarithmic. */ +static void mark_nodes(splaytree_node *node) { + while(node) { + rb_gc_mark(node->key); + rb_gc_mark(node->value); + if (node_size(node->left) < node_size(node->right)) { + mark_nodes(node->left); + node = node->right; + } else { + mark_nodes(node->right); + node = node->left; + } + } +} + static void splaytree_mark(void *ptr) { - ll_node *current, *new, *last, *old; if (ptr) { splaytree *tree = ptr; - - if (tree->root) { - current = ALLOC(ll_node); - last = current; - current->node = tree->root; - current->next = NULL; - - while(current) { - rb_gc_mark(current->node->key); - rb_gc_mark(current->node->value); - if (current->node->left) { - new = ALLOC(ll_node); - new->node = current->node->left; - new->next = NULL; - last->next = new; - last = new; - } - if (current->node->right) { - new = ALLOC(ll_node); - new->node = current->node->right; - new->next = NULL; - last->next = new; - last = new; - } - old = current; - current = current->next; - xfree(old); - } - } + mark_nodes(tree->root); } }