Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
21 changes: 16 additions & 5 deletions ext/containers/bst/bst.c
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}

Expand Down Expand Up @@ -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);
}
Expand All @@ -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);
}
Expand All @@ -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) {
Expand Down Expand Up @@ -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);
}

Expand Down
13 changes: 11 additions & 2 deletions ext/containers/deque/deque.c
Original file line number Diff line number Diff line change
Expand Up @@ -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;
}

Expand Down Expand Up @@ -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) {
Expand Down
60 changes: 23 additions & 37 deletions ext/containers/rbtree_map/rbtree.c
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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;
}

Expand Down Expand Up @@ -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);
}
}

Expand All @@ -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) {
Expand Down
66 changes: 29 additions & 37 deletions ext/containers/splaytree_map/splaytree.c
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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;
}

Expand Down Expand Up @@ -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);
}
}

Expand All @@ -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) {
Expand Down