static void
set_init(void)
{
common_srand48((long int)time(NULL));
if (ck_hs_init(&hs, CK_HS_MODE_OBJECT | CK_HS_MODE_SPMC, hs_hash, hs_compare, &my_allocator, 8, common_lrand48()) == false) {
perror("ck_hs_init");
exit(EXIT_FAILURE);
}
return;
}
static void
set_init(unsigned int size, unsigned int mode)
{
if (ck_hs_init(&hs, CK_HS_MODE_OBJECT | CK_HS_MODE_SPMC | mode, hs_hash, hs_compare,
&my_allocator, size, global_seed) == false) {
perror("ck_hs_init");
exit(EXIT_FAILURE);
}
return;
}
void mtev_hash_init_locks(mtev_hash_table *h, int size, mtev_hash_lock_mode_t lock_mode) {
mtev_rand_init();
if(size < 8) size = 8;
mtevAssert(ck_hs_init(&h->u.hs, CK_HS_MODE_OBJECT | CK_HS_MODE_SPMC, hs_hash, hs_compare, &my_allocator,
size, mtev_rand()));
mtevAssert(h->u.hs.hf != NULL);
h->u.locks.locks = calloc(1, sizeof(struct locks_container));
mtev_hash_set_lock_mode_funcs(h, lock_mode);
}
static void
run_test(unsigned int is, unsigned int ad)
{
ck_hs_t hs[16];
const size_t size = sizeof(hs) / sizeof(*hs);
size_t i, j;
const char *blob = "#blobs";
unsigned long h;
if (ck_hs_init(&hs[0], CK_HS_MODE_SPMC | CK_HS_MODE_OBJECT | ad, hs_hash, hs_compare, &my_allocator, is, 6602834) == false)
ck_error("ck_hs_init\n");
for (j = 0; j < size; j++) {
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_hs_get(&hs[j], h, test[i]) != NULL) {
continue;
}
if (ck_hs_put_unique(&hs[j], h, test[i]) == false)
ck_error("ERROR [%zu]: Failed to insert unique (%s)\n", j, test[i]);
if (ck_hs_remove(&hs[j], h, test[i]) == false)
ck_error("ERROR [%zu]: Failed to remove unique (%s)\n", j, test[i]);
break;
}
if (ck_hs_gc(&hs[j], 0, 0) == false)
ck_error("ERROR: Failed to GC empty set.\n");
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
ck_hs_put(&hs[j], h, test[i]);
if (ck_hs_put(&hs[j], h, test[i]) == true) {
ck_error("ERROR [%u] [1]: put must fail on collision (%s).\n", is, test[i]);
}
if (ck_hs_get(&hs[j], h, test[i]) == NULL) {
ck_error("ERROR [%u]: get must not fail after put\n", is);
}
}
/* Test grow semantics. */
ck_hs_grow(&hs[j], 128);
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_hs_put(&hs[j], h, test[i]) == true) {
ck_error("ERROR [%u] [2]: put must fail on collision.\n", is);
}
if (ck_hs_get(&hs[j], h, test[i]) == NULL) {
ck_error("ERROR [%u]: get must not fail\n", is);
}
}
h = blob[0];
if (ck_hs_get(&hs[j], h, blob) == NULL) {
if (j > 0)
ck_error("ERROR [%u]: Blob must always exist after first.\n", is);
if (ck_hs_put(&hs[j], h, blob) == false) {
ck_error("ERROR [%u]: A unique blob put failed.\n", is);
}
} else {
if (ck_hs_put(&hs[j], h, blob) == true) {
ck_error("ERROR [%u]: Duplicate blob put succeeded.\n", is);
}
}
/* Grow set and check get semantics. */
ck_hs_grow(&hs[j], 512);
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_hs_get(&hs[j], h, test[i]) == NULL) {
ck_error("ERROR [%u]: get must not fail\n", is);
}
}
/* Delete and check negative membership. */
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
void *r;
h = test[i][0];
if (ck_hs_get(&hs[j], h, test[i]) == NULL)
continue;
if (r = ck_hs_remove(&hs[j], h, test[i]), r == NULL) {
ck_error("ERROR [%u]: remove must not fail\n", is);
}
if (strcmp(r, test[i]) != 0) {
ck_error("ERROR [%u]: Removed incorrect node (%s != %s)\n", (char *)r, test[i], is);
}
}
/* Test replacement semantics. */
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
void *r;
bool d;
h = test[i][0];
d = ck_hs_get(&hs[j], h, test[i]) != NULL;
if (ck_hs_set(&hs[j], h, test[i], &r) == false) {
ck_error("ERROR [%u]: Failed to set\n", is);
}
/* Expected replacement. */
if (d == true && (r == NULL || strcmp(r, test[i]) != 0)) {
ck_error("ERROR [%u]: Incorrect previous value: %s != %s\n",
is, test[i], (char *)r);
}
/* Replacement should succeed. */
if (ck_hs_fas(&hs[j], h, test[i], &r) == false)
ck_error("ERROR [%u]: ck_hs_fas must succeed.\n", is);
if (strcmp(r, test[i]) != 0) {
ck_error("ERROR [%u]: Incorrect replaced value: %s != %s\n",
is, test[i], (char *)r);
}
if (ck_hs_fas(&hs[j], h, negative, &r) == true)
ck_error("ERROR [%u]: Replacement of negative should fail.\n", is);
if (ck_hs_set(&hs[j], h, test[i], &r) == false) {
ck_error("ERROR [%u]: Failed to set [1]\n", is);
}
if (strcmp(r, test[i]) != 0) {
ck_error("ERROR [%u]: Invalid &hs[j]: %s != %s\n", (char *)r, test[i], is);
}
}
if (j == size - 1)
break;
if (ck_hs_move(&hs[j + 1], &hs[j], hs_hash, hs_compare, &my_allocator) == false)
ck_error("Failed to move hash table");
if (j & 1) {
ck_hs_gc(&hs[j + 1], 0, 0);
} else {
ck_hs_gc(&hs[j + 1], 26, 26);
}
if (ck_hs_rebuild(&hs[j + 1]) == false)
ck_error("Failed to rebuild");
}
return;
}
