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..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); @@ -36,9 +31,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; } @@ -309,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); } } @@ -355,7 +341,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..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); @@ -33,9 +28,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; } @@ -252,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); } } @@ -298,7 +290,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) {