greg/skiplist
1
0
Fork 0
Code Issues Pull requests 2 Packages Projects Releases Wiki Activity

impl remove api

Browse source
This commit is contained in:
Gregory Burd 2024-03-19 12:33:11 -04:00
parent 81d2f817f2
commit de415b0d65
2 changed files with 366 additions and 276 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
examples/slm.c
View file

@ -29,7 +29,10 @@ struct slex_node {
/* /*
* Generate all the access functions for our type of Skiplist. * Generate all the access functions for our type of Skiplist.
*/ */
SKIPLIST_DECL(slex, api_, entries, { (void)node; }) SKIPLIST_DECL(
slex, api_, entries,
/* free node */ { (void)node; },
/* update node */ { node->value = new->value; })
/* /*
* Getter * Getter
@ -103,14 +106,25 @@ main()
/* Insert 7 key/value pairs into the list. */ /* Insert 7 key/value pairs into the list. */
for (int i = -2; i <= 2; i++) { for (int i = -2; i <= 2; i++) {
int v;
slex_node_t new;
rc = api_skip_alloc_node_slex(list, &n); rc = api_skip_alloc_node_slex(list, &n);
if (rc) if (rc)
return rc; return rc;
n->key = i; n->key = i;
n->value = i; n->value = i;
api_skip_insert_slex(list, n); api_skip_insert_slex(list, n);
v = api_skip_get_slex(list, i);
((void)v);
new.key = n->key;
new.value = n->value * 10;
api_skip_update_slex(list, &new);
} }
slex_node_t q;
q.key = 0;
api_skip_remove_slex(list, &q);
FILE *of = fopen("/tmp/slm.dot", "w"); FILE *of = fopen("/tmp/slm.dot", "w");
if (!of) { if (!of) {
perror("Failed to open file /tmp/slm.dot"); perror("Failed to open file /tmp/slm.dot");

626
include/sl.h
View file

@ -57,11 +57,11 @@
(size) = (size == 0 ? 254 : size); \ (size) = (size == 0 ? 254 : size); \
(var) = (type **)calloc(sizeof(type *), size + 2); \ (var) = (type **)calloc(sizeof(type *), size + 2); \
if ((var) != NULL) { \ if ((var) != NULL) { \
*(var)++ = (type *)size; \ *(var)++ = (void *)(uintptr_t)size; \
*(var)++ = 0; \ *(var)++ = (void *)(uintptr_t)0; \
} \ } \
} while (0) } while (0)
#define ARRAY_FREE(var) free((var)-2) #define ARRAY_FREE(list) free((list)-2)
#define ARRAY_SIZE(list) (unsigned int)(uintptr_t)(list)[-2] #define ARRAY_SIZE(list) (unsigned int)(uintptr_t)(list)[-2]
#define ARRAY_SET_SIZE(list, size) (list)[-2] = (void *)(uintptr_t)(size) #define ARRAY_SET_SIZE(list, size) (list)[-2] = (void *)(uintptr_t)(size)
#define ARRAY_LENGTH(list) (unsigned int)(uintptr_t)(list)[-1] #define ARRAY_LENGTH(list) (unsigned int)(uintptr_t)(list)[-1]
@ -111,284 +111,360 @@
fn \ fn \
} }
#define SKIPLIST_DECL(decl, prefix, field, free_node_blk) \ #define SKIPLIST_DECL(decl, prefix, field, free_node_blk, update_node_blk) \
\ \
/* Skiplist node type */ \ /* Skiplist node type */ \
typedef struct decl##_node decl##_node_t; \ typedef struct decl##_node decl##_node_t; \
\ \
/* Skiplist type */ \ /* Skiplist type */ \
typedef struct decl { \ typedef struct decl { \
size_t level, length, max, fanout; \ size_t level, length, max, fanout; \
int (*cmp)(struct decl *, decl##_node_t *, decl##_node_t *, void *); \ int (*cmp)(struct decl *, decl##_node_t *, decl##_node_t *, void *); \
void *aux; \ void *aux; \
decl##_node_t *slh_head; \ decl##_node_t *slh_head; \
decl##_node_t *slh_tail; \ decl##_node_t *slh_tail; \
} decl##_t; \ } decl##_t; \
\ \
/* -- __skip_key_compare_ \ /* -- __skip_key_compare_ \
* \ * \
* This function takes four arguments: \ * This function takes four arguments: \
* - a reference to the Skiplist \ * - a reference to the Skiplist \
* - the two nodes to compare, `a` and `b` \ * - the two nodes to compare, `a` and `b` \
* - `aux` an additional auxiliary argument \ * - `aux` an additional auxiliary argument \
* and returns: \ * and returns: \
* a < b : return -1 \ * a < b : return -1 \
* a == b : return 0 \ * a == b : return 0 \
* a > b : return 1 \ * a > b : return 1 \
*/ \ */ \
static int __skip_key_compare_##decl(decl##_t *slist, decl##_node_t *a, \ static int __skip_key_compare_##decl(decl##_t *slist, decl##_node_t *a, \
decl##_node_t *b, void *aux) \ decl##_node_t *b, void *aux) \
{ \ { \
if (a == b) \ if (a == b) \
return 0; \ return 0; \
if (a == slist->slh_head || b == slist->slh_tail) \ if (a == slist->slh_head || b == slist->slh_tail) \
return -1; \ return -1; \
if (a == slist->slh_tail || b == slist->slh_head) \ if (a == slist->slh_tail || b == slist->slh_head) \
return 1; \ return 1; \
return slist->cmp(slist, a, b, aux); \ return slist->cmp(slist, a, b, aux); \
} \ } \
\ \
/* -- __skip_toss_ */ \ /* -- __skip_toss_ */ \
static int __skip_toss_##decl(size_t max, size_t fanout) \ static int __skip_toss_##decl(size_t max, size_t fanout) \
{ \ { \
size_t level = 0; \ size_t level = 0; \
while (level + 1 < max) { \ while (level + 1 < max) { \
if (rand() % fanout == 0) /* NOLINT(*-msc50-cpp) */ \ if (rand() % fanout == 0) /* NOLINT(*-msc50-cpp) */ \
level++; \ level++; \
else \ else \
break; \ break; \
} \ } \
return level; \ return level; \
} \ } \
\ \
/* -- skip_alloc_node_ */ \ /* -- skip_alloc_node_ */ \
int prefix##skip_alloc_node_##decl(decl##_t *slist, decl##_node_t **node) \ int prefix##skip_alloc_node_##decl(decl##_t *slist, decl##_node_t **node) \
{ \ { \
decl##_node_t *n; \ decl##_node_t *n; \
n = (decl##_node_t *)calloc(1, sizeof(decl##_node_t)); \ n = (decl##_node_t *)calloc(1, sizeof(decl##_node_t)); \
ARRAY_ALLOC(n->field.sle_next, struct decl##_node, slist->max); \ ARRAY_ALLOC(n->field.sle_next, struct decl##_node, slist->max); \
if (n && n->field.sle_next) { \ if (n && n->field.sle_next) { \
ARRAY_SET_SIZE(n->field.sle_next, slist->max); \ ARRAY_SET_SIZE(n->field.sle_next, slist->max); \
ARRAY_SET_LENGTH(n->field.sle_next, 0); \ ARRAY_SET_LENGTH(n->field.sle_next, 0); \
*node = n; \ *node = n; \
return 0; \ return 0; \
} \ } \
return ENOMEM; \ return ENOMEM; \
} \ } \
\ \
/* -- skip_init_ \ /* -- skip_init_ \
* max: 12, fanout: 4 are good defaults. \ * max: 12, fanout: 4 are good defaults. \
*/ \ */ \
int prefix##skip_init_##decl(decl##_t *slist, size_t max, size_t fanout, \ int prefix##skip_init_##decl(decl##_t *slist, size_t max, size_t fanout, \
int (*cmp)(struct decl *, decl##_node_t *, decl##_node_t *, void *)) \ int (*cmp)(struct decl *, decl##_node_t *, decl##_node_t *, void *)) \
{ \ { \
int rc = 0; \ int rc = 0; \
slist->level = 0; \ slist->level = 0; \
slist->length = 0; \ slist->length = 0; \
slist->max = max; \ slist->max = max; \
slist->fanout = fanout; \ slist->fanout = fanout; \
slist->cmp = cmp; \ slist->cmp = cmp; \
rc = prefix##skip_alloc_node_##decl(slist, &slist->slh_head); \ rc = prefix##skip_alloc_node_##decl(slist, &slist->slh_head); \
if (rc) \ if (rc) \
goto fail; \ goto fail; \
rc = prefix##skip_alloc_node_##decl(slist, &slist->slh_tail); \ rc = prefix##skip_alloc_node_##decl(slist, &slist->slh_tail); \
if (rc) \ if (rc) \
goto fail; \ goto fail; \
ARRAY_SET_LENGTH(slist->slh_head->field.sle_next, max); \ ARRAY_SET_LENGTH(slist->slh_head->field.sle_next, max); \
for (size_t __i = 0; __i < max; __i++) \ for (size_t __i = 0; __i < max; __i++) \
slist->slh_head->field.sle_next[__i] = slist->slh_tail; \ slist->slh_head->field.sle_next[__i] = slist->slh_tail; \
slist->slh_head->field.sle_prev = NULL; \ slist->slh_head->field.sle_prev = NULL; \
ARRAY_SET_LENGTH(slist->slh_tail->field.sle_next, max); \ ARRAY_SET_LENGTH(slist->slh_tail->field.sle_next, max); \
for (size_t __i = 0; __i < max; __i++) \ for (size_t __i = 0; __i < max; __i++) \
slist->slh_tail->field.sle_next[__i] = NULL; \ slist->slh_tail->field.sle_next[__i] = NULL; \
slist->slh_head->field.sle_prev = slist->slh_tail; \ slist->slh_head->field.sle_prev = slist->slh_tail; \
fail:; \ fail:; \
return rc; \ return rc; \
} \ } \
\ \
/* -- skip_free_node_ */ \ /* -- skip_free_node_ */ \
void prefix##skip_free_node_##decl(decl##_node_t *node) \ void prefix##skip_free_node_##decl(decl##_node_t *node) \
{ \ { \
free_node_blk; \ free_node_blk; \
free(node->field.sle_next); \ free(node->field.sle_next); \
free(node); \ free(node); \
} \ } \
\ \
/* -- skip_destroy_ */ \ /* -- skip_size_ */ \
int prefix##skip_destroy_##decl(decl##_t *slist, decl##_node_t *n) \ int prefix##skip_size_##decl(decl##_t *slist) \
{ \ { \
((void)slist); /* TODO */ \ return slist->length; \
((void)n); \ } \
return 0; \ \
} \ /* -- skip_empty_ */ \
\ int prefix##skip_empty_##decl(decl##_t *slist) \
/* -- skip_size_ */ \ { \
int prefix##skip_size_##decl(decl##_t *slist, decl##_node_t *n) \ return slist->length == 0; \
{ \ } \
((void)slist); /* TODO */ \ \
((void)n); \ /* -- skip_head_ */ \
return 0; \ decl##_node_t *prefix##skip_head_##decl(decl##_t *slist) \
} \ { \
\ return slist->slh_head; \
/* -- skip_empty_ */ \ } \
int prefix##skip_empty_##decl(decl##_t *slist) \ \
{ \ /* -- skip_tail_ */ \
((void)slist); /* TODO */ \ decl##_node_t *prefix##skip_tail_##decl(decl##_t *slist) \
return 0; \ { \
} \ return slist->slh_tail; \
\ } \
/* -- skip_head_ */ \ \
int prefix##skip_head_##decl(decl##_t *slist, decl##_node_t *n) \ /* -- skip_locate_ */ \
{ \ decl##_node_t **prefix##skip_locate_##decl(decl##_t *slist, \
((void)slist); /* TODO */ \ decl##_node_t *n) \
((void)n); \ { \
return 0; \ unsigned int i; \
} \ decl##_node_t **path; \
\ decl##_node_t *elm = slist->slh_head; \
/* -- skip_tail_ */ \ \
int prefix##skip_tail_##decl(decl##_t *slist, decl##_node_t *n) \ if (n == NULL) \
{ \ return NULL; \
((void)slist); /* TODO */ \ \
((void)n); \ i = slist->max + 1; \
return 0; \ ARRAY_ALLOC(path, decl##_node_t, i); \
} \ ARRAY_SET_LENGTH(path, 1); \
\ i = slist->level; \
/* -- skip_locate_ */ \ if (path == NULL) \
decl##_node_t *prefix##skip_locate_##decl(decl##_t *slist, decl##_node_t *n) \ return NULL; \
{ \ \
((void)slist); /* TODO */ \ /* Find the node that matches `node` or NULL. */ \
((void)n); \ do { \
return NULL; \ while (elm && \
} \ __skip_key_compare_##decl(slist, elm->field.sle_next[i], n, \
\ slist->aux) < 0) \
/* -- skip_insert_ */ \ elm = elm->field.sle_next[i]; \
int prefix##skip_insert_##decl(decl##_t *slist, decl##_node_t *n) \ path[i + 1] = elm; \
{ \ ARRAY_SET_LENGTH(path, ARRAY_LENGTH(path) + 1); \
if (n == NULL) \ } while (i--); \
return ENOMEM; \ elm = elm->field.sle_next[0]; \
decl##_node_t *prev, *elm = slist->slh_head; \ if (__skip_key_compare_##decl(slist, elm, n, slist->aux) == 0) { \
unsigned int i; \ path[0] = elm; \
decl##_node_t **path; \ return path; \
i = slist->level; \ } \
ARRAY_ALLOC(path, decl##_node_t, slist->max); \ ARRAY_FREE(path); \
if (path == NULL) \ return NULL; \
return ENOMEM; \ } \
/* Find the position in the list where this element belongs. */ \ \
do { \ /* -- skip_insert_ */ \
while (elm && \ int prefix##skip_insert_##decl(decl##_t *slist, decl##_node_t *n) \
__skip_key_compare_##decl(slist, elm->field.sle_next[i], n, \ { \
slist->aux) < 0) \ unsigned int i; \
elm = elm->field.sle_next[i]; \ decl##_node_t *prev, *elm = slist->slh_head; \
path[i] = elm; \ decl##_node_t **path; \
ARRAY_SET_LENGTH(path, ARRAY_LENGTH(path) + 1); \ \
} while (i--); \ if (n == NULL) \
i = 0; \ return ENOENT; \
prev = elm; \ \
elm = elm->field.sle_next[0]; \ i = slist->level; \
if (__skip_key_compare_##decl(slist, elm, n, slist->aux) == 0) { \ ARRAY_ALLOC(path, decl##_node_t, slist->max); \
/* Don't overwrite, to do that use _REPLACE not _INSERT */ \ if (path == NULL) \
ARRAY_FREE(path); \ return ENOMEM; \
return -1; \ \
} \ /* Find the position in the list where this element belongs. */ \
size_t level = __skip_toss_##decl(slist->max, slist->fanout); \ do { \
ARRAY_SET_LENGTH(n->field.sle_next, level); \ while (elm && \
if (level > slist->level) { \ __skip_key_compare_##decl(slist, elm->field.sle_next[i], n, \
for (i = slist->level + 1; i <= level; i++) { \ slist->aux) < 0) \
path[i] = slist->slh_tail; \ elm = elm->field.sle_next[i]; \
} \ path[i] = elm; \
slist->level = level; \ ARRAY_SET_LENGTH(path, ARRAY_LENGTH(path) + 1); \
} \ } while (i--); \
for (i = 0; i <= level; i++) { \ i = 0; \
n->field.sle_next[i] = path[i]->field.sle_next[i]; \ prev = elm; \
path[i]->field.sle_next[i] = n; \ elm = elm->field.sle_next[0]; \
} \ if (__skip_key_compare_##decl(slist, elm, n, slist->aux) == 0) { \
n->field.sle_prev = prev; \ /* Don't overwrite, to do that use _REPLACE not _INSERT */ \
if (n->field.sle_next[0] == slist->slh_tail) { \ ARRAY_FREE(path); \
slist->slh_tail->field.sle_prev = n; \ return -1; \
} \ } \
slist->length++; \ size_t level = __skip_toss_##decl(slist->max, slist->fanout); \
ARRAY_FREE(path); \ ARRAY_SET_LENGTH(n->field.sle_next, level); \
return 0; \ if (level > slist->level) { \
} \ for (i = slist->level + 1; i <= level; i++) { \
\ path[i] = slist->slh_tail; \
/* -- skip_insert_dup_ */ \ } \
int prefix##skip_insert_dup_##decl(decl##_t *slist, decl##_node_t *n) \ slist->level = level; \
{ \ } \
((void)slist); /* TODO */ \ for (i = 0; i <= level; i++) { \
((void)n); \ n->field.sle_next[i] = path[i]->field.sle_next[i]; \
return 0; \ path[i]->field.sle_next[i] = n; \
} \ } \
\ n->field.sle_prev = prev; \
/* -- skip_update_ */ \ if (n->field.sle_next[0] == slist->slh_tail) { \
int prefix##skip_update_##decl(decl##_t *slist, decl##_node_t *n) \ slist->slh_tail->field.sle_prev = n; \
{ \ } \
((void)slist); /* TODO */ \ slist->length++; \
((void)n); \ ARRAY_FREE(path); \
return 0; \ return 0; \
} \ } \
\ \
/* -- skip_delete_ */ \ /* -- skip_insert_dup_ TODO \
int prefix##skip_delete_##decl(decl##_t *slist, decl##_node_t *n) \ int prefix##skip_insert_dup_##decl(decl##_t *slist, decl##_node_t *n) \
{ \ { \
((void)slist); /* TODO */ \ ((void)slist); \
((void)n); \ ((void)n); \
return 0; \ return 0; \
} \ } \
\ */ \
/* -- skip_find_ */ \ \
int prefix##skip_find_##decl(decl##_t *slist, decl##_node_t *n) \ /* -- skip_update_ \
{ \ * Locates a node in the list that equals the `new` node and then \
((void)slist); /* TODO */ \ * uses the `update_node_blk` to update the contents. \
((void)n); \ * WARNING: Do not update the portion of the node used for ordering \
return 0; \ * (e.g. `key`) unless you really know what you're doing. \
} \ */ \
\ int prefix##skip_update_##decl(decl##_t *slist, decl##_node_t *new) \
/* -- skip_find_gte */ \ { \
int prefix##skip_find_gte_##decl(decl##_t *slist, decl##_node_t *n) \ decl##_node_t **path, *node; \
{ \ \
((void)slist); /* TODO */ \ if (!slist || !new) \
((void)n); \ return -1; \
return 0; \ \
} \ path = prefix##skip_locate_##decl(slist, new); \
\ if (ARRAY_SIZE(path) > 0) { \
/* -- skip_find_lte */ \ node = path[0]; \
int prefix##skip_find_lte_##decl(decl##_t *slist, decl##_node_t *n) \ ARRAY_FREE(path); \
{ \ update_node_blk; \
((void)slist); /* TODO */ \ return 0; \
((void)n); \ } \
return 0; \ return -1; \
} \ } \
\ \
/* -- skip_next_node_ */ \ /* -- skip_remove_ */ \
int prefix##skip_next_node_##decl(decl##_t *slist, decl##_node_t *n) \ int prefix##skip_remove_##decl(decl##_t *slist, decl##_node_t *n) \
{ \ { \
((void)slist); /* TODO */ \ size_t i, s; \
((void)n); \ decl##_node_t **path, *node; \
return 0; \ \
} \ if (!slist || !n) \
\ return -1; \
/* -- skip_prev_node_ */ \ if (slist->length == 0) \
int prefix##skip_prev_node_##decl(decl##_t *slist, decl##_node_t *n) \ return 0; \
{ \ \
((void)slist); /* TODO */ \ path = prefix##skip_locate_##decl(slist, n); \
((void)n); \ s = ARRAY_LENGTH(path); \
return 0; \ node = path[0]; \
} \ if (s > 0) { \
\ node->field.sle_next[0]->field.sle_prev = node->field.sle_prev; \
/* -- __skip_integrity_check_ */ \ for (i = 1; i < s; i++) { \
static int __skip_integrity_check_##decl(decl##_t *slist) \ if (path[i]->field.sle_next[i - 1] != node) \
{ \ break; \
((void)slist); /* TODO */ \ path[i]->field.sle_next[i - 1] = node->field.sle_next[i - 1]; \
return 0; \ if (path[i]->field.sle_next[i - 1] == slist->slh_tail) { \
size_t h = ARRAY_LENGTH(path[i]->field.sle_next); \
ARRAY_SET_LENGTH(path[i]->field.sle_next, h - 1); \
} \
} \
ARRAY_FREE(path); \
free_node_blk; \
/* Find all levels in the first element in the list that point \
at the tail and shrink the level*/ \
while (slist->level > 0 && \
slist->slh_head->field.sle_next[slist->level] == slist->slh_tail) { \
slist->level--; \
} \
slist->length--; \
} \
return 0; \
} \
\
/* -- skip_find_ */ \
int prefix##skip_find_##decl(decl##_t *slist, decl##_node_t *n) \
{ \
((void)slist); /* TODO */ \
((void)n); \
return 0; \
} \
\
/* -- skip_find_gte */ \
int prefix##skip_find_gte_##decl(decl##_t *slist, decl##_node_t *n) \
{ \
((void)slist); /* TODO */ \
((void)n); \
return 0; \
} \
\
/* -- skip_find_lte */ \
int prefix##skip_find_lte_##decl(decl##_t *slist, decl##_node_t *n) \
{ \
((void)slist); /* TODO */ \
((void)n); \
return 0; \
} \
\
/* -- skip_next_node_ */ \
int prefix##skip_next_node_##decl(decl##_t *slist, decl##_node_t *n) \
{ \
((void)slist); /* TODO */ \
((void)n); \
return 0; \
} \
\
/* -- skip_prev_node_ */ \
int prefix##skip_prev_node_##decl(decl##_t *slist, decl##_node_t *n) \
{ \
((void)slist); /* TODO */ \
((void)n); \
return 0; \
} \
\
/* -- skip_destroy_ */ \
int prefix##skip_destroy_##decl(decl##_t *slist, decl##_node_t *n) \
{ \
((void)slist); /* TODO */ \
((void)n); \
return 0; \
} \
\
/* -- __skip_integrity_check_ */ \
static int __skip_integrity_check_##decl(decl##_t *slist) \
{ \
((void)slist); /* TODO */ \
return 0; \
} }
#define SKIPLIST_GETTER(decl, prefix, name, ktype, vtype, qblk, rblk) \ #define SKIPLIST_GETTER(decl, prefix, name, ktype, vtype, qblk, rblk) \
vtype prefix##skip_##name##_##decl(decl##_t *slist, ktype key) \ vtype prefix##skip_##name##_##decl(decl##_t *slist, ktype key) \
{ \ { \
decl##_node_t *node, query; \ decl##_node_t **path, *node, query; \
\
qblk; \ qblk; \
node = prefix##skip_locate_##decl(slist, &query); \ path = prefix##skip_locate_##decl(slist, &query); \
rblk; \ if (ARRAY_SIZE(path) > 0) { \
node = path[0]; \
ARRAY_FREE(path); \
rblk; \
} \
return (vtype)0; \
} }
#define SKIPLIST_DECL_DOT(decl, prefix, field) \ #define SKIPLIST_DECL_DOT(decl, prefix, field) \