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

progress

Browse source
This commit is contained in:
Gregory Burd 2024-05-25 21:34:43 -04:00
parent c5529b6677
commit 1356b02303
5 changed files with 819 additions and 388 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitignore vendored
View file

@ -5,6 +5,9 @@ tests/test
examples/mls.c
examples/mls
examples/mls.o
examples/ex2_sl.c
examples/ex2_sl
examples/ex2_sl.o
/mxe
.cache
hints.txt

8
Makefile
View file

@ -14,7 +14,7 @@ TEST_FLAGS = -Itests/
TESTS = tests/test
TEST_OBJS = tests/test.o tests/munit.o
EXAMPLES = examples/ex1.c
EXAMPLES = examples/ex1 examples/ex2
.PHONY: all shared static clean test examples mls
@ -64,9 +64,15 @@ examples/%.o: examples/%.c
examples/mls.c: examples/ex1.c
$(CC) $(CFLAGS) -C -E examples/ex1.c | sed -e '1,7d' -e '/^# [0-9]* "/d' | clang-format > examples/mls.c
examples/ex2_sl.c: examples/ex2.c
$(CC) $(CFLAGS) -C -E examples/ex2.c | sed -e '1,7d' -e '/^# [0-9]* "/d' | clang-format > examples/ex2_sl.c
examples/mls: examples/mls.o $(STATIC_LIB)
$(CC) $^ -o $@ $(CFLAGS) $(TEST_FLAGS) -lm -pthread
examples/ex2_sl: examples/ex2_sl.o $(STATIC_LIB)
$(CC) $^ -o $@ $(CFLAGS) $(TEST_FLAGS) -lm -pthread
#dot:
# ./examples/mls
# dot -Tpdf /tmp/ex1.dot -o /tmp/ex1.pdf >/dev/null 2>&1

13
examples/ex1.c
View file

@ -18,7 +18,7 @@
// Local demo application OPTIONS:
// ---------------------------------------------------------------------------
#define TEST_ARRAY_SIZE 100
#define TEST_ARRAY_SIZE 10
#define VALIDATE
//define SNAPSHOTS
//define TODO_RESTORE_SNAPSHOTS
@ -74,7 +74,10 @@ SKIPLIST_DECL(
return 0;
},
/* free entry: node */
{ free(node->value); },
{
free(node->value);
node->value = NULL;
},
/* update entry: rc, node, value */
{
char *numeral = (char *)value;
@ -310,10 +313,8 @@ main()
if (list == NULL)
return ENOMEM;
/* We set the max height here to 12, it's negative so that
the PRNG is seeded with this value as a testing trick for
predictable random sequences. */
rc = api_skip_init_ex(list, -12);
rc = api_skip_init_ex(list);
list->slh_prng_state = 12;
if (rc)
return rc;
api_skip_snapshots_init_ex(list);

483
examples/ex2.c Normal file
View file

@ -0,0 +1,483 @@
#pragma GCC push_options
#pragma GCC optimize("O0")
// OPTIONS to set before including sl.h
// ---------------------------------------------------------------------------
#define DEBUG
#define SKIPLIST_DIAGNOSTIC
/* Setting SKIPLIST_MAX_HEIGHT will do two things:
* 1) limit our max height across all instances of this data structure.
* 2) remove a heap allocation on frequently used paths, insert/remove/etc.
* so, use it when you need it.
*/
#define SKIPLIST_MAX_HEIGHT 12
// Include our monolithic ADT, the Skiplist!
// ---------------------------------------------------------------------------
#include "../include/sl.h"
// Local demo application OPTIONS:
// ---------------------------------------------------------------------------
#define TEST_ARRAY_SIZE 10
#define VALIDATE
//define SNAPSHOTS
//define TODO_RESTORE_SNAPSHOTS
#define STABLE_SEED
#define DOT
#ifdef DOT
size_t gen = 0;
FILE *of = 0;
#endif
// ---------------------------------------------------------------------------
#ifdef VALIDATE
#define CHECK __skip_integrity_check_ex(list, 0)
#else
#define CHECK ((void)0)
#endif
/*
* SKIPLIST EXAMPLE:
*
* This example creates an "ex" Skiplist where keys are integers, values are
* strings containing the roman numeral for the key allocated on the heap.
*/
/*
* To start, you must create a type node that will contain the
* fields you'd like to maintain in your Skiplist. In this case
* we map int -> char [] on the heap, but what you put here is up
* to you. You don't even need a "key", just a way to compare one
* node against another, logic you'll provide in SKIP_DECL as a
* block below.
*/
struct ex_node {
int key;
char *value;
SKIPLIST_ENTRY(ex) entries;
};
/*
* Generate all the access functions for our type of Skiplist.
*/
SKIPLIST_DECL(
ex, api_, entries,
/* compare entries: list, a, b, aux */
{
(void)list;
(void)aux;
if (a->key < b->key)
return -1;
if (a->key > b->key)
return 1;
return 0;
},
/* free entry: node */
{
free(node->value);
node->value = NULL;
},
/* update entry: rc, node, value */
{
char *numeral = (char *)value;
if (node->value)
free(node->value);
node->value = numeral;
},
/* archive an entry: rc, src, dest */
{
dest->key = src->key;
char *nv = calloc(strlen(src->value) + 1, sizeof(char));
if (nv == NULL)
rc = ENOMEM;
else {
strncpy(nv, src->value, strlen(src->value));
dest->value = nv;
}
},
/* size in bytes of the content stored in an entry: bytes */
{ bytes = strlen(node->value) + 1; })
/*
* Skiplists are ordered, we need a way to compare entries.
* Let's create a function with four arguments:
* - a reference to the Skiplist, `slist`
* - the two nodes to compare, `a` and `b`
* - and `aux`, which you can use to pass into this function
* any additional information required to compare objects.
* `aux` is passed from the value in the Skiplist, you can
* modify that value at any time to suit your needs.
*
* Your function should result in a return statement:
* a < b : return -1
* a == b : return 0
* a > b : return 1
*
* This result provides the ordering within the Skiplist. Sometimes
* your function will not be used when comparing nodes. This will
* happen when `a` or `b` are references to the head or tail of the
* list or when `a == b`. In those cases the comparison function
* returns before using the code in your block, don't panic. :)
int
__ex_key_compare(ex_t *list, ex_node_t *a, ex_node_t *b, void *aux)
{
(void)list;
(void)aux;
if (a->key < b->key)
return -1;
if (a->key > b->key)
return 1;
return 0;
}
*/
/*
* Optional: Getters and Setters
* - get, put, dup(put), del, etc. functions
*
* It can be useful to have simple get/put-style API, but to
* do that you'll have to supply some blocks of code used to
* extract data from within your nodes.
*/
SKIPLIST_DECL_ACCESS(
ex, api_, key, int, value, char *,
/* query blk */ { query.key = key; },
/* return blk */ { return node->value; })
/*
* Optional: Snapshots
*
* Enable functions that enable returning to an earlier point in
* time when a snapshot was created.
*/
SKIPLIST_DECL_SNAPSHOTS(ex, api_, entries)
/*
* Optional: Archive to/from bytes
*
* Enable functions that can write/read the content of your Skiplist
* out/in to/from an array of bytes.
*/
// TODO SKIPLIST_DECL_ARCHIVE(ex, api_, entries)
/*
* Optional: As Hashtable
*
* Turn your Skiplist into a hash table.
*/
// TODO SKIPLIST_DECL_HASHTABLE(ex, api_, entries, snaps)
/*
* Optional: Check Skiplists at runtime
*
* Create a functions that validate the integrity of a Skiplist.
*/
SKIPLIST_DECL_VALIDATE(ex, api_, entries)
/* Optional: Visualize your Skiplist using DOT/Graphviz in PDF
*
* Create the functions used to annotate a visualization of a Skiplist.
*/
SKIPLIST_DECL_DOT(ex, api_, entries)
void
sprintf_ex_node(ex_node_t *node, char *buf)
{
sprintf(buf, "%d:%s", node->key, node->value);
}
// Function for this demo application.
// ---------------------------------------------------------------------------
int __xorshift32_state = 0;
// Xorshift algorithm for PRNG
uint32_t
xorshift32()
{
uint32_t x = __xorshift32_state;
if (x == 0)
x = 123456789;
x ^= x << 13;
x ^= x >> 17;
x ^= x << 5;
__xorshift32_state = x;
return x;
}
void
xorshift32_seed()
{
// Seed the PRNG
#ifdef STABLE_SEED
__xorshift32_state = 8675309;
#else
__xorshift32_state = (unsigned int)time(NULL) ^ getpid();
#endif
}
static char *
to_lower(char *str)
{
char *p = str;
for (; *p; ++p)
*p = (char)(*p >= 'A' && *p <= 'Z' ? *p | 0x60 : *p);
return str;
}
static char *
to_upper(char *str)
{
char *p = str;
for (; *p; ++p)
*p = (char)(*p >= 'a' && *p <= 'z' ? *p & ~0x20 : *p);
return str;
}
static char *
int_to_roman_numeral(int num)
{
int del[] = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 }; // Key value in Roman counting
char *sym[] = { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" }; // Symbols for key values
// The maximum length of the Roman numeral representation for the maximum signed 64-bit integer would be approximately 19 * 3 = 57 characters, assuming
// every digit is represented by its Roman numeral equivalent up to 3 repetitions. Therefore, 64 should be more than enough.
char *res = (char *)calloc(4096, sizeof(char));
int i = 0;
if (num < 0) {
res[0] = '-';
i++;
num = -num;
}
if (num == 0) {
res[0] = '0';
return res;
}
if (num > 10000) {
sprintf(res, "The person you were looking for is not here, their mailbox is full, good bye.");
return res;
}
while (num) { // while input number is not zero
while (num / del[i]) { // while a number contains the largest key value possible
strcat(res, sym[i]); // append the symbol for this key value to res string
num -= del[i]; // subtract the key value from number
}
i++; // proceed to the next key value
}
return res;
}
void
shuffle(int *array, size_t n)
{
if (n > 1) {
size_t i;
for (i = n - 1; i > 0; i--) {
size_t j = (unsigned int)(xorshift32() % (i + 1)); /* NOLINT(*-msc50-cpp) */
int t = array[j];
array[j] = array[i];
array[i] = t;
}
}
}
#ifdef TODO_RESTORE_SNAPSHOTS
typedef struct {
size_t length;
size_t key;
size_t snap_id;
} snap_info_t;
#endif
// ---------------------------------------------------------------------------
int
main()
{
int rc;
#ifdef TODO_RESTORE_SNAPSHOTS
size_t n_snaps = 0;
snap_info_t snaps[TEST_ARRAY_SIZE * 2 + 1];
#endif
xorshift32_seed();
#ifdef DOT
of = fopen("/tmp/ex1.dot", "w");
if (!of) {
perror("Failed to open file /tmp/ex1.dot");
return 1;
}
#endif
/* Allocate and initialize a Skiplist. */
ex_t *list = (ex_t *)malloc(sizeof(ex_t));
if (list == NULL)
return ENOMEM;
rc = api_skip_init_ex(list);
list->slh_prng_state = 12;
if (rc)
return rc;
api_skip_snapshots_init_ex(list);
#ifdef DOT
api_skip_dot_ex(of, list, gen++, "init", sprintf_ex_node);
#endif
if (api_skip_get_ex(list, 0) != NULL)
perror("found a non-existent item!");
api_skip_del_ex(list, 0);
CHECK;
/* Insert TEST_ARRAY_SIZE key/value pairs into the list. */
int i, j;
char *numeral;
#ifdef DOT
char msg[1024];
memset(msg, 0, 1024);
#endif
int amt = TEST_ARRAY_SIZE, asz = (amt * 2) + 1;
int array[(TEST_ARRAY_SIZE * 2) + 1];
for (j = 0, i = -amt; i <= amt; i++, j++)
array[j] = i;
shuffle(array, asz);
for (i = 0; i < asz; i++) {
#ifdef SNAPSHOTS
api_skip_snapshot_ex(list);
#elif defined(TODO_RESTORE_SNAPSHOTS)
/* Snapshot the first iteration, and then every 5th after that. */
if (i % 5 == 0) {
snaps[i].length = api_skip_length_ex(list);
snaps[i].key = array[i];
snaps[i].snap_id = api_skip_snapshot_ex(list);
n_snaps++;
CHECK;
}
#endif
numeral = to_lower(int_to_roman_numeral(array[i]));
rc = api_skip_put_ex(list, array[i], numeral);
CHECK;
#ifdef DOT
sprintf(msg, "put key: %d value: %s", i, numeral);
api_skip_dot_ex(of, list, gen++, msg, sprintf_ex_node);
#endif
char *v = api_skip_get_ex(list, array[i]);
CHECK;
char *upper_numeral = calloc(1, strlen(v) + 1);
strncpy(upper_numeral, v, strlen(v));
assert(strncmp(v, upper_numeral, strlen(upper_numeral)) == 0);
to_upper(upper_numeral);
api_skip_set_ex(list, array[i], upper_numeral);
CHECK;
}
numeral = int_to_roman_numeral(-1);
api_skip_dup_ex(list, -1, numeral);
CHECK;
#ifdef DOT
sprintf(msg, "put dup key: %d value: %s", i, numeral);
api_skip_dot_ex(of, list, gen++, msg, sprintf_ex_node);
#endif
numeral = int_to_roman_numeral(1);
api_skip_dup_ex(list, 1, numeral);
CHECK;
#ifdef DOT
sprintf(msg, "put dup key: %d value: %s", i, numeral);
api_skip_dot_ex(of, list, gen++, msg, sprintf_ex_node);
#endif
api_skip_del_ex(list, 0);
CHECK;
if (api_skip_get_ex(list, 0) != NULL)
perror("found a deleted item!");
api_skip_del_ex(list, 0);
CHECK;
if (api_skip_get_ex(list, 0) != NULL)
perror("found a deleted item!");
int key = TEST_ARRAY_SIZE + 1;
api_skip_del_ex(list, key);
CHECK;
key = -(TEST_ARRAY_SIZE)-1;
api_skip_del_ex(list, key);
CHECK;
#ifdef DOT
sprintf(msg, "deleted key: %d, value: %s", 0, numeral);
api_skip_dot_ex(of, list, gen++, msg, sprintf_ex_node);
#endif
numeral = int_to_roman_numeral(-(TEST_ARRAY_SIZE));
assert(strcmp(api_skip_pos_ex(list, SKIP_GTE, -(TEST_ARRAY_SIZE)-1)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(-2);
assert(strcmp(api_skip_pos_ex(list, SKIP_GTE, -2)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(1);
assert(strcmp(api_skip_pos_ex(list, SKIP_GTE, 0)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(2);
assert(strcmp(api_skip_pos_ex(list, SKIP_GTE, 2)->value, numeral) == 0);
free(numeral);
assert(api_skip_pos_ex(list, SKIP_GTE, (TEST_ARRAY_SIZE + 1)) == NULL);
numeral = int_to_roman_numeral(-(TEST_ARRAY_SIZE));
assert(strcmp(api_skip_pos_ex(list, SKIP_GT, -(TEST_ARRAY_SIZE)-1)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(-1);
assert(strcmp(api_skip_pos_ex(list, SKIP_GT, -2)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(1);
assert(strcmp(api_skip_pos_ex(list, SKIP_GT, 0)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(2);
assert(strcmp(api_skip_pos_ex(list, SKIP_GT, 1)->value, numeral) == 0);
free(numeral);
assert(api_skip_pos_ex(list, SKIP_GT, TEST_ARRAY_SIZE) == NULL);
assert(api_skip_pos_ex(list, SKIP_LT, -(TEST_ARRAY_SIZE)) == NULL);
numeral = int_to_roman_numeral(-2);
assert(strcmp(api_skip_pos_ex(list, SKIP_LT, -1)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(-1);
assert(strcmp(api_skip_pos_ex(list, SKIP_LT, 0)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(1);
assert(strcmp(api_skip_pos_ex(list, SKIP_LT, 2)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(TEST_ARRAY_SIZE);
assert(strcmp(api_skip_pos_ex(list, SKIP_LT, (TEST_ARRAY_SIZE + 1))->value, numeral) == 0);
free(numeral);
assert(api_skip_pos_ex(list, SKIP_LTE, -(TEST_ARRAY_SIZE)-1) == NULL);
numeral = int_to_roman_numeral(-2);
assert(strcmp(api_skip_pos_ex(list, SKIP_LTE, -2)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(-1);
assert(strcmp(api_skip_pos_ex(list, SKIP_LTE, 0)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(2);
assert(strcmp(api_skip_pos_ex(list, SKIP_LTE, 2)->value, numeral) == 0);
free(numeral);
numeral = int_to_roman_numeral(TEST_ARRAY_SIZE);
assert(strcmp(api_skip_pos_ex(list, SKIP_LTE, (TEST_ARRAY_SIZE + 1))->value, numeral) == 0);
free(numeral);
#ifdef TODO_RESTORE_SNAPSHOTS
// Walk backward by 2 and test snapshot restore.
for (i = n_snaps; i > 0; i -= 2) {
api_skip_restore_snapshot_ex(list, snaps[i].snap_id);
CHECK;
assert(api_skip_length_ex(list) == snaps[i].length);
numeral = int_to_roman_numeral(snaps[i].key);
assert(strncmp(api_skip_get_ex(list, snaps[i].key), numeral, strlen(numeral)) == 0);
free(numeral);
}
api_skip_release_snapshots_ex(list);
#endif
#ifdef DOT
api_skip_dot_end_ex(of, gen);
fclose(of);
#endif
api_skip_free_ex(list);
free(list);
return rc;
}
#pragma GCC pop_options

700
include/sl.h
View file

@ -62,12 +62,11 @@
* It is a probabilistic datastructure, meaning that it does not guarantee
* O(log(n)), but it has been shown to approximate it over time. This
* implementation includes the rebalancing techniques that improve on that
* approximation using an adaptive technique called "splay-list" (named after
* the splay-tree due to the similarities between the two). It is similar to a
* standard skip-list, with the key distinction that the height of each element
* adapts dynamically to its access rate: popular elements increase in height,
* whereas rarely-accessed elements decrease in height. See below for the link
* to the research behind this adaptive technique.
* approximation using an adaptive technique called "splay-list". It is similar
* to a standard skip-list, with the key distinction that the height of each
* element adapts dynamically to its access rate: popular elements increase in
* height, whereas rarely-accessed elements decrease in height. See below for
* the link to the research behind this adaptive technique.
*
* Conceptually, at a high level, a skip-list is arranged as follows:
*
@ -202,7 +201,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
*/
#ifndef SKIPLIST_MAX_HEIGHT
#define SKIPLIST_MAX_HEIGHT 1
#define SKIPLIST_MAX_HEIGHT 64
#endif
/*
@ -232,17 +231,17 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
for (iter = (list)->slh_length, (elm) = (list)->slh_tail; ((elm) = (elm)->field.sle_prev) != (list)->slh_head; iter--)
/* Iterate over the next pointers in a node from bottom to top (B2T) or top to bottom (T2B). */
#define __SKIP_ALL_ENTRIES_T2B(field, elm) for (size_t lvl = slist->slh_max_height; lvl != (size_t)-1; lvl--)
#define __SKIP_ALL_ENTRIES_T2B(field, elm) for (size_t lvl = slist->slh_head->entries.sle_height - 1; lvl != (size_t)-1; lvl--)
#define __SKIP_ENTRIES_T2B(field, elm) for (size_t lvl = elm->field.sle_height; lvl != (size_t)-1; lvl--)
#define __SKIP_ENTRIES_T2B_FROM(field, elm, off) for (size_t lvl = off; lvl != (size_t)-1; lvl--)
#define __SKIP_IS_LAST_ENTRY_T2B() if (lvl == 0)
#define __SKIP_ALL_ENTRIES_B2T(field, elm) for (size_t lvl = 0; lvl < slist->slh_max_height; lvl++)
#define __SKIP_ALL_ENTRIES_B2T(field, elm) for (size_t lvl = 0; lvl < slist->slh_head->entries.sle_height - 1; lvl++)
#define __SKIP_ENTRIES_B2T(field, elm) for (size_t lvl = 0; lvl <= elm->field.sle_height; lvl++)
#define __SKIP_ENTRIES_B2T_FROM(field, elm, off) for (size_t lvl = off; lvl <= elm->field.sle_height; lvl++)
#define __SKIP_IS_LAST_ENTRY_B2T() if (lvl + 1 == elm->field.sle_height)
/* Iterate over the subtree to the left (v, or 'lt') and right (u) or "CHu" and "CHv". */
/* Iterate over the subtree to the left (v, or 'lt') and right (u, or 'gt') or "CHu" and "CHv". */
#define __SKIP_SUBTREE_CHv(decl, field, list, path, nth) \
for (decl##_node_t *elm = path[nth].node; elm->field.sle_levels[path[nth].in].next == path[nth].node; elm = elm->field.sle_prev)
#define __SKIP_SUBTREE_CHu(decl, field, list, path, nth) \
@ -264,7 +263,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
\
/* Skiplist structure */ \
struct decl { \
size_t slh_length, slh_max_height; \
size_t slh_length; \
void *slh_aux; \
int slh_prng_state; \
decl##_node_t *slh_head; \
@ -414,12 +413,12 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
* \
* Allocates a new node on the heap and sets default values. \
*/ \
int prefix##skip_alloc_node_##decl(decl##_t *slist, decl##_node_t **node) \
int prefix##skip_alloc_node_##decl(decl##_node_t **node) \
{ \
decl##_node_t *n; \
/* Calculate the size of the struct sle within decl##_node_t, multiply \
by array size. (16/24 bytes on 32/64 bit systems) */ \
size_t sle_arr_sz = sizeof(struct __skiplist_##decl##_level) * slist->slh_max_height; \
size_t sle_arr_sz = sizeof(struct __skiplist_##decl##_level) * SKIPLIST_MAX_HEIGHT; \
n = (decl##_node_t *)calloc(1, sizeof(decl##_node_t) + sle_arr_sz); \
if (n == NULL) \
return ENOMEM; \
@ -432,16 +431,15 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
/** \
* -- skip_init_ \
* \
* Initializes a Skiplist to the deafault values, this must be called \
* before using the list. \
* Initializes a Skiplist to the default values, this must be \
* called before using the list. \
*/ \
int prefix##skip_init_##decl(decl##_t *slist, int max) \
int prefix##skip_init_##decl(decl##_t *slist) \
{ \
int rc = 0; \
size_t i; \
\
slist->slh_length = 0; \
slist->slh_max_height = SKIPLIST_MAX_HEIGHT == 1 ? (size_t)(max < 0 ? -max : max) : SKIPLIST_MAX_HEIGHT; \
slist->slh_snap.cur_era = 0; \
slist->slh_snap.pres_era = 0; \
slist->slh_snap.pres = 0; \
@ -450,32 +448,25 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
slist->slh_fns.archive_entry = __skip_archive_entry_fn_##decl; \
slist->slh_fns.sizeof_entry = __skip_sizeof_entry_fn_##decl; \
slist->slh_fns.compare_entries = __skip_compare_entries_fn_##decl; \
rc = prefix##skip_alloc_node_##decl(slist, &slist->slh_head); \
rc = prefix##skip_alloc_node_##decl(&slist->slh_head); \
if (rc) \
goto fail; \
rc = prefix##skip_alloc_node_##decl(slist, &slist->slh_tail); \
rc = prefix##skip_alloc_node_##decl(&slist->slh_tail); \
if (rc) \
goto fail; \
\
/* Initial height is 0 (meaning 1 level), all next point to tail */ \
slist->slh_head->field.sle_height = 0; \
for (i = 0; i < slist->slh_max_height; i++) \
/* Initial height at head is 0 (meaning 0 sub-lists), all next point to tail */ \
slist->slh_head->field.sle_height = 1; \
for (i = 0; i < slist->slh_head->entries.sle_height + 1; i++) \
slist->slh_head->field.sle_levels[i].next = slist->slh_tail; \
slist->slh_head->field.sle_prev = NULL; \
\
/* Initial height is 0 (meaning 1 level), all next point to tail */ \
/* Initial height at tail is also 0 and all next point to tail */ \
slist->slh_tail->field.sle_height = slist->slh_head->field.sle_height; \
for (i = 0; i < slist->slh_max_height; i++) \
for (i = 0; i < slist->slh_head->entries.sle_height + 1; i++) \
slist->slh_tail->field.sle_levels[i].next = NULL; \
slist->slh_tail->field.sle_prev = slist->slh_head; \
\
/* NOTE: Here's a testing aid, simply set `max` to a negative number to \
* seed the PRNG in a predictable way and have reproducible random numbers. \
*/ \
if (max < 0) \
slist->slh_prng_state = -max; \
else \
slist->slh_prng_state = ((unsigned int)time(NULL) ^ getpid()); \
slist->slh_prng_state = ((unsigned int)time(NULL) ^ getpid()); \
fail:; \
return rc; \
} \
@ -533,6 +524,8 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
*/ \
decl##_node_t *prefix##skip_tail_##decl(decl##_t *slist) \
{ \
if (slist == NULL) \
return NULL; \
return slist->slh_tail->field.sle_prev == slist->slh_head->field.sle_levels[0].next ? NULL : slist->slh_tail->field.sle_prev; \
} \
\
@ -640,13 +633,13 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
static void __skip_rebalance_##decl(decl##_t *slist, size_t len, __skiplist_path_##decl##_t path[]) \
{ \
size_t i, j, u_hits, hits_CHu = 0, hits_CHv = 0, delta_height, new_height, cur_hits, prev_hits; \
double k_threshold, m_total_hits, asc_cond, dsc_cond; \
size_t k_threshold, m_total_hits; \
double asc_cond, dsc_cond; \
\
/* return; TODO/WIP */ \
/* Total hits, `k`, accross all nodes. */ \
/* Total hits, `k`, across all nodes. */ \
m_total_hits = slist->slh_head->field.sle_levels[slist->slh_head->field.sle_height].hits; \
\
/* Height of the head node, should be close to floor(log(max_height)). */ \
/* Height of the head node, should be close to floor(log(m_total_hits)). */ \
k_threshold = slist->slh_head->field.sle_height + 1; \
\
/* Moving backwards along the path... \
@ -655,7 +648,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
* - path[len] is where the locate() terminated, just before path[0] \
* if there was a match \
*/ \
for (i = 1; i < len; i++) { \
for (i = 1; i <= len; i++) { \
if (path[i].node == slist->slh_head || path[i].node == slist->slh_tail) \
continue; \
\
@ -707,7 +700,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
*/ \
/* 1) check ascent condition */ \
asc_cond = m_total_hits / pow(2.0, delta_height == 0 ? 0 : delta_height - 1); \
if (path[i - 1].pu > asc_cond && path[i].node->field.sle_height < slist->slh_max_height - 1) { \
if (path[i - 1].pu > asc_cond && path[i].node->field.sle_height < SKIPLIST_MAX_HEIGHT) { \
/* 2) increase height by one */ \
new_height = path[i].node->field.sle_height++; \
/* 3) update hit counter */ \
@ -726,19 +719,21 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
* Locates a node that matches another node updating `path` and then \
* returning the length of that path + 1 to the node and the matching \
* node in path[0], or NULL at path[0] where there wasn't a match. \
* sizeof(path) should be `slist->slh_max_height + 1` \
* sizeof(path) should be `slist->slh_head->entries.sle_height + 1` \
*/ \
static size_t __skip_locate_##decl(decl##_t *slist, decl##_node_t *n, __skiplist_path_##decl##_t path[]) \
{ \
unsigned int i; \
size_t len = 0; \
decl##_node_t *elm = slist->slh_head; \
decl##_node_t *elm; \
\
if (slist == NULL || n == NULL) \
return 0; \
\
elm = slist->slh_head; \
\
/* Find the node that matches `node` or NULL. */ \
i = slist->slh_head->field.sle_height; \
i = slist->slh_head->field.sle_height - 1; \
do { \
path[i + 1].pu = 0; \
while (elm != slist->slh_tail && elm->field.sle_levels[i].next && \
@ -755,6 +750,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
if (__skip_compare_nodes_##decl(slist, elm, n, slist->slh_aux) == 0) { \
path[0].node = elm; \
path[0].node->field.sle_levels[0].hits++; \
slist->slh_head->entries.sle_levels[slist->slh_head->entries.sle_height].hits++; \
__skip_rebalance_##decl(slist, len, path); \
} \
return len; \
@ -778,17 +774,13 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
if (slist == NULL || new == NULL) \
return ENOENT; \
\
/* Allocate a buffer, or use a static one. */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
return ENOMEM; \
} \
/* First element in path should be NULL, reset should start pointing at tail. */ \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
/* First element in path should be NULL, rest should start pointing at tail. */ \
path[0].node = NULL; \
path[0].in = 0; \
path[0].pu = 0; \
for (i = 1; i < slist->slh_max_height + 1; i++) { \
for (i = 1; i < slist->slh_head->entries.sle_height + 1; i++) { \
path[i].node = slist->slh_tail; \
path[i].in = 0; \
path[i].pu = 0; \
@ -802,9 +794,9 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
/* Don't insert, duplicate if flag not set. */ \
return -1; \
} \
/* Coin toss to determine level of this new node [0, max) */ \
cur_height = slist->slh_head->field.sle_height; \
new_height = __skip_toss_##decl(slist, slist->slh_max_height - 1); \
/* Coin toss to determine level of this new node [0, current max height) */ \
cur_height = slist->slh_head->field.sle_height - 1; \
new_height = __skip_toss_##decl(slist, cur_height); \
new->field.sle_height = new_height; \
/* Trim the path to at most the new height for the new node. */ \
for (i = cur_height + 1; i <= new_height; i++) { \
@ -835,23 +827,18 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
slist->slh_head->field.sle_levels[lvl].next = slist->slh_tail; \
} \
} \
/* Adujust the previous pointers in the nodes. */ \
/* Adjust the previous pointers in the nodes. */ \
new->field.sle_prev = path[1].node; \
new->field.sle_levels[0].next->field.sle_prev = new; \
/* Account for insert at tail. */ \
if (new->field.sle_levels[0].next == slist->slh_tail) \
slist->slh_tail->field.sle_prev = new; \
/* Adjust the head/tail boundary node heights if necessary. */ \
if (new_height > cur_height) { \
slist->slh_head->field.sle_height = new_height; \
slist->slh_tail->field.sle_height = new_height; \
} \
/* Record the era for this node to enable snapshots. */ \
if (slist->slh_snap.pres_era > 0) { \
/* Increase the the list's era/age and record it. */ \
/* Increase the list's era/age and record it. */ \
new->field.sle_era = slist->slh_snap.cur_era++; \
} \
/* Set hits for rebalencing to 1 when new born. */ \
/* Set hits for re-balancing to 1 when newborn. */ \
new->field.sle_levels[new_height].hits = 1; \
/* Increase our list length (aka. size, count, etc.) by one. */ \
slist->slh_length++; \
@ -895,18 +882,11 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
decl##_node_t *node = NULL; \
__skiplist_path_##decl##_t *path = apath; \
\
/* Allocate a buffer, or use a static one. */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
goto done; \
} \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
/* Find a `path` to `new` in the list and a match (`path[0]`) if it exists. */ \
__skip_locate_##decl(slist, query, path); \
node = path[0].node; \
done:; \
if (SKIPLIST_MAX_HEIGHT == 1) \
free(path); \
\
@ -927,13 +907,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
decl##_node_t *node; \
__skiplist_path_##decl##_t *path = apath; \
\
/* Allocate a buffer, or use a static one. */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
goto done; \
} \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
/* Find a `path` to `new` in the list and a match (`path[0]`) if it exists. */ \
__skip_locate_##decl(slist, query, path); \
@ -942,8 +916,6 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
node = node->field.sle_levels[0].next; \
cmp = __skip_compare_nodes_##decl(slist, node, query, slist->slh_aux); \
} while (cmp < 0); \
\
done:; \
if (SKIPLIST_MAX_HEIGHT == 1) \
free(path); \
\
@ -964,13 +936,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
decl##_node_t *node; \
__skiplist_path_##decl##_t *path = apath; \
\
/* Allocate a buffer, or use a static one. */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
goto done; \
} \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
/* Find a `path` to `new` in the list and a match (`path[0]`) if it exists. */ \
__skip_locate_##decl(slist, query, path); \
@ -981,7 +947,6 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
node = node->field.sle_levels[0].next; \
cmp = __skip_compare_nodes_##decl(slist, node, query, slist->slh_aux); \
} while (cmp <= 0 && node != slist->slh_tail); \
\
done:; \
if (SKIPLIST_MAX_HEIGHT == 1) \
free(path); \
@ -1002,13 +967,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
decl##_node_t *node; \
__skiplist_path_##decl##_t *path = apath; \
\
/* Allocate a buffer, or use a static one. */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
goto done; \
} \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
/* Find a `path` to `new` in the list and a match (`path[0]`) if it exists. */ \
__skip_locate_##decl(slist, query, path); \
@ -1016,7 +975,6 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
if (node) \
goto done; \
node = path[1].node; \
\
done:; \
if (SKIPLIST_MAX_HEIGHT == 1) \
free(path); \
@ -1036,19 +994,11 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
decl##_node_t *node; \
__skiplist_path_##decl##_t *path = apath; \
\
/* Allocate a buffer, or use a static one. */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
goto done; \
} \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
/* Find a `path` to `new` in the list and a match (`path[0]`) if it exists. */ \
__skip_locate_##decl(slist, query, path); \
node = path[1].node; \
\
done:; \
if (SKIPLIST_MAX_HEIGHT == 1) \
free(path); \
\
@ -1104,13 +1054,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
if (slist == NULL) \
return -1; \
\
/* Allocate a buffer, or use a static one. */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
return ENOMEM; \
} \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
__skip_locate_##decl(slist, query, path); \
node = path[0].node; \
@ -1157,13 +1101,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
if (slist->slh_length == 0) \
return 0; \
\
/* Allocate a buffer */ \
if (SKIPLIST_MAX_HEIGHT == 1) { \
path = malloc(sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
if (path == NULL) \
return ENOMEM; \
} \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * slist->slh_max_height + 1); \
memset(path, 0, sizeof(__skiplist_path_##decl##_t) * SKIPLIST_MAX_HEIGHT + 1); \
\
/* Attempt to locate the node in the list. */ \
len = __skip_locate_##decl(slist, query, path); \
@ -1207,13 +1145,12 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
free(path); \
\
slist->slh_fns.free_entry(node); \
free(node); \
\
/* Reduce the height of the head node. */ \
i = 0; \
while (slist->slh_head->field.sle_levels[i].next != slist->slh_tail && i < slist->slh_head->field.sle_height) \
i++; \
slist->slh_head->field.sle_height = i; \
slist->slh_tail->field.sle_height = i; \
/* Reduce the height of the head/tail nodes. */ \
for (i = 0; slist->slh_head->field.sle_levels[i].next != slist->slh_tail && i < SKIPLIST_MAX_HEIGHT; i++) \
; \
slist->slh_head->field.sle_height = slist->slh_tail->field.sle_height = i; \
\
slist->slh_length--; \
__skip_adjust_hit_counts_##decl(slist); \
@ -1319,8 +1256,8 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
return 0; \
\
/* (a) alloc, ... */ \
size_t sle_arr_sz = sizeof(struct __skiplist_##decl##_level) * slist->slh_max_height; \
rc = prefix##skip_alloc_node_##decl(slist, &dest); \
size_t sle_arr_sz = sizeof(struct __skiplist_##decl##_level) * slist->slh_head->entries.sle_height - 1; \
rc = prefix##skip_alloc_node_##decl(&dest); \
if (rc) \
return rc; \
\
@ -1482,261 +1419,262 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
} \
}
#define SKIPLIST_DECL_VALIDATE(decl, prefix, field) \
/** \
* -- __skip_integrity_failure_ \
*/ \
static void __attribute__((format(printf, 1, 2))) __skip_integrity_failure_##decl(const char *format, ...) \
{ \
va_list args; \
va_start(args, format); \
vfprintf(stderr, format, args); \
va_end(args); \
} \
\
/** \
* -- __skip_integrity_check_ \
*/ \
static int __skip_integrity_check_##decl(decl##_t *slist, int flags) \
{ \
size_t n = 0; \
unsigned long nth, n_err = 0; \
decl##_node_t *node, *prev, *next; \
struct __skiplist_##decl##_entry *this; \
\
if (slist == NULL) { \
__skip_integrity_failure_##decl("slist was NULL, nothing to check\n"); \
n_err++; \
return n_err; \
} \
\
/* Check the Skiplist header (slh) */ \
\
if (slist->slh_head == NULL) { \
__skip_integrity_failure_##decl("skiplist slh_head is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_tail == NULL) { \
__skip_integrity_failure_##decl("skiplist slh_tail is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.free_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist free_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.update_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist update_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.archive_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist archive_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.sizeof_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist sizeof_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.compare_entries == NULL) { \
__skip_integrity_failure_##decl("skiplist compare_entries fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_max_height < 1) { \
__skip_integrity_failure_##decl("skiplist max level must be 1 at minimum\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (slist->slh_head->field.sle_height >= slist->slh_max_height) { \
/* level is 0-based, max of 12 means level cannot be > 11 */ \
__skip_integrity_failure_##decl("skiplist level %lu in header was >= max %lu\n", slist->slh_head->field.sle_height, slist->slh_max_height); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (SKIPLIST_MAX_HEIGHT < 1) { \
__skip_integrity_failure_##decl("SKIPLIST_MAX_HEIGHT cannot be less than 1\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (SKIPLIST_MAX_HEIGHT > 1 && slist->slh_max_height > SKIPLIST_MAX_HEIGHT) { \
__skip_integrity_failure_##decl("slist->slh_max_height %lu cannot be greater than SKIPLIST_MAX_HEIGHT %lu\n", slist->slh_max_height, \
(size_t)SKIPLIST_MAX_HEIGHT); \
n_err++; \
if (flags) \
return n_err; \
} \
\
node = slist->slh_head; \
__SKIP_ENTRIES_B2T(field, node) \
{ \
if (node->field.sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("the head's %lu next node should not be NULL\n", lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
n = lvl; \
if (node->field.sle_levels[lvl].next == slist->slh_tail) \
break; \
} \
n++; \
__SKIP_ENTRIES_B2T_FROM(field, node, n) \
{ \
if (node->field.sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("the head's %lu next node should not be NULL\n", lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
/* TODO: really? \
if (node->field.sle_levels[lvl].next != slist->slh_tail) { \
__skip_integrity_failure_##decl("after internal nodes, the head's %lu next node should always be the tail\n", lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
*/ \
} \
\
if (slist->slh_length > 0 && slist->slh_tail->field.sle_prev == slist->slh_head) { \
__skip_integrity_failure_##decl("slist->slh_length is 0, but tail->prev == head, not an internal node\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
/* Validate the head node */ \
\
/* Validate the tail node */ \
\
/* Validate each node */ \
SKIPLIST_FOREACH_H2T(decl, prefix, field, slist, node, nth) \
{ \
this = &node->field; \
\
if (this->sle_height >= slist->slh_max_height) { \
__skip_integrity_failure_##decl("the %lu node's [%p] height %lu is >= max %lu\n", nth, (void *)node, this->sle_height, slist->slh_max_height); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (this->sle_levels == NULL) { \
__skip_integrity_failure_##decl("the %lu node's [%p] next field should never be NULL\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (this->sle_prev == NULL) { \
__skip_integrity_failure_##decl("the %lu node [%p] prev field should never be NULL\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
__SKIP_ENTRIES_B2T(field, node) \
{ \
if (this->sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("the %lu node's next[%lu] should not be NULL\n", nth, lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
n = lvl; \
if (this->sle_levels[lvl].next == slist->slh_tail) \
break; \
} \
n++; \
__SKIP_ENTRIES_B2T_FROM(field, node, n) \
{ \
if (this->sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("after the %lunth the %lu node's next[%lu] should not be NULL\n", n, nth, lvl); \
n_err++; \
if (flags) \
return n_err; \
} else if (this->sle_levels[lvl].next != slist->slh_tail) { \
__skip_integrity_failure_##decl("after the %lunth the %lu node's next[%lu] should point to the tail\n", n, nth, lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
} \
\
decl##_node_t *a = (decl##_node_t *)(uintptr_t)this->sle_levels; \
decl##_node_t *b = (decl##_node_t *)(intptr_t)((uintptr_t)node + sizeof(decl##_node_t)); \
if (a != b) { \
__skip_integrity_failure_##decl("the %lu node's [%p] next field isn't at the proper offset relative to the node\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
next = this->sle_levels[0].next; \
prev = this->sle_prev; \
if (__skip_compare_nodes_##decl(slist, node, node, slist->slh_aux) != 0) { \
__skip_integrity_failure_##decl("the %lu node [%p] is not equal to itself\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, node, prev, slist->slh_aux) < 0) { \
__skip_integrity_failure_##decl("the %lu node [%p] is not greater than the prev node [%p]\n", nth, (void *)node, (void *)prev); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, node, next, slist->slh_aux) > 0) { \
__skip_integrity_failure_##decl("the %lu node [%p] is not less than the next node [%p]\n", nth, (void *)node, (void *)next); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, prev, node, slist->slh_aux) > 0) { \
__skip_integrity_failure_##decl("the prev node [%p] is not less than the %lu node [%p]\n", (void *)prev, nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, next, node, slist->slh_aux) < 0) { \
__skip_integrity_failure_##decl("the next node [%p] is not greater than the %lu node [%p]\n", (void *)next, nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
} \
\
if (slist->slh_length != nth) { \
__skip_integrity_failure_##decl("slist->slh_length (%lu) doesn't match the count (%lu) of nodes between the head and tail\n", slist->slh_length, \
nth); \
n_err++; \
if (flags) \
return n_err; \
} \
\
return 0; \
#define SKIPLIST_DECL_VALIDATE(decl, prefix, field) \
/** \
* -- __skip_integrity_failure_ \
*/ \
static void __attribute__((format(printf, 1, 2))) __skip_integrity_failure_##decl(const char *format, ...) \
{ \
va_list args; \
va_start(args, format); \
vfprintf(stderr, format, args); \
va_end(args); \
} \
\
/** \
* -- __skip_integrity_check_ \
*/ \
static int __skip_integrity_check_##decl(decl##_t *slist, int flags) \
{ \
size_t n = 0; \
unsigned long nth, n_err = 0; \
decl##_node_t *node, *prev, *next; \
struct __skiplist_##decl##_entry *this; \
\
if (slist == NULL) { \
__skip_integrity_failure_##decl("slist was NULL, nothing to check\n"); \
n_err++; \
return n_err; \
} \
\
/* Check the Skiplist header (slh) */ \
\
if (slist->slh_head == NULL) { \
__skip_integrity_failure_##decl("skiplist slh_head is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_tail == NULL) { \
__skip_integrity_failure_##decl("skiplist slh_tail is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.free_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist free_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.update_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist update_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.archive_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist archive_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.sizeof_entry == NULL) { \
__skip_integrity_failure_##decl("skiplist sizeof_entry fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_fns.compare_entries == NULL) { \
__skip_integrity_failure_##decl("skiplist compare_entries fn is NULL\n"); \
n_err++; \
return n_err; \
} \
\
if (slist->slh_head->entries.sle_height > SKIPLIST_MAX_HEIGHT) { \
__skip_integrity_failure_##decl("skiplist head height > SKIPLIST_MAX_HEIGHT\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (slist->slh_tail->entries.sle_height > SKIPLIST_MAX_HEIGHT) { \
__skip_integrity_failure_##decl("skiplist tail height > SKIPLIST_MAX_HEIGHT\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (slist->slh_head->entries.sle_height != slist->slh_tail->entries.sle_height) { \
__skip_integrity_failure_##decl("skiplist head & tail height are not equal\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
/* TODO: slh_head->entries.sle_height should == log(m) where m is the sum of all hits on all nodes */ \
\
if (SKIPLIST_MAX_HEIGHT < 1) { \
__skip_integrity_failure_##decl("SKIPLIST_MAX_HEIGHT cannot be less than 1\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
node = slist->slh_head; \
__SKIP_ENTRIES_B2T(field, node) \
{ \
if (node->field.sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("the head's %lu next node should not be NULL\n", lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
n = lvl; \
if (node->field.sle_levels[lvl].next == slist->slh_tail) \
break; \
} \
n++; \
__SKIP_ENTRIES_B2T_FROM(field, node, n) \
{ \
if (node->field.sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("the head's %lu next node should not be NULL\n", lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
/* TODO: really? \
if (node->field.sle_levels[lvl].next != slist->slh_tail) { \
__skip_integrity_failure_##decl("after internal nodes, the head's %lu next node should always be the tail\n", lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
*/ \
} \
\
if (slist->slh_length > 0 && slist->slh_tail->field.sle_prev == slist->slh_head) { \
__skip_integrity_failure_##decl("slist->slh_length is 0, but tail->prev == head, not an internal node\n"); \
n_err++; \
if (flags) \
return n_err; \
} \
\
/* Validate the head node */ \
\
/* Validate the tail node */ \
\
/* Validate each node */ \
SKIPLIST_FOREACH_H2T(decl, prefix, field, slist, node, nth) \
{ \
this = &node->field; \
\
if (this->sle_height > slist->slh_head->entries.sle_height) { \
__skip_integrity_failure_##decl("the %lu node's [%p] height %lu is > head %lu\n", nth, (void *)node, this->sle_height, \
slist->slh_head->entries.sle_height); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (this->sle_levels == NULL) { \
__skip_integrity_failure_##decl("the %lu node's [%p] next field should never be NULL\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (this->sle_prev == NULL) { \
__skip_integrity_failure_##decl("the %lu node [%p] prev field should never be NULL\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
__SKIP_ENTRIES_B2T(field, node) \
{ \
if (this->sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("the %lu node's next[%lu] should not be NULL\n", nth, lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
n = lvl; \
if (this->sle_levels[lvl].next == slist->slh_tail) \
break; \
} \
n++; \
__SKIP_ENTRIES_B2T_FROM(field, node, n) \
{ \
if (this->sle_levels[lvl].next == NULL) { \
__skip_integrity_failure_##decl("after the %lunth the %lu node's next[%lu] should not be NULL\n", n, nth, lvl); \
n_err++; \
if (flags) \
return n_err; \
} else if (this->sle_levels[lvl].next != slist->slh_tail) { \
__skip_integrity_failure_##decl("after the %lunth the %lu node's next[%lu] should point to the tail\n", n, nth, lvl); \
n_err++; \
if (flags) \
return n_err; \
} \
} \
\
decl##_node_t *a = (decl##_node_t *)(uintptr_t)this->sle_levels; \
decl##_node_t *b = (decl##_node_t *)(intptr_t)((uintptr_t)node + sizeof(decl##_node_t)); \
if (a != b) { \
__skip_integrity_failure_##decl("the %lu node's [%p] next field isn't at the proper offset relative to the node\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
next = this->sle_levels[0].next; \
prev = this->sle_prev; \
if (__skip_compare_nodes_##decl(slist, node, node, slist->slh_aux) != 0) { \
__skip_integrity_failure_##decl("the %lu node [%p] is not equal to itself\n", nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, node, prev, slist->slh_aux) < 0) { \
__skip_integrity_failure_##decl("the %lu node [%p] is not greater than the prev node [%p]\n", nth, (void *)node, (void *)prev); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, node, next, slist->slh_aux) > 0) { \
__skip_integrity_failure_##decl("the %lu node [%p] is not less than the next node [%p]\n", nth, (void *)node, (void *)next); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, prev, node, slist->slh_aux) > 0) { \
__skip_integrity_failure_##decl("the prev node [%p] is not less than the %lu node [%p]\n", (void *)prev, nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
\
if (__skip_compare_nodes_##decl(slist, next, node, slist->slh_aux) < 0) { \
__skip_integrity_failure_##decl("the next node [%p] is not greater than the %lu node [%p]\n", (void *)next, nth, (void *)node); \
n_err++; \
if (flags) \
return n_err; \
} \
} \
\
if (slist->slh_length != nth) { \
__skip_integrity_failure_##decl("slist->slh_length (%lu) doesn't match the count (%lu) of nodes between the head and tail\n", slist->slh_length, \
nth); \
n_err++; \
if (flags) \
return n_err; \
} \
\
return 0; \
}
#define SKIPLIST_DECL_ACCESS(decl, prefix, key, ktype, value, vtype, qblk, rblk) \
@ -1808,7 +1746,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
{ \
int rc; \
decl##_node_t *node; \
rc = prefix##skip_alloc_node_##decl(slist, &node); \
rc = prefix##skip_alloc_node_##decl(&node); \
if (rc) \
return rc; \
node->key = key; \
@ -1829,7 +1767,7 @@ void __attribute__((format(printf, 4, 5))) __skip_diag_(const char *file, int li
{ \
int rc; \
decl##_node_t *node; \
rc = prefix##skip_alloc_node_##decl(slist, &node); \
rc = prefix##skip_alloc_node_##decl(&node); \
if (rc) \
return rc; \
node->key = key; \