wash/mango
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sandbox: btree: add macros to define custom btree inserter

Browse Source 
tree keys are no longer stored in btree_node_t. The tree user is responsible for
defining their own node type that includes btree_node_t, and a comparator for the nodes.
This commit is contained in:
max 🍓
2023-01-26 18:30:14 +00:00
parent c35f06e191
commit e2fbc4e40b
2 changed files with 125 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
sandbox/btree/btree.c
View File

@@ -4,14 +4,6 @@
#include <stdio.h>
#include <assert.h>
#define BTREE_VERBOSE
#ifdef BTREE_VERBOSE
#define debug_msg(...) printf(__VA_ARGS__)
#else
#define debug_msg(...)
#endif
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
@@ -27,8 +19,6 @@
#define HEIGHT(x) ((x) ? (x)->b_height : 0)
extern void btree_print(btree_node_t *, int);
static inline void update_height(btree_node_t *x)
{
x->b_height = MAX(HEIGHT(x->b_left), HEIGHT((x->b_right))) + 1;
@@ -65,8 +55,6 @@ static void rotate_left(btree_t *tree, btree_node_t *x)
assert(x == x->b_parent->b_left || x == x->b_parent->b_right);
}
debug_msg(" rotate_left(x: %llu, y: %llu)\n", x->b_key, y->b_key);
btree_node_t *p = x->b_parent;
if (y->b_left) {
@@ -78,10 +66,8 @@ static void rotate_left(btree_t *tree, btree_node_t *x)
if (!p) {
tree->b_root = y;
} else if (x == p->b_left) {
debug_msg(" %llu->left was %llu, now %llu\n", p->b_key, p->b_left->b_key, y->b_key);
p->b_left = y;
} else {
debug_msg(" %llu->right was %llu, now %llu\n", p->b_key, p->b_right->b_key, y->b_key);
p->b_right = y;
}
@@ -110,8 +96,6 @@ static void rotate_right(btree_t *tree, btree_node_t *y)
assert(y == y->b_parent->b_left || y == y->b_parent->b_right);
}
debug_msg(" rotate_right(y: %llu, x: %llu)\n", y->b_key, x->b_key);
btree_node_t *p = y->b_parent;
if (x->b_right) {
@@ -123,10 +107,8 @@ static void rotate_right(btree_t *tree, btree_node_t *y)
if (!p) {
tree->b_root = x;
} else if (y == p->b_left) {
debug_msg(" %llu->left was %llu, now %llu\n", p->b_key, p->b_left->b_key, x->b_key);
p->b_left = x;
} else {
debug_msg(" %llu->right was %llu, now %llu\n", p->b_key, p->b_right->b_key, x->b_key);
p->b_right = x;
}
@@ -139,13 +121,10 @@ static void rotate_double_left(btree_t *tree, btree_node_t *z)
{
btree_node_t *x = z->b_right;
btree_node_t *y = x->b_left;
debug_msg("rotate_double_left(z: %llu, x: %llu, y: %llu) {\n", z->b_key, x->b_key, y->b_key);
rotate_right(tree, x);
rotate_left(tree, z);
debug_msg("}\n");
update_height(z);
update_height(x);
@@ -159,13 +138,10 @@ static void rotate_double_right(btree_t *tree, btree_node_t *z)
{
btree_node_t *x = z->b_left;
btree_node_t *y = x->b_right;
debug_msg("rotate_double_right(z: %llu, x: %llu, y: %llu) {\n", z->b_key, x->b_key, y->b_key);
rotate_left(tree, x);
rotate_right(tree, z);
debug_msg("}\n");
update_height(z);
update_height(x);
@@ -216,15 +192,11 @@ next_ancestor:
static void delete_fixup(btree_t *tree, btree_node_t *w)
{
printf("delete_fixup(%llu)\n", w->b_key);
btree_node_t *z = w;
int nr_rotations = 0;
while (z) {
printf("bf(z)=%d\n", bf(z));
printf("bf(z->b_left)=%d\n", bf(z->b_left));
if (bf(z) > 1) {
if (bf(z->b_right) >= 0) {
rotate_left(tree, z);
@@ -246,10 +218,22 @@ static void delete_fixup(btree_t *tree, btree_node_t *w)
}
}
void btree_insert_fixup(btree_t *tree, btree_node_t *node)
{
node->b_height = 0;
btree_node_t *cur = node;
while (cur) {
update_height(cur);
cur = cur->b_parent;
}
insert_fixup(tree, node);
}
#if 0
void btree_insert(btree_t *tree, btree_node_t *node)
{
node->b_owner = tree;
if (!tree->b_root) {
tree->b_root = node;
node->b_parent = NULL;
@@ -262,7 +246,6 @@ void btree_insert(btree_t *tree, btree_node_t *node)
btree_node_t **nextp = NULL;
if (node->b_key == cur->b_key) {
node->b_owner = NULL;
return;
}
@@ -289,18 +272,12 @@ void btree_insert(btree_t *tree, btree_node_t *node)
cur = cur->b_parent;
}
#if 0
printf("##### TREE POST-INSERT, PRE-FIXUP ##############\n");
btree_print(tree->b_root, 0);
printf("################################################\n");
#endif
insert_fixup(tree, node);
}
#endif
static btree_node_t *remove_node_with_no_children(btree_t *tree, btree_node_t *node)
{
debug_msg("remove_node_with_no_children(%llu)\n", node->b_key);
btree_node_t *w = node->b_parent;
btree_node_t *p = node->b_parent;
node->b_parent = NULL;
@@ -323,7 +300,6 @@ static btree_node_t *remove_node_with_no_children(btree_t *tree, btree_node_t *n
static btree_node_t *replace_node_with_one_subtree(btree_t *tree, btree_node_t *node)
{
debug_msg("remove_node_with_one_subtree()\n");
btree_node_t *p = node->b_parent;
btree_node_t *z = NULL;
@@ -357,8 +333,6 @@ static btree_node_t *replace_node_with_one_subtree(btree_t *tree, btree_node_t *
static btree_node_t *replace_node_with_two_subtrees(btree_t *tree, btree_node_t *z)
{
debug_msg("remove_node_with_two_subtrees()\n");
/* x will replace z */
btree_node_t *x = z->b_left;
@@ -417,17 +391,11 @@ static btree_node_t *replace_node_with_two_subtrees(btree_t *tree, btree_node_t
cur = cur->b_parent;
}
printf("w=%llu, h:%u\n", w->b_key, w->b_height);
return w;
}
void btree_delete(btree_t *tree, btree_node_t *node)
{
if (!node->b_owner) {
return;
}
assert(node->b_owner == tree);
btree_node_t *w = NULL;
if (HAS_NO_CHILDREN(node)) {
@@ -438,8 +406,6 @@ void btree_delete(btree_t *tree, btree_node_t *node)
w = replace_node_with_two_subtrees(tree, node);
}
btree_print(tree->b_root, 0);
if (w) {
delete_fixup(tree, w);
}

115
sandbox/btree/include/socks/btree.h
View File

@@ -3,22 +3,127 @@
#include <stdint.h>
typedef uint64_t btree_key_t;
#define BTREE_CONTAINER(t, m, v) ((void *)((v) ? (uintptr_t)(v) - (offsetof(t, m)) : 0))
struct btree;
#define BTREE_DEFINE_SIMPLE_INSERT(node_type, container_node_member, container_key_member, function_name) \
static void function_name(btree_t *tree, node_type *node) \
{ \
if (!tree->b_root) { \
tree->b_root = &node->container_node_member; \
btree_insert_fixup(tree, &node->container_node_member); \
return; \
} \
\
btree_node_t *cur = tree->b_root; \
while (1) { \
node_type *cur_node = BTREE_CONTAINER(node_type, container_node_member, cur); \
btree_node_t *next = NULL; \
\
if (node->container_key_member > cur_node->container_key_member) { \
next = btree_right(cur); \
\
if (!next) { \
btree_put_right(cur, &node->container_node_member); \
break; \
} \
} else if (node->container_key_member < cur_node->container_key_member) { \
next = btree_left(cur); \
\
if (!next) { \
btree_put_left(cur, &node->container_node_member); \
break; \
} \
} else { \
return; \
} \
\
cur = next; \
} \
\
btree_insert_fixup(tree, &node->container_node_member); \
}
#define BTREE_DEFINE_INSERT(node_type, container_node_member, container_key_member, function_name, comparator) \
static void function_name(btree_t *tree, node_type *node) \
{ \
if (!tree->b_root) { \
tree->b_root = &node->container_node_member; \
btree_insert_fixup(tree, &node->container_node_member); \
return; \
} \
\
btree_node_t *cur = tree->b_root; \
while (1) { \
node_type *cur_node = BTREE_CONTAINER(node_type, container_node_member, cur); \
btree_node_t *next = NULL; \
int cmp = comparator(node, cur_node); \
\
if (cmp == 1) { \
next = btree_right(cur); \
\
if (!next) { \
btree_put_right(cur, &node->container_node_member); \
break; \
} \
} else if (cmp == -1) { \
next = btree_left(cur); \
\
if (!next) { \
btree_put_left(cur, &node->container_node_member); \
break; \
} \
} else { \
return; \
} \
\
cur = next; \
} \
\
btree_insert_fixup(tree, &node->container_node_member); \
}
typedef struct btree_node {
struct btree_node *b_parent, *b_left, *b_right;
unsigned short b_height;
btree_key_t b_key;
struct btree *b_owner;
} btree_node_t;
typedef struct btree {
struct btree_node *b_root;
} btree_t;
extern void btree_insert(btree_t *tree, btree_node_t *node);
extern void btree_insert_fixup(btree_t *tree, btree_node_t *node);
extern void btree_delete(btree_t *tree, btree_node_t *node);
static inline void btree_put_left(btree_node_t *parent, btree_node_t *child)
{
parent->b_left = child;
child->b_parent = parent;
}
static inline void btree_put_right(btree_node_t *parent, btree_node_t *child)
{
parent->b_right = child;
child->b_parent = parent;
}
static inline btree_node_t *btree_left(btree_node_t *node)
{
return node->b_left;
}
static inline btree_node_t *btree_right(btree_node_t *node)
{
return node->b_right;
}
static inline btree_node_t *btree_parent(btree_node_t *node)
{
return node->b_parent;
}
static inline unsigned short btree_height(btree_node_t *node)
{
return node->b_height;
}
#endif