haiwan
/
ck
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

regressions: Add ck_error convenience function.

Browse Source 
Prints a message and then executes exit(EXIT_FAILURE).
ck_pring
Samy Al Bahra 13 years ago
parent 12da4128ff
commit 6bd946d019
49 changed files with 488 additions and 726 deletions
Show Stats Download Patch File Download Diff File

14
regressions/ck_backoff/validate/validate.c
Unescape View File

@ -37,23 +37,20 @@ main(void)
const ck_backoff_t ceiling = CK_BACKOFF_CEILING + 1;
unsigned int i = 0;
fprintf(stderr, "Ceiling is: %u (%#x)\n", CK_BACKOFF_CEILING, CK_BACKOFF_CEILING);
ck_error("Ceiling is: %u (%#x)\n", CK_BACKOFF_CEILING, CK_BACKOFF_CEILING);
for (;;) {
ck_backoff_t previous = backoff;
ck_backoff_gb(&backoff);
if (previous == ceiling) {
if (backoff != ceiling) {
fprintf(stderr, "[C] GB: expected %u, got %u\n", ceiling, backoff);
exit(EXIT_FAILURE);
}
if (backoff != ceiling)
ck_error("[C] GB: expected %u, got %u\n", ceiling, backoff);
if (i++ >= 1)
break;
} else if (previous != backoff >> 1) {
fprintf(stderr, "[N] GB: expected %u (%u), got %u\n", previous << 1, previous, backoff);
exit(EXIT_FAILURE);
ck_error("[N] GB: expected %u (%u), got %u\n", previous << 1, previous, backoff);
}
}
@ -66,8 +63,7 @@ main(void)
if (i++ >= 3)
break;
} else if (previous * previous >= backoff) {
fprintf(stderr, "[N] EB: expected %u (%u), got %u\n", previous * previous, previous, backoff);
exit(EXIT_FAILURE);
ck_error("[N] EB: expected %u (%u), got %u\n", previous * previous, previous, backoff);
}
}

47
regressions/ck_bag/validate/order.c
Unescape View File

@ -124,16 +124,12 @@ reader(void *arg)
curr = (uintptr_t)(curr_ptr);
if (curr < prev) {
/* Ascending order within block violated */
fprintf(stderr, "%p: %p: %ju\n", (void *)&epoch_record, (void *)iterator.block, (uintmax_t)curr);
fprintf(stderr, "ERROR: %ju < %ju \n",
(uintmax_t)curr, (uintmax_t)prev);
exit(EXIT_FAILURE);
ck_error("%p: %p: %ju\nERROR: %ju < %ju\n",
(void *)&epoch_record, (void *)iterator.block, (uintmax_t)curr, (uintmax_t)curr, (uintmax_t)prev);
} else if (prev_max != -1 && curr > prev_max) {
/* Max of prev block > max of current block */
fprintf(stderr, "%p: %p: %ju\n", (void *)&epoch_record, (void *)iterator.block, (uintmax_t)curr);
fprintf(stderr, "ERROR: %ju > prev_max: %ju\n",
(uintmax_t)curr, (uintmax_t)prev_max);
exit(EXIT_FAILURE);
ck_error("%p: %p: %ju\nERROR: %ju > %ju\n",
(void *)&epoch_record, (void *)iterator.block, (uintmax_t)curr, (uintmax_t)curr, (uintmax_t)prev_max);
}
curr_max = curr;
@ -148,7 +144,7 @@ reader(void *arg)
break;
}
fprintf(stderr, "Read %llu entries in %llu iterations.\n", n_entries, iterations);
ck_error("Read %llu entries in %llu iterations.\n", n_entries, iterations);
ck_pr_inc_uint(&barrier);
while (ck_pr_load_uint(&barrier) != NUM_READER_THREADS + 1)
@ -175,8 +171,7 @@ writer_thread(void *unused)
}
if (ck_bag_member_spmc(&bag, (void *)(uintptr_t)i) == false) {
fprintf(stderr, "ck_bag_put_spmc [%u]: %u\n", iteration, i);
exit(EXIT_FAILURE);
ck_error("ck_bag_put_spmc [%u]: %u\n", iteration, i);
}
}
@ -186,28 +181,25 @@ writer_thread(void *unused)
for (i = 1; i < writer_max; i++) {
void *replace = (void *)(uintptr_t)i;
if (ck_bag_set_spmc(&bag, (void *)(uintptr_t)i, replace) == false) {
fprintf(stderr, "ERROR: set %ju != %ju",
ck_error("ERROR: set %ju != %ju",
(uintmax_t)(uintptr_t)replace, (uintmax_t)i);
exit(EXIT_FAILURE);
}
}
for (i = writer_max; i > 0; i--) {
if (ck_bag_member_spmc(&bag, (void *)(uintptr_t)i) == false) {
fprintf(stderr, "ck_bag_member_spmc [%u]: %u\n", iteration, i);
exit(EXIT_FAILURE);
ck_error("ck_bag_member_spmc [%u]: %u\n", iteration, i);
}
if (ck_bag_remove_spmc(&bag, (void *)(uintptr_t)i) == false) {
fprintf(stderr, "ck_bag_remove_spmc [%u]: %u\n", iteration, i);
exit(EXIT_FAILURE);
ck_error("ck_bag_remove_spmc [%u]: %u\n", iteration, i);
}
}
ck_epoch_poll(&epoch_bag, &epoch_wr);
}
fprintf(stderr, "Writer %u iterations, %u writes per iteration.\n", iteration, writer_max);
ck_error("Writer %u iterations, %u writes per iteration.\n", iteration, writer_max);
while (ck_pr_load_uint(&barrier) != NUM_READER_THREADS)
ck_pr_stall();
@ -228,8 +220,7 @@ main(int argc, char **argv)
if (argc >= 2) {
int r = atoi(argv[1]);
if (r <= 0) {
fprintf(stderr, "# entries in block must be > 0\n");
exit(EXIT_FAILURE);
ck_error("# entries in block must be > 0\n");
}
b = (size_t)r;
@ -238,8 +229,7 @@ main(int argc, char **argv)
if (argc >= 3) {
int r = atoi(argv[2]);
if (r < 16) {
fprintf(stderr, "# entries must be >= 16\n");
exit(EXIT_FAILURE);
ck_error("# entries must be >= 16\n");
}
writer_max = (unsigned int)r;
@ -249,10 +239,9 @@ main(int argc, char **argv)
ck_epoch_register(&epoch_bag, &epoch_wr);
ck_bag_allocator_set(&allocator, sizeof(struct bag_epoch));
if (ck_bag_init(&bag, b, CK_BAG_ALLOCATE_GEOMETRIC) == false) {
fprintf(stderr, "Error: failed ck_bag_init().");
exit(EXIT_FAILURE);
ck_error("Error: failed ck_bag_init().");
}
fprintf(stderr, "Configuration: %u entries, %zu bytes/block, %zu entries/block\n", writer_max, bag.info.bytes, bag.info.max);
ck_error("Configuration: %u entries, %zu bytes/block, %zu entries/block\n", writer_max, bag.info.bytes, bag.info.max);
i = 1;
/* Basic Test */
@ -277,7 +266,7 @@ main(int argc, char **argv)
while (ck_bag_next(&bag_it, &curr_ptr)) {
curr = (uintptr_t)(curr_ptr);
if (curr > (uintptr_t)i)
fprintf(stderr, "ERROR: %ju != %u\n", (uintmax_t)curr, i);
ck_error("ERROR: %ju != %u\n", (uintmax_t)curr, i);
ck_bag_remove_spmc(&bag, curr_ptr);
}
@ -289,16 +278,16 @@ main(int argc, char **argv)
pthread_create(&readers[i], NULL, reader, NULL);
}
fprintf(stderr, "Waiting...");
ck_error("Waiting...");
sleep(30);
fprintf(stderr, "done\n");
ck_error("done\n");
ck_pr_store_int(&leave, 1);
for (i = 0; i < NUM_READER_THREADS; i++)
pthread_join(readers[i], NULL);
pthread_join(writer, NULL);
fprintf(stderr, "Current entries: %u\n", ck_bag_count(&bag));
ck_error("Current entries: %u\n", ck_bag_count(&bag));
ck_bag_destroy(&bag);
return 0;
}

19
regressions/ck_barrier/benchmark/throughput.c
Unescape View File

@ -86,38 +86,33 @@ main(int argc, char *argv[])
int i;
if (argc != 3) {
fprintf(stderr, "Correct usage: <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Correct usage: <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
counters = calloc(sizeof(struct counter), nthr);
if (counters == NULL) {
fprintf(stderr, "ERROR: Could not allocate counters\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate counters\n");
}
a.delta = atoi(argv[2]);
fprintf(stderr, "Creating threads (barrier)...");
ck_error("Creating threads (barrier)...");
for (i = 0; i < nthr; ++i) {
if (pthread_create(&threads[i], NULL, thread, NULL)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
sleep(10);

23
regressions/ck_barrier/validate/barrier_centralized.c
Unescape View File

@ -73,8 +73,7 @@ thread(void *null CK_CC_UNUSED)
ck_barrier_centralized(&barrier, &state, nthr);
counter = ck_pr_load_int(&counters[i]);
if (counter != nthr * (j / ENTRIES + 1)) {
fprintf(stderr, "FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
exit(EXIT_FAILURE);
ck_error("FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
}
}
@ -88,37 +87,33 @@ main(int argc, char *argv[])
int i;
if (argc < 3) {
fprintf(stderr, "Usage: correct <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: correct <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
a.delta = atoi(argv[2]);
fprintf(stderr, "Creating threads (barrier)...");
ck_error("Creating threads (barrier)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread, NULL)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);

32
regressions/ck_barrier/validate/barrier_combining.c
Unescape View File

@ -75,8 +75,7 @@ thread(void *group)
ck_barrier_combining(&barrier, group, &state);
counter = ck_pr_load_int(&counters[i]);
if (counter != nthr * ngroups * (j / ENTRIES + 1)) {
fprintf(stderr, "FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr * ngroups);
exit(EXIT_FAILURE);
ck_error("FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr * ngroups);
}
}
@ -93,38 +92,32 @@ main(int argc, char *argv[])
init_root = malloc(sizeof(ck_barrier_combining_group_t));
if (init_root == NULL) {
fprintf(stderr, "ERROR: Could not allocate initial barrier structure\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate initial barrier structure\n");
}
ck_barrier_combining_init(&barrier, init_root);
if (argc < 4) {
fprintf(stderr, "Usage: correct <total groups> <threads per group> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: correct <total groups> <threads per group> <affinity delta>\n");
}
ngroups = atoi(argv[1]);
if (ngroups <= 0) {
fprintf(stderr, "ERROR: Number of groups must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of groups must be greater than 0\n");
}
nthr = atoi(argv[2]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
groupings = malloc(sizeof(ck_barrier_combining_group_t) * ngroups);
if (groupings == NULL) {
fprintf(stderr, "Could not allocate thread barrier grouping structures\n");
exit(EXIT_FAILURE);
ck_error("Could not allocate thread barrier grouping structures\n");
}
threads = malloc(sizeof(pthread_t) * nthr * ngroups);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
a.delta = atoi(argv[3]);
@ -132,19 +125,18 @@ main(int argc, char *argv[])
for (i = 0; i < ngroups; i++)
ck_barrier_combining_group_init(&barrier, groupings + i, nthr);
fprintf(stderr, "Creating threads (barrier)...");
ck_error("Creating threads (barrier)...");
for (i = 0; i < (nthr * ngroups); i++) {
if (pthread_create(&threads[i], NULL, thread, groupings + (i % ngroups))) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < (nthr * ngroups); i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);
}

32
regressions/ck_barrier/validate/barrier_dissemination.c
Unescape View File

@ -75,8 +75,7 @@ thread(void *b)
ck_barrier_dissemination(barrier, &state);
counter = ck_pr_load_int(&counters[i]);
if (counter != nthr * (j / ENTRIES + 1)) {
fprintf(stderr, "FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
exit(EXIT_FAILURE);
ck_error("FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
}
}
@ -92,59 +91,52 @@ main(int argc, char *argv[])
int i, size;
if (argc < 3) {
fprintf(stderr, "Usage: correct <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: correct <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
a.delta = atoi(argv[2]);
barrier = malloc(sizeof(ck_barrier_dissemination_t) * nthr);
if (barrier == NULL) {
fprintf(stderr, "ERROR: Could not allocate barrier structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate barrier structures\n");
}
barrier_internal = malloc(sizeof(ck_barrier_dissemination_flag_t *) * nthr);
if (barrier_internal == NULL) {
fprintf(stderr, "ERROR: Could not allocate barrier structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate barrier structures\n");
}
size = ck_barrier_dissemination_size(nthr);
for (i = 0; i < nthr; ++i) {
barrier_internal[i] = malloc(sizeof(ck_barrier_dissemination_flag_t) * size);
if (barrier_internal[i] == NULL) {
fprintf(stderr, "ERROR: Could not allocate barrier structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate barrier structures\n");
}
}
ck_barrier_dissemination_init(barrier, barrier_internal, nthr);
fprintf(stderr, "Creating threads (barrier)...");
ck_error("Creating threads (barrier)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread, barrier)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);

26
regressions/ck_barrier/validate/barrier_mcs.c
Unescape View File

@ -76,8 +76,7 @@ thread(void *b)
ck_barrier_mcs(barrier, &state);
counter = ck_pr_load_int(&counters[i]);
if (counter != nthr * (j / ENTRIES + 1)) {
fprintf(stderr, "FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
exit(EXIT_FAILURE);
ck_error("FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
}
}
@ -92,44 +91,39 @@ main(int argc, char *argv[])
int i;
if (argc < 3) {
fprintf(stderr, "Usage: correct <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: correct <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
barrier = malloc(sizeof(ck_barrier_mcs_t) * nthr);
if (barrier == NULL) {
fprintf(stderr, "ERROR: Could not allocate barrier structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate barrier structures\n");
}
ck_barrier_mcs_init(barrier, nthr);
a.delta = atoi(argv[2]);
fprintf(stderr, "Creating threads (barrier)...");
ck_error("Creating threads (barrier)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread, barrier)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);

29
regressions/ck_barrier/validate/barrier_tournament.c
Unescape View File

@ -75,8 +75,7 @@ thread(CK_CC_UNUSED void *unused)
ck_barrier_tournament(&barrier, &state);
counter = ck_pr_load_int(&counters[i]);
if (counter != nthr * (j / ENTRIES + 1)) {
fprintf(stderr, "FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
exit(EXIT_FAILURE);
ck_error("FAILED [%d:%d]: %d != %d\n", i, j - 1, counter, nthr);
}
}
@ -96,53 +95,47 @@ main(int argc, char *argv[])
unsigned int size;
if (argc < 3) {
fprintf(stderr, "Usage: correct <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: correct <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
a.delta = atoi(argv[2]);
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
rounds = malloc(sizeof(ck_barrier_tournament_round_t *) * nthr);
if (rounds == NULL) {
fprintf(stderr, "ERROR: Could not allocate barrier structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate barrier structures\n");
}
size = ck_barrier_tournament_size(nthr);
for (i = 0; i < nthr; ++i) {
rounds[i] = malloc(sizeof(ck_barrier_tournament_round_t) * size);
if (rounds[i] == NULL) {
fprintf(stderr, "ERROR: Could not allocate barrier structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate barrier structures\n");
}
}
ck_barrier_tournament_init(&barrier, rounds, nthr);
fprintf(stderr, "Creating threads (barrier)...");
ck_error("Creating threads (barrier)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread, NULL)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);
}

39
regressions/ck_bitmap/validate/serial.c
Unescape View File

@ -31,6 +31,8 @@
#include <stdlib.h>
#include <string.h>
#include "../../common.h"
#ifndef STATIC_LENGTH
#define STATIC_LENGTH 256
#endif
@ -57,13 +59,11 @@ check_iteration(ck_bitmap_t *bits, unsigned int len, bool initial)
if (i == j)
continue;
fprintf(stderr, "[4] ERROR: Expected bit %u, got bit %u\n", j, i);
exit(EXIT_FAILURE);
ck_error("[4] ERROR: Expected bit %u, got bit %u\n", j, i);
}
if (j != len) {
fprintf(stderr, "[5] ERROR: Expected length %u, got length %u\n", len, j);
exit(EXIT_FAILURE);
ck_error("[5] ERROR: Expected length %u, got length %u\n", len, j);
}
return;
@ -76,28 +76,24 @@ test(ck_bitmap_t *bits, unsigned int n_length, bool initial)
for (i = 0; i < n_length; i++) {
if (ck_bitmap_test(bits, i) == !initial) {
fprintf(stderr, "[0] ERROR [%u]: Expected %u got %u\n", i,
ck_error("[0] ERROR [%u]: Expected %u got %u\n", i,
initial, !initial);
exit(EXIT_FAILURE);
}
}
for (i = 0; i < n_length; i++) {
ck_bitmap_set_mpmc(bits, i);
if (ck_bitmap_test(bits, i) == false) {
fprintf(stderr, "[1] ERROR: Expected bit to be set: %u\n", i);
exit(EXIT_FAILURE);
ck_error("[1] ERROR: Expected bit to be set: %u\n", i);
}
ck_bitmap_reset_mpmc(bits, i);
if (ck_bitmap_test(bits, i) == true) {
fprintf(stderr, "[2] ERROR: Expected bit to be cleared: %u\n", i);
exit(EXIT_FAILURE);
ck_error("[2] ERROR: Expected bit to be cleared: %u\n", i);
}
ck_bitmap_set_mpmc(bits, i);
if (ck_bitmap_test(bits, i) == false) {
fprintf(stderr, "[3] ERROR: Expected bit to be set: %u\n", i);
exit(EXIT_FAILURE);
ck_error("[3] ERROR: Expected bit to be set: %u\n", i);
}
check_iteration(bits, i, initial);
@ -105,8 +101,7 @@ test(ck_bitmap_t *bits, unsigned int n_length, bool initial)
for (i = 0; i < n_length; i++) {
if (ck_bitmap_test(bits, i) == false) {
fprintf(stderr, "[4] ERROR: Expected bit to be set: %u\n", i);
exit(EXIT_FAILURE);
ck_error("[4] ERROR: Expected bit to be set: %u\n", i);
}
}
@ -114,8 +109,7 @@ test(ck_bitmap_t *bits, unsigned int n_length, bool initial)
for (i = 0; i < n_length; i++) {
if (ck_bitmap_test(bits, i) == true) {
fprintf(stderr, "[4] ERROR: Expected bit to be reset: %u\n", i);
exit(EXIT_FAILURE);
ck_error("[4] ERROR: Expected bit to be reset: %u\n", i);
}
}
@ -133,7 +127,7 @@ main(int argc, char *argv[])
base = ck_bitmap_base(length);
bytes = ck_bitmap_size(length);
fprintf(stderr, "Configuration: %u bytes\n",
ck_error("Configuration: %u bytes\n",
bytes);
g_bits = malloc(bytes);
@ -148,7 +142,7 @@ main(int argc, char *argv[])
ck_bitmap_test(g_bits, length - 1);
CK_BITMAP_INSTANCE(STATIC_LENGTH) sb;
fprintf(stderr, "Static configuration: %zu bytes\n",
ck_error("Static configuration: %zu bytes\n",
sizeof(sb));
memset(CK_BITMAP_BUFFER(&sb), 0xFF, ck_bitmap_base(STATIC_LENGTH));
CK_BITMAP_INIT(&sb, STATIC_LENGTH, false);
@ -159,20 +153,17 @@ main(int argc, char *argv[])
CK_BITMAP_CLEAR(&sb);
if (CK_BITMAP_TEST(&sb, 1) == true) {
fprintf(stderr, "ERROR: Expected bit to be reset.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Expected bit to be reset.\n");
}
CK_BITMAP_SET_MPMC(&sb, 1);
if (CK_BITMAP_TEST(&sb, 1) == false) {
fprintf(stderr, "ERROR: Expected bit to be set.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Expected bit to be set.\n");
}
CK_BITMAP_RESET_MPMC(&sb, 1);
if (CK_BITMAP_TEST(&sb, 1) == true) {
fprintf(stderr, "ERROR: Expected bit to be reset.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Expected bit to be reset.\n");
}
return 0;

23
regressions/ck_brlock/benchmark/throughput.c
Unescape View File

@ -119,47 +119,42 @@ main(int argc, char *argv[])
uint64_t *latency;
if (argc != 3) {
fprintf(stderr, "Usage: throughput <delta> <threads>\n");
exit(EXIT_FAILURE);
ck_error("Usage: throughput <delta> <threads>\n");
}
threads = atoi(argv[2]);
if (threads <= 0) {
fprintf(stderr, "ERROR: Threads must be a value > 0.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Threads must be a value > 0.\n");
}
p = malloc(sizeof(pthread_t) * threads);
if (p == NULL) {
fprintf(stderr, "ERROR: Failed to initialize thread.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to initialize thread.\n");
}
latency = malloc(sizeof(uint64_t) * threads);
if (latency == NULL) {
fprintf(stderr, "ERROR: Failed to create latency buffer.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to create latency buffer.\n");
}
affinity.delta = atoi(argv[1]);
affinity.request = 0;
fprintf(stderr, "Creating threads (brlock)...");
ck_error("Creating threads (brlock)...");
for (t = 0; t < threads; t++) {
if (pthread_create(&p[t], NULL, thread_brlock, latency + t) != 0) {
fprintf(stderr, "ERROR: Could not create thread %d\n", t);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", t);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
sleep(10);
ck_pr_store_uint(&flag, 1);
fprintf(stderr, "Waiting for threads to finish acquisition regression...");
ck_error("Waiting for threads to finish acquisition regression...");
for (t = 0; t < threads; t++)
pthread_join(p[t], NULL);
fprintf(stderr, "done\n\n");
ck_error("done\n\n");
for (t = 1; t <= threads; t++)
printf("%10u %20" PRIu64 "\n", t, latency[t - 1]);

32
regressions/ck_brlock/validate/validate.c
Unescape View File

@ -68,8 +68,7 @@ thread(void *null CK_CC_UNUSED)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
ck_pr_inc_uint(&locked);
@ -83,8 +82,7 @@ thread(void *null CK_CC_UNUSED)
l = ck_pr_load_uint(&locked);
if (l != 8) {
fprintf(stderr, "ERROR [WR:%d]: %u != 2\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
}
ck_pr_dec_uint(&locked);
@ -98,8 +96,7 @@ thread(void *null CK_CC_UNUSED)
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
}
ck_brlock_write_unlock(&lock);
@ -108,8 +105,7 @@ thread(void *null CK_CC_UNUSED)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [RD:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
}
}
ck_brlock_read_unlock(&r);
@ -126,37 +122,33 @@ main(int argc, char *argv[])
int i;
if (argc != 3) {
fprintf(stderr, "Usage: validate <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
a.delta = atoi(argv[2]);
fprintf(stderr, "Creating threads (mutual exclusion)...");
ck_error("Creating threads (mutual exclusion)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread, NULL)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);
}

35
regressions/ck_bytelock/validate/validate.c
Unescape View File

@ -70,8 +70,7 @@ thread(void *null)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
ck_pr_inc_uint(&locked);
@ -85,8 +84,7 @@ thread(void *null)
l = ck_pr_load_uint(&locked);
if (l != 8) {
fprintf(stderr, "ERROR [WR:%d]: %u != 2\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
}
ck_pr_dec_uint(&locked);
@ -100,8 +98,7 @@ thread(void *null)
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
}
ck_bytelock_write_unlock(&lock);
@ -110,8 +107,7 @@ thread(void *null)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [RD:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
}
}
ck_bytelock_read_unlock(&lock, context->tid);
@ -128,44 +124,39 @@ main(int argc, char *argv[])
int i;
if (argc != 3) {
fprintf(stderr, "Usage: correct <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: correct <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
context = malloc(sizeof(struct block) * nthr);
if (context == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread contexts\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread contexts\n");
}
a.delta = atoi(argv[2]);
fprintf(stderr, "Creating threads (mutual exclusion)...");
ck_error("Creating threads (mutual exclusion)...");
for (i = 0; i < nthr; i++) {
context[i].tid = i + 1;
if (pthread_create(&threads[i], NULL, thread, context + i)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);
}

15
regressions/ck_epoch/validate/ck_epoch_poll.c
Unescape View File

@ -138,7 +138,7 @@ read_thread(void *unused CK_CC_UNUSED)
ck_pr_inc_uint(&e_barrier);
while (ck_pr_load_uint(&e_barrier) < n_threads);
fprintf(stderr, "[R] Observed entries: %u\n", j);
ck_error("[R] Observed entries: %u\n", j);
return (NULL);
}
@ -163,16 +163,14 @@ write_thread(void *unused CK_CC_UNUSED)
entry = malloc(sizeof(struct node *) * PAIRS_S);
if (entry == NULL) {
fprintf(stderr, "Failed allocation.\n");
exit(EXIT_FAILURE);
ck_error("Failed allocation.\n");
}
for (j = 0; j < ITERATE_S; j++) {
for (i = 0; i < PAIRS_S; i++) {
entry[i] = malloc(sizeof(struct node));
if (entry == NULL) {
fprintf(stderr, "Failed individual allocation\n");
exit(EXIT_FAILURE);
ck_error("Failed individual allocation\n");
}
}
@ -184,7 +182,7 @@ write_thread(void *unused CK_CC_UNUSED)
ck_pr_stall();
if (tid == 0) {
fprintf(stderr, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] %2.2f: %c",
ck_error("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] %2.2f: %c",
(double)j / ITERATE_S, animate[i % strlen(animate)]);
}
@ -202,7 +200,7 @@ write_thread(void *unused CK_CC_UNUSED)
ck_epoch_synchronize(&stack_epoch, &record);
if (tid == 0) {
fprintf(stderr, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] Peak: %u (%2.2f%%)\n Reclamations: %lu\n\n",
ck_error("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] Peak: %u (%2.2f%%)\n Reclamations: %lu\n\n",
record.n_peak,
(double)record.n_peak / ((double)PAIRS_S * ITERATE_S) * 100,
record.n_dispatch);
@ -220,8 +218,7 @@ main(int argc, char *argv[])
pthread_t *threads;
if (argc != 4) {
fprintf(stderr, "Usage: stack <#readers> <#writers> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <#readers> <#writers> <affinity delta>\n");
}
n_rd = atoi(argv[1]);

17
regressions/ck_epoch/validate/ck_epoch_synchronize.c
Unescape View File

@ -138,7 +138,7 @@ read_thread(void *unused CK_CC_UNUSED)
ck_pr_inc_uint(&e_barrier);
while (ck_pr_load_uint(&e_barrier) < n_threads);
fprintf(stderr, "[R] Observed entries: %u\n", j);
ck_error("[R] Observed entries: %u\n", j);
return (NULL);
}
@ -163,16 +163,14 @@ write_thread(void *unused CK_CC_UNUSED)
entry = malloc(sizeof(struct node *) * PAIRS_S);
if (entry == NULL) {
fprintf(stderr, "Failed allocation.\n");
exit(EXIT_FAILURE);
ck_error("Failed allocation.\n");
}
for (j = 0; j < ITERATE_S; j++) {
for (i = 0; i < PAIRS_S; i++) {
entry[i] = malloc(sizeof(struct node));
if (entry == NULL) {
fprintf(stderr, "Failed individual allocation\n");
exit(EXIT_FAILURE);
ck_error("Failed individual allocation\n");
}
}
@ -184,7 +182,7 @@ write_thread(void *unused CK_CC_UNUSED)
ck_pr_stall();
if (tid == 0) {
fprintf(stderr, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] %2.2f: %c",
ck_error("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] %2.2f: %c",
(double)j / ITERATE_S, animate[i % strlen(animate)]);
}
@ -200,7 +198,7 @@ write_thread(void *unused CK_CC_UNUSED)
ck_epoch_call(&stack_epoch, &record, &e->epoch_entry, destructor);
} else {
if (tid == 0 && i % 8192)
fprintf(stderr, "\b%c", animate[i % strlen(animate)]);
ck_error("\b%c", animate[i % strlen(animate)]);
destructor(&e->epoch_entry);
}
@ -210,7 +208,7 @@ write_thread(void *unused CK_CC_UNUSED)
ck_epoch_synchronize(&stack_epoch, &record);
if (tid == 0) {
fprintf(stderr, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] Peak: %u (%2.2f%%)\n Reclamations: %lu\n\n",
ck_error("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b[W] Peak: %u (%2.2f%%)\n Reclamations: %lu\n\n",
record.n_peak,
(double)record.n_peak / ((double)PAIRS_S * ITERATE_S) * 100,
record.n_dispatch);
@ -228,8 +226,7 @@ main(int argc, char *argv[])
pthread_t *threads;
if (argc != 4) {
fprintf(stderr, "Usage: stack <#readers> <#writers> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <#readers> <#writers> <affinity delta>\n");
}
n_rd = atoi(argv[1]);

16
regressions/ck_epoch/validate/ck_stack.c
Unescape View File

@ -90,15 +90,13 @@ thread(void *unused CK_CC_UNUSED)
entry = malloc(sizeof(struct node *) * PAIRS);
if (entry == NULL) {
fprintf(stderr, "Failed allocation.\n");
exit(EXIT_FAILURE);
ck_error("Failed allocation.\n");
}
for (i = 0; i < PAIRS; i++) {
entry[i] = malloc(sizeof(struct node));
if (entry == NULL) {
fprintf(stderr, "Failed individual allocation\n");
exit(EXIT_FAILURE);
ck_error("Failed individual allocation\n");
}
}
@ -119,8 +117,8 @@ thread(void *unused CK_CC_UNUSED)
ck_pr_inc_uint(&e_barrier);
while (ck_pr_load_uint(&e_barrier) < n_threads);
fprintf(stderr, "Deferrals: %lu (%2.2f)\n", smr, (double)smr / PAIRS);
fprintf(stderr, "Peak: %u (%2.2f%%), %u pending\nReclamations: %lu\n\n",
ck_error("Deferrals: %lu (%2.2f)\n", smr, (double)smr / PAIRS);
ck_error("Peak: %u (%2.2f%%), %u pending\nReclamations: %lu\n\n",
record.n_peak,
(double)record.n_peak / PAIRS * 100,
record.n_pending,
@ -131,9 +129,8 @@ thread(void *unused CK_CC_UNUSED)
while (ck_pr_load_uint(&e_barrier) < (n_threads << 1));
if (record.n_pending != 0) {
fprintf(stderr, "ERROR: %u pending, expecting none.\n",
ck_error("ERROR: %u pending, expecting none.\n",
record.n_pending);
exit(EXIT_FAILURE);
}
return (NULL);
@ -146,8 +143,7 @@ main(int argc, char *argv[])
pthread_t *threads;
if (argc != 3) {
fprintf(stderr, "Usage: stack <threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <threads> <affinity delta>\n");
}
n_threads = atoi(argv[1]);

14
regressions/ck_fifo/validate/ck_fifo_mpmc.c
Unescape View File

@ -82,13 +82,11 @@ test(void *c)
entry->tid = context->tid;
ck_fifo_mpmc_enqueue(&fifo, fifo_entry, entry);
if (ck_fifo_mpmc_dequeue(&fifo, &entry, &garbage) == false) {
fprintf(stderr, "ERROR [%u] Queue should never be empty.\n", context->tid);
exit(EXIT_FAILURE);
ck_error("ERROR [%u] Queue should never be empty.\n", context->tid);
}
if (entry->tid < 0 || entry->tid >= nthr) {
fprintf(stderr, "ERROR [%u] Incorrect value in entry.\n", entry->tid);
exit(EXIT_FAILURE);
ck_error("ERROR [%u] Incorrect value in entry.\n", entry->tid);
}
}
}
@ -105,8 +103,7 @@ test(void *c)
ck_pr_stall();
if (entry->tid < 0 || entry->tid >= nthr) {
fprintf(stderr, "ERROR [%u] Incorrect value in entry when using try interface.\n", entry->tid);
exit(EXIT_FAILURE);
ck_error("ERROR [%u] Incorrect value in entry when using try interface.\n", entry->tid);
}
}
}
@ -123,8 +120,7 @@ main(int argc, char *argv[])
pthread_t *thread;
if (argc != 4) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <threads> <affinity delta> <size>\n");
}
a.request = 0;
@ -158,7 +154,7 @@ main(int argc, char *argv[])
int
main(void)
{
fprintf(stderr, "Unsupported.\n");
ck_error("Unsupported.\n");
return 0;
}
#endif

11
regressions/ck_fifo/validate/ck_fifo_spsc.c
Unescape View File

@ -68,7 +68,7 @@ test(void *c)
}
#ifdef DEBUG
fprintf(stderr, "%p %u: %u -> %u\n", fifo+context->tid, context->tid, context->previous, context->tid);
ck_error("%p %u: %u -> %u\n", fifo+context->tid, context->tid, context->previous, context->tid);
#endif
if (context->tid == 0) {
@ -93,15 +93,13 @@ test(void *c)
for (j = 0; j < size; j++) {
while (ck_fifo_spsc_dequeue(fifo + context->previous, &entry) == false);
if (context->previous != (unsigned int)entry->tid) {
fprintf(stderr, "T [%u:%p] %u != %u\n",
ck_error("T [%u:%p] %u != %u\n",
context->tid, (void *)entry, entry->tid, context->previous);
exit(EXIT_FAILURE);
}
if (entry->value != j) {
fprintf(stderr, "V [%u:%p] %u != %u\n",
ck_error("V [%u:%p] %u != %u\n",
context->tid, (void *)entry, entry->value, j);
exit(EXIT_FAILURE);
}
entry->tid = context->tid;
@ -124,8 +122,7 @@ main(int argc, char *argv[])
pthread_t *thread;
if (argc != 4) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <threads> <affinity delta> <size>\n");
}
a.request = 0;

3
regressions/ck_hp/benchmark/fifo_latency.c
Unescape View File

@ -59,8 +59,7 @@ main(void)
r = malloc(CK_HP_FIFO_SLOTS_SIZE);
if (r == NULL) {
fprintf(stderr, "ERROR: Failed to allocate slots.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to allocate slots.\n");
}
ck_hp_register(&fifo_hp, &record, r);

3
regressions/ck_hp/benchmark/stack_latency.c
Unescape View File

@ -58,8 +58,7 @@ main(void)
ck_hp_init(&stack_hp, CK_HP_STACK_SLOTS_COUNT, 1000000, NULL);
r = malloc(CK_HP_STACK_SLOTS_SIZE);
if (r == NULL) {
fprintf(stderr, "ERROR: Failed to allocate slots.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to allocate slots.\n");
}
ck_hp_register(&stack_hp, &record, (void *)r);

12
regressions/ck_hp/validate/ck_hp_fifo.c
Unescape View File

@ -85,15 +85,13 @@ test(void *c)
fifo_entry = ck_hp_fifo_dequeue_mpmc(&record, &fifo, &entry);
if (fifo_entry == NULL) {
fprintf(stderr, "ERROR [%u] Queue should never be empty.\n", context->tid);
exit(EXIT_FAILURE);
ck_error("ERROR [%u] Queue should never be empty.\n", context->tid);
}
ck_pr_barrier();
if (entry->tid < 0 || entry->tid >= nthr) {
fprintf(stderr, "ERROR [%u] Incorrect value in entry.\n", entry->tid);
exit(EXIT_FAILURE);
ck_error("ERROR [%u] Incorrect value in entry.\n", entry->tid);
}
ck_hp_free(&record, &fifo_entry->hazard, fifo_entry, fifo_entry);
@ -113,8 +111,7 @@ test(void *c)
ck_pr_stall();
if (entry->tid < 0 || entry->tid >= nthr) {
fprintf(stderr, "ERROR [%u] Incorrect value in entry.\n", entry->tid);
exit(EXIT_FAILURE);
ck_error("ERROR [%u] Incorrect value in entry.\n", entry->tid);
}
ck_hp_free(&record, &fifo_entry->hazard, fifo_entry, fifo_entry);
@ -144,8 +141,7 @@ main(int argc, char *argv[])
int threshold;
if (argc != 5) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size> <threshold>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <threads> <affinity delta> <size> <threshold>\n");
}
a.delta = atoi(argv[2]);

4
regressions/ck_hp/validate/ck_hp_fifo_donner.c
Unescape View File

@ -34,6 +34,7 @@
#include <pthread.h>
#include <sys/time.h>
#include <assert.h>
#include "../../common.h"
/* FIFO queue */
static ck_hp_fifo_t fifo;
@ -149,8 +150,7 @@ main(int argc, char** argv)
pthread_t *thr;
if (argc != 3) {
fprintf(stderr, "Usage: cktest <thread_count> <element_count>\n");
exit(EXIT_FAILURE);
ck_error("Usage: cktest <thread_count> <element_count>\n");
}
/* Get element count from argument */

14
regressions/ck_hp/validate/ck_hp_stack.c
Unescape View File

@ -84,15 +84,13 @@ thread(void *unused CK_CC_UNUSED)
entry = malloc(sizeof(struct node *) * PAIRS);
if (entry == NULL) {
fprintf(stderr, "Failed allocation.\n");
exit(EXIT_FAILURE);
ck_error("Failed allocation.\n");
}
for (i = 0; i < PAIRS; i++) {
entry[i] = malloc(sizeof(struct node));
if (entry == NULL) {
fprintf(stderr, "Failed individual allocation\n");
exit(EXIT_FAILURE);
ck_error("Failed individual allocation\n");
}
}
@ -109,7 +107,7 @@ thread(void *unused CK_CC_UNUSED)
ck_pr_inc_uint(&e_barrier);
while (ck_pr_load_uint(&e_barrier) < n_threads);
fprintf(stderr, "Peak: %u (%2.2f%%)\nReclamations: %" PRIu64 "\n\n",
ck_error("Peak: %u (%2.2f%%)\nReclamations: %" PRIu64 "\n\n",
record.n_peak,
(double)record.n_peak / PAIRS * 100,
record.n_reclamations);
@ -121,9 +119,8 @@ thread(void *unused CK_CC_UNUSED)
while (ck_pr_load_uint(&e_barrier) < (n_threads << 1));
if (record.n_pending != 0) {
fprintf(stderr, "ERROR: %u pending, expecting none.\n",
ck_error("ERROR: %u pending, expecting none.\n",
record.n_pending);
exit(EXIT_FAILURE);
}
return (NULL);
@ -144,8 +141,7 @@ main(int argc, char *argv[])
pthread_t *threads;
if (argc != 4) {
fprintf(stderr, "Usage: stack <threads> <threshold> <delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <threads> <threshold> <delta>\n");
}
n_threads = atoi(argv[1]);

5
regressions/ck_hp/validate/nbds_haz_test.c
Unescape View File

@ -201,8 +201,7 @@ main(int argc, char *argv[])
pthread_t *threads;
if (argc != 4) {
fprintf(stderr, "Usage: stack <threads> <threshold> <delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <threads> <threshold> <delta>\n");
}
n_threads = atoi(argv[1]);
@ -220,6 +219,6 @@ main(int argc, char *argv[])
for (i = 0; i < n_threads; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "Push: %u\nPop: %u\n", pushs, pops);
ck_error("Push: %u\nPop: %u\n", pushs, pops);
return (0);
}

10
regressions/ck_hp/validate/serial.c
Unescape View File

@ -38,6 +38,8 @@
#include <stddef.h>
#include <ck_hp.h>
#include "../../common.h"
struct entry {
unsigned int value;
ck_hp_hazard_t hazard;
@ -47,7 +49,7 @@ static void
destructor(void *pointer)
{
fprintf(stderr, "Free %p\n", pointer);
ck_error("Free %p\n", pointer);
free(pointer);
return;
}
@ -67,8 +69,7 @@ main(int argc, char *argv[])
pointers = malloc(sizeof(void *));
if (pointers == NULL) {
fprintf(stderr, "ERROR: Failed to allocate slot.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to allocate slot.\n");
}
ck_hp_register(&state, &record[0], pointers);
ck_hp_reclaim(&record[0]);
@ -91,8 +92,7 @@ main(int argc, char *argv[])
pointers = malloc(sizeof(void *));
if (pointers == NULL) {
fprintf(stderr, "ERROR: Failed to allocate slot.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to allocate slot.\n");
}
ck_hp_register(&state, &record[1], pointers);
ck_hp_reclaim(&record[1]);

75
regressions/ck_hs/benchmark/parallel_bytestring.c
Unescape View File

@ -227,8 +227,7 @@ reader(void *unused)
r = set_get(keys[i]);
if (r == NULL) {
if (n_state == HS_STATE_STRICT_REPLACEMENT) {
fprintf(stderr, "ERROR: Did not find during replacement: %s\n", keys[i]);
exit(EXIT_FAILURE);
ck_error("ERROR: Did not find during replacement: %s\n", keys[i]);
}
continue;
@ -237,8 +236,7 @@ reader(void *unused)
if (strcmp(r, keys[i]) == 0)
continue;
fprintf(stderr, "ERROR: Found invalid value: [%s] but expected [%s]\n", (char *)r, keys[i]);
exit(EXIT_FAILURE);
ck_error("ERROR: Found invalid value: [%s] but expected [%s]\n", (char *)r, keys[i]);
}
a += rdtsc() - s;
ck_epoch_end(&epoch_hs, &epoch_record);
@ -277,9 +275,8 @@ main(int argc, char *argv[])
n_threads = CORES - 1;
if (argc < 2) {
fprintf(stderr, "Usage: parallel <dictionary> [<interval length> <initial size> <readers>\n"
ck_error("Usage: parallel <dictionary> [<interval length> <initial size> <readers>\n"
" <probability of replacement> <probability of deletion> <epoch threshold>]\n");
exit(EXIT_FAILURE);
}
if (argc >= 3)
@ -291,24 +288,21 @@ main(int argc, char *argv[])
if (argc >= 5) {
n_threads = atoi(argv[4]);
if (n_threads < 1) {
fprintf(stderr, "ERROR: Number of readers must be >= 1.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of readers must be >= 1.\n");
}
}
if (argc >= 6) {
p_r = atof(argv[5]) / 100.00;
if (p_r < 0) {
fprintf(stderr, "ERROR: Probability of replacement must be >= 0 and <= 100.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Probability of replacement must be >= 0 and <= 100.\n");
}
}
if (argc >= 7) {
p_d = atof(argv[6]) / 100.00;
if (p_d < 0) {
fprintf(stderr, "ERROR: Probability of deletion must be >= 0 and <= 100.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Probability of deletion must be >= 0 and <= 100.\n");
}
}
@ -342,25 +336,23 @@ main(int argc, char *argv[])
for (i = 0; i < (size_t)n_threads; i++) {
if (pthread_create(&readers[i], NULL, reader, NULL) != 0) {
fprintf(stderr, "ERROR: Failed to create thread %zu.\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to create thread %zu.\n", i);
}
}
for (i = 0; i < keys_length; i++)
d += set_insert(keys[i]) == false;
fprintf(stderr, " [S] %d readers, 1 writer.\n", n_threads);
fprintf(stderr, " [S] %zu entries stored and %u duplicates.\n\n",
ck_error(" [S] %d readers, 1 writer.\n", n_threads);
ck_error(" [S] %zu entries stored and %u duplicates.\n\n",
set_count(), d);
fprintf(stderr, " ,- BASIC TEST\n");
fprintf(stderr, " | Executing SMR test...");
ck_error(" ,- BASIC TEST\n");
ck_error(" | Executing SMR test...");
a = 0;
for (j = 0; j < r; j++) {
if (set_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -369,9 +361,9 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing replacement test...");
ck_error(" | Executing replacement test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
@ -380,25 +372,24 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing get test...");
ck_error(" | Executing get test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
for (i = 0; i < keys_length; i++) {
if (set_get(keys[i]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
a = 0;
fprintf(stderr, " | Executing removal test...");
ck_error(" | Executing removal test...");
for (j = 0; j < r; j++) {
s = rdtsc();
for (i = 0; i < keys_length; i++)
@ -409,9 +400,9 @@ main(int argc, char *argv[])
for (i = 0; i < keys_length; i++)
set_insert(keys[i]);
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing negative look-up test...");
ck_error(" | Executing negative look-up test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
@ -421,18 +412,18 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_epoch_record_t epoch_temporary = epoch_wr;
ck_epoch_synchronize(&epoch_hs, &epoch_wr);
fprintf(stderr, " '- Summary: %u pending, %u peak, %lu reclamations -> "
ck_error(" '- Summary: %u pending, %u peak, %lu reclamations -> "
"%u pending, %u peak, %lu reclamations\n\n",
epoch_temporary.n_pending, epoch_temporary.n_peak, epoch_temporary.n_dispatch,
epoch_wr.n_pending, epoch_wr.n_peak, epoch_wr.n_dispatch);
fprintf(stderr, " ,- READER CONCURRENCY\n");
fprintf(stderr, " | Executing reader test...");
ck_error(" ,- READER CONCURRENCY\n");
ck_error(" | Executing reader test...");
ck_pr_store_int(&state, HS_STATE_GET);
while (ck_pr_load_int(&barrier[HS_STATE_STOP]) != n_threads)
@ -442,10 +433,10 @@ main(int argc, char *argv[])
ck_pr_store_int(&state, HS_STATE_STRICT_REPLACEMENT);
while (ck_pr_load_int(&barrier[HS_STATE_GET]) != n_threads)
ck_pr_stall();
fprintf(stderr, "done (reader = %" PRIu64 " ticks)\n",
ck_error("done (reader = %" PRIu64 " ticks)\n",
accumulator[HS_STATE_GET] / n_threads);
fprintf(stderr, " | Executing strict replacement test...");
ck_error(" | Executing strict replacement test...");
a = repeated = 0;
signal(SIGALRM, alarm_handler);
@ -471,13 +462,13 @@ main(int argc, char *argv[])
ck_pr_stall();
set_reset();
ck_epoch_synchronize(&epoch_hs, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HS_STATE_STRICT_REPLACEMENT] / n_threads);
signal(SIGALRM, alarm_handler);
alarm(r);
fprintf(stderr, " | Executing deletion test (%.2f)...", p_d * 100);
ck_error(" | Executing deletion test (%.2f)...", p_d * 100);
a = repeated = 0;
ck_pr_inc_int(&barrier[HS_STATE_STRICT_REPLACEMENT]);
for (;;) {
@ -507,13 +498,13 @@ main(int argc, char *argv[])
set_reset();
ck_epoch_synchronize(&epoch_hs, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HS_STATE_DELETION] / n_threads);
signal(SIGALRM, alarm_handler);
alarm(r);
fprintf(stderr, " | Executing replacement test (%.2f)...", p_r * 100);
ck_error(" | Executing replacement test (%.2f)...", p_r * 100);
a = repeated = 0;
ck_pr_inc_int(&barrier[HS_STATE_DELETION]);
for (;;) {
@ -547,14 +538,14 @@ main(int argc, char *argv[])
ck_pr_stall();
set_reset();
ck_epoch_synchronize(&epoch_hs, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HS_STATE_REPLACEMENT] / n_threads);
ck_pr_inc_int(&barrier[HS_STATE_REPLACEMENT]);
epoch_temporary = epoch_wr;
ck_epoch_synchronize(&epoch_hs, &epoch_wr);
fprintf(stderr, " '- Summary: %u pending, %u peak, %lu reclamations -> "
ck_error(" '- Summary: %u pending, %u peak, %lu reclamations -> "
"%u pending, %u peak, %lu reclamations\n\n",
epoch_temporary.n_pending, epoch_temporary.n_peak, epoch_temporary.n_dispatch,
epoch_wr.n_pending, epoch_wr.n_peak, epoch_wr.n_dispatch);

25
regressions/ck_hs/benchmark/serial.c
Unescape View File

@ -187,8 +187,7 @@ main(int argc, char *argv[])
srand(time(NULL));
if (argc < 2) {
fprintf(stderr, "Usage: ck_hs <dictionary> [<repetitions> <initial size>]\n");
exit(EXIT_FAILURE);
ck_error("Usage: ck_hs <dictionary> [<repetitions> <initial size>]\n");
}
if (argc >= 3)
@ -224,16 +223,15 @@ main(int argc, char *argv[])
d += set_insert(keys[i]) == false;
ck_hs_stat(&hs, &st);
fprintf(stderr, "# %zu entries stored, %u duplicates, %u probe.\n",
ck_error("# %zu entries stored, %u duplicates, %u probe.\n",
set_count(), d, st.probe_maximum);
fprintf(stderr, "# reverse_insertion serial_insertion random_insertion serial_replace reverse_get serial_get random_get serial_remove negative_get\n\n");
ck_error("# reverse_insertion serial_insertion random_insertion serial_replace reverse_get serial_get random_get serial_remove negative_get\n\n");
a = 0;
for (j = 0; j < r; j++) {
if (set_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -247,8 +245,7 @@ main(int argc, char *argv[])
a = 0;
for (j = 0; j < r; j++) {
if (set_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -264,8 +261,7 @@ main(int argc, char *argv[])
keys_shuffle(keys);
if (set_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -295,8 +291,7 @@ main(int argc, char *argv[])
s = rdtsc();
for (i = keys_length; i > 0; i--) {
if (set_get(keys[i - 1]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();
@ -309,8 +304,7 @@ main(int argc, char *argv[])
s = rdtsc();
for (i = 0; i < keys_length; i++) {
if (set_get(keys[i]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();
@ -325,8 +319,7 @@ main(int argc, char *argv[])
s = rdtsc();
for (i = 0; i < keys_length; i++) {
if (set_get(keys[i]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();

37
regressions/ck_hs/validate/serial.c
Unescape View File

@ -33,6 +33,8 @@
#include <stdlib.h>
#include <string.h>
#include "../../common.h"
static void *
hs_malloc(size_t r)
{
@ -100,8 +102,7 @@ main(void)
h = test[i][0];
ck_hs_put(&hs, h, test[i]);
if (ck_hs_put(&hs, h, test[i]) == true) {
fprintf(stderr, "ERROR [1]: put must fail on collision.\n");
exit(EXIT_FAILURE);
ck_error("ERROR [1]: put must fail on collision.\n");
}
}
@ -110,25 +111,21 @@ main(void)
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_hs_put(&hs, h, test[i]) == true) {
fprintf(stderr, "ERROR [2]: put must fail on collision.\n");
exit(EXIT_FAILURE);
ck_error("ERROR [2]: put must fail on collision.\n");
}
if (ck_hs_get(&hs, h, test[i]) == NULL) {
fprintf(stderr, "ERROR: get must not fail\n");
exit(EXIT_FAILURE);
ck_error("ERROR: get must not fail\n");
}
}
h = ULONG_MAX;
if (ck_hs_put(&hs, h, blob) == false) {
fprintf(stderr, "ERROR: Duplicate put failed.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Duplicate put failed.\n");
}
if (ck_hs_put(&hs, h, blob) == true) {
fprintf(stderr, "ERROR: Duplicate put succeeded.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Duplicate put succeeded.\n");
}
/* Grow set and check get semantics. */
@ -136,8 +133,7 @@ main(void)
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
h = test[i][0];
if (ck_hs_get(&hs, h, test[i]) == NULL) {
fprintf(stderr, "ERROR: get must not fail\n");
exit(EXIT_FAILURE);
ck_error("ERROR: get must not fail\n");
}
}
@ -150,13 +146,11 @@ main(void)
continue;
if (r = ck_hs_remove(&hs, h, test[i]), r == NULL) {
fprintf(stderr, "ERROR: remove must not fail\n");
exit(EXIT_FAILURE);
ck_error("ERROR: remove must not fail\n");
}
if (strcmp(r, test[i]) != 0) {
fprintf(stderr, "ERROR: Removed incorrect node (%s != %s)\n", (char *)r, test[i]);
exit(EXIT_FAILURE);
ck_error("ERROR: Removed incorrect node (%s != %s)\n", (char *)r, test[i]);
}
}
@ -168,24 +162,21 @@ main(void)
h = test[i][0];
d = ck_hs_get(&hs, h, test[i]) != NULL;
if (ck_hs_set(&hs, h, test[i], &r) == false) {
fprintf(stderr, "ERROR: Failed to set\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to set\n");
}
/* Expected replacement. */
if (d == true && (r == NULL || strcmp(r, test[i]) != 0)) {
fprintf(stderr, "ERROR: Incorrect previous value: %s != %s\n",
ck_error("ERROR: Incorrect previous value: %s != %s\n",
test[i], (char *)r);
}
if (ck_hs_set(&hs, h, test[i], &r) == false) {
fprintf(stderr, "ERROR: Failed to set [1]\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to set [1]\n");
}
if (strcmp(r, test[i]) != 0) {
fprintf(stderr, "ERROR: Invalid pointer: %s != %s\n", (char *)r, test[i]);
exit(EXIT_FAILURE);
ck_error("ERROR: Invalid pointer: %s != %s\n", (char *)r, test[i]);
}
}

72
regressions/ck_ht/benchmark/parallel_bytestring.c
Unescape View File

@ -231,8 +231,7 @@ reader(void *unused)
if (strcmp(r, keys[i]) == 0)
continue;
fprintf(stderr, "ERROR: Found invalid value: [%s] but expected [%s]\n", r, keys[i]);
exit(EXIT_FAILURE);
ck_error("ERROR: Found invalid value: [%s] but expected [%s]\n", r, keys[i]);
}
a += rdtsc() - s;
ck_epoch_end(&epoch_ht, &epoch_record);
@ -271,9 +270,8 @@ main(int argc, char *argv[])
n_threads = CORES - 1;
if (argc < 2) {
fprintf(stderr, "Usage: parallel <dictionary> [<interval length> <initial size> <readers>\n"
ck_error("Usage: parallel <dictionary> [<interval length> <initial size> <readers>\n"
" <probability of replacement> <probability of deletion> <epoch threshold>]\n");
exit(EXIT_FAILURE);
}
if (argc >= 3)
@ -285,24 +283,21 @@ main(int argc, char *argv[])
if (argc >= 5) {
n_threads = atoi(argv[4]);
if (n_threads < 1) {
fprintf(stderr, "ERROR: Number of readers must be >= 1.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of readers must be >= 1.\n");
}
}
if (argc >= 6) {
p_r = atof(argv[5]) / 100.00;
if (p_r < 0) {
fprintf(stderr, "ERROR: Probability of replacement must be >= 0 and <= 100.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Probability of replacement must be >= 0 and <= 100.\n");
}
}
if (argc >= 7) {
p_d = atof(argv[6]) / 100.00;
if (p_d < 0) {
fprintf(stderr, "ERROR: Probability of deletion must be >= 0 and <= 100.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Probability of deletion must be >= 0 and <= 100.\n");
}
}
@ -336,25 +331,23 @@ main(int argc, char *argv[])
for (i = 0; i < (size_t)n_threads; i++) {
if (pthread_create(&readers[i], NULL, reader, NULL) != 0) {
fprintf(stderr, "ERROR: Failed to create thread %zu.\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to create thread %zu.\n", i);
}
}
for (i = 0; i < keys_length; i++)
d += table_insert(keys[i]) == false;
fprintf(stderr, " [S] %d readers, 1 writer.\n", n_threads);
fprintf(stderr, " [S] %zu entries stored and %u duplicates.\n\n",
ck_error(" [S] %d readers, 1 writer.\n", n_threads);
ck_error(" [S] %zu entries stored and %u duplicates.\n\n",
table_count(), d);
fprintf(stderr, " ,- BASIC TEST\n");
fprintf(stderr, " | Executing SMR test...");
ck_error(" ,- BASIC TEST\n");
ck_error(" | Executing SMR test...");
a = 0;
for (j = 0; j < r; j++) {
if (table_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -363,9 +356,9 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing replacement test...");
ck_error(" | Executing replacement test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
@ -374,25 +367,24 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing get test...");
ck_error(" | Executing get test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
for (i = 0; i < keys_length; i++) {
if (table_get(keys[i]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
a = 0;
fprintf(stderr, " | Executing removal test...");
ck_error(" | Executing removal test...");
for (j = 0; j < r; j++) {
s = rdtsc();
for (i = 0; i < keys_length; i++)
@ -403,9 +395,9 @@ main(int argc, char *argv[])
for (i = 0; i < keys_length; i++)
table_insert(keys[i]);
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing negative look-up test...");
ck_error(" | Executing negative look-up test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
@ -415,18 +407,18 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_epoch_record_t epoch_temporary = epoch_wr;
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, " '- Summary: %u pending, %u peak, %lu reclamations -> "
ck_error(" '- Summary: %u pending, %u peak, %lu reclamations -> "
"%u pending, %u peak, %lu reclamations\n\n",
epoch_temporary.n_pending, epoch_temporary.n_peak, epoch_temporary.n_dispatch,
epoch_wr.n_pending, epoch_wr.n_peak, epoch_wr.n_dispatch);
fprintf(stderr, " ,- READER CONCURRENCY\n");
fprintf(stderr, " | Executing reader test...");
ck_error(" ,- READER CONCURRENCY\n");
ck_error(" | Executing reader test...");
ck_pr_store_int(&state, HT_STATE_GET);
while (ck_pr_load_int(&barrier[HT_STATE_STOP]) != n_threads)
@ -436,10 +428,10 @@ main(int argc, char *argv[])
ck_pr_store_int(&state, HT_STATE_STRICT_REPLACEMENT);
while (ck_pr_load_int(&barrier[HT_STATE_GET]) != n_threads)
ck_pr_stall();
fprintf(stderr, "done (reader = %" PRIu64 " ticks)\n",
ck_error("done (reader = %" PRIu64 " ticks)\n",
accumulator[HT_STATE_GET] / n_threads);
fprintf(stderr, " | Executing strict replacement test...");
ck_error(" | Executing strict replacement test...");
a = repeated = 0;
signal(SIGALRM, alarm_handler);
@ -465,13 +457,13 @@ main(int argc, char *argv[])
ck_pr_stall();
table_reset();
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HT_STATE_STRICT_REPLACEMENT] / n_threads);
signal(SIGALRM, alarm_handler);
alarm(r);
fprintf(stderr, " | Executing deletion test (%.2f)...", p_d * 100);
ck_error(" | Executing deletion test (%.2f)...", p_d * 100);
a = repeated = 0;
ck_pr_inc_int(&barrier[HT_STATE_STRICT_REPLACEMENT]);
for (;;) {
@ -501,13 +493,13 @@ main(int argc, char *argv[])
table_reset();
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HT_STATE_DELETION] / n_threads);
signal(SIGALRM, alarm_handler);
alarm(r);
fprintf(stderr, " | Executing replacement test (%.2f)...", p_r * 100);
ck_error(" | Executing replacement test (%.2f)...", p_r * 100);
a = repeated = 0;
ck_pr_inc_int(&barrier[HT_STATE_DELETION]);
for (;;) {
@ -541,14 +533,14 @@ main(int argc, char *argv[])
ck_pr_stall();
table_reset();
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HT_STATE_REPLACEMENT] / n_threads);
ck_pr_inc_int(&barrier[HT_STATE_REPLACEMENT]);
epoch_temporary = epoch_wr;
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, " '- Summary: %u pending, %u peak, %lu reclamations -> "
ck_error(" '- Summary: %u pending, %u peak, %lu reclamations -> "
"%u pending, %u peak, %lu reclamations\n\n",
epoch_temporary.n_pending, epoch_temporary.n_peak, epoch_temporary.n_dispatch,
epoch_wr.n_pending, epoch_wr.n_peak, epoch_wr.n_dispatch);

70
regressions/ck_ht/benchmark/parallel_direct.c
Unescape View File

@ -237,9 +237,8 @@ ht_reader(void *unused)
if (r == keys[i])
continue;
fprintf(stderr, "ERROR: Found invalid value: [%ju]\n",
ck_error("ERROR: Found invalid value: [%ju]\n",
(uintmax_t)r);
exit(EXIT_FAILURE);
}
a += rdtsc() - s;
ck_epoch_end(&epoch_ht, &epoch_record);
@ -275,9 +274,8 @@ main(int argc, char *argv[])
n_threads = CORES - 1;
if (argc < 2) {
fprintf(stderr, "Usage: parallel <#entries> [<interval length> <initial size> <readers>\n"
ck_error("Usage: parallel <#entries> [<interval length> <initial size> <readers>\n"
" <probability of replacement> <probability of deletion> <epoch threshold>]\n");
exit(EXIT_FAILURE);
}
if (argc >= 3)
@ -289,24 +287,21 @@ main(int argc, char *argv[])
if (argc >= 5) {
n_threads = atoi(argv[4]);
if (n_threads < 1) {
fprintf(stderr, "ERROR: Number of readers must be >= 1.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of readers must be >= 1.\n");
}
}
if (argc >= 6) {
p_r = atof(argv[5]) / 100.00;
if (p_r < 0) {
fprintf(stderr, "ERROR: Probability of replacement must be >= 0 and <= 100.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Probability of replacement must be >= 0 and <= 100.\n");
}
}
if (argc >= 7) {
p_d = atof(argv[6]) / 100.00;
if (p_d < 0) {
fprintf(stderr, "ERROR: Probability of deletion must be >= 0 and <= 100.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Probability of deletion must be >= 0 and <= 100.\n");
}
}
@ -328,24 +323,22 @@ main(int argc, char *argv[])
for (i = 0; i < (size_t)n_threads; i++) {
if (pthread_create(&readers[i], NULL, ht_reader, NULL) != 0) {
fprintf(stderr, "ERROR: Failed to create thread %zu.\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to create thread %zu.\n", i);
}
}
for (i = 0; i < keys_length; i++)
d += table_insert(keys[i]) == false;
fprintf(stderr, " [S] %zu entries stored and %u duplicates.\n\n",
ck_error(" [S] %zu entries stored and %u duplicates.\n\n",
table_count(), d);
fprintf(stderr, " ,- BASIC TEST\n");
fprintf(stderr, " | Executing SMR test...");
ck_error(" ,- BASIC TEST\n");
ck_error(" | Executing SMR test...");
a = 0;
for (j = 0; j < r; j++) {
if (table_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -354,9 +347,9 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing replacement test...");
ck_error(" | Executing replacement test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
@ -365,25 +358,24 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing get test...");
ck_error(" | Executing get test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
for (i = 0; i < keys_length; i++) {
if (table_get(keys[i]) == 0) {
fprintf(stderr, "ERROR: Unexpected 0 value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected 0 value.\n");
}
}
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
a = 0;
fprintf(stderr, " | Executing removal test...");
ck_error(" | Executing removal test...");
for (j = 0; j < r; j++) {
s = rdtsc();
for (i = 0; i < keys_length; i++)
@ -394,9 +386,9 @@ main(int argc, char *argv[])
for (i = 0; i < keys_length; i++)
table_insert(keys[i]);
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
fprintf(stderr, " | Executing negative look-up test...");
ck_error(" | Executing negative look-up test...");
a = 0;
for (j = 0; j < r; j++) {
s = rdtsc();
@ -406,18 +398,18 @@ main(int argc, char *argv[])
e = rdtsc();
a += e - s;
}
fprintf(stderr, "done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_error("done (%" PRIu64 " ticks)\n", a / (r * keys_length));
ck_epoch_record_t epoch_temporary = epoch_wr;
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, " '- Summary: %u pending, %u peak, %lu reclamations -> "
ck_error(" '- Summary: %u pending, %u peak, %lu reclamations -> "
"%u pending, %u peak, %lu reclamations\n\n",
epoch_temporary.n_pending, epoch_temporary.n_peak, epoch_temporary.n_dispatch,
epoch_wr.n_pending, epoch_wr.n_peak, epoch_wr.n_dispatch);
fprintf(stderr, " ,- READER CONCURRENCY\n");
fprintf(stderr, " | Executing reader test...");
ck_error(" ,- READER CONCURRENCY\n");
ck_error(" | Executing reader test...");
ck_pr_store_int(&state, HT_STATE_GET);
while (ck_pr_load_int(&barrier[HT_STATE_STOP]) != n_threads)
@ -427,10 +419,10 @@ main(int argc, char *argv[])
ck_pr_store_int(&state, HT_STATE_STRICT_REPLACEMENT);
while (ck_pr_load_int(&barrier[HT_STATE_GET]) != n_threads)
ck_pr_stall();
fprintf(stderr, "done (reader = %" PRIu64 " ticks)\n",
ck_error("done (reader = %" PRIu64 " ticks)\n",
accumulator[HT_STATE_GET] / n_threads);
fprintf(stderr, " | Executing strict replacement test...");
ck_error(" | Executing strict replacement test...");
a = repeated = 0;
signal(SIGALRM, alarm_handler);
@ -456,13 +448,13 @@ main(int argc, char *argv[])
ck_pr_stall();
table_reset();
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HT_STATE_STRICT_REPLACEMENT] / n_threads);
signal(SIGALRM, alarm_handler);
alarm(r);
fprintf(stderr, " | Executing deletion test (%.2f)...", p_d * 100);
ck_error(" | Executing deletion test (%.2f)...", p_d * 100);
a = repeated = 0;
ck_pr_inc_int(&barrier[HT_STATE_STRICT_REPLACEMENT]);
for (;;) {
@ -492,13 +484,13 @@ main(int argc, char *argv[])
table_reset();
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HT_STATE_DELETION] / n_threads);
signal(SIGALRM, alarm_handler);
alarm(r);
fprintf(stderr, " | Executing replacement test (%.2f)...", p_r * 100);
ck_error(" | Executing replacement test (%.2f)...", p_r * 100);
a = repeated = 0;
ck_pr_inc_int(&barrier[HT_STATE_DELETION]);
for (;;) {
@ -532,14 +524,14 @@ main(int argc, char *argv[])
ck_pr_stall();
table_reset();
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, "done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
ck_error("done (writer = %" PRIu64 " ticks, reader = %" PRIu64 " ticks)\n",
a / (repeated * keys_length), accumulator[HT_STATE_REPLACEMENT] / n_threads);
ck_pr_inc_int(&barrier[HT_STATE_REPLACEMENT]);
epoch_temporary = epoch_wr;
ck_epoch_synchronize(&epoch_ht, &epoch_wr);
fprintf(stderr, " '- Summary: %u pending, %u peak, %lu reclamations -> "
ck_error(" '- Summary: %u pending, %u peak, %lu reclamations -> "
"%u pending, %u peak, %lu reclamations\n\n",
epoch_temporary.n_pending, epoch_temporary.n_peak, epoch_temporary.n_dispatch,
epoch_wr.n_pending, epoch_wr.n_peak, epoch_wr.n_dispatch);

25
regressions/ck_ht/benchmark/serial.c
Unescape View File

@ -183,8 +183,7 @@ main(int argc, char *argv[])
srand(time(NULL));
if (argc < 2) {
fprintf(stderr, "Usage: ck_ht <dictionary> [<repetitions> <initial size>]\n");
exit(EXIT_FAILURE);
ck_error("Usage: ck_ht <dictionary> [<repetitions> <initial size>]\n");
}
if (argc >= 3)
@ -221,16 +220,15 @@ main(int argc, char *argv[])
d += table_insert(keys[i]) == false;
ck_ht_stat(&ht, &st);
fprintf(stderr, "# %zu entries stored, %u duplicates, %" PRIu64 " probe.\n",
ck_error("# %zu entries stored, %u duplicates, %" PRIu64 " probe.\n",
table_count(), d, st.probe_maximum);
fprintf(stderr, "# reverse_insertion serial_insertion random_insertion serial_replace reverse_get serial_get random_get serial_remove negative_get\n\n");
ck_error("# reverse_insertion serial_insertion random_insertion serial_replace reverse_get serial_get random_get serial_remove negative_get\n\n");
a = 0;
for (j = 0; j < r; j++) {
if (table_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -244,8 +242,7 @@ main(int argc, char *argv[])
a = 0;
for (j = 0; j < r; j++) {
if (table_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -261,8 +258,7 @@ main(int argc, char *argv[])
keys_shuffle(keys);
if (table_reset() == false) {
fprintf(stderr, "ERROR: Failed to reset hash table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to reset hash table.\n");
}
s = rdtsc();
@ -292,8 +288,7 @@ main(int argc, char *argv[])
s = rdtsc();
for (i = keys_length; i > 0; i--) {
if (table_get(keys[i - 1]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();
@ -306,8 +301,7 @@ main(int argc, char *argv[])
s = rdtsc();
for (i = 0; i < keys_length; i++) {
if (table_get(keys[i]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();
@ -322,8 +316,7 @@ main(int argc, char *argv[])
s = rdtsc();
for (i = 0; i < keys_length; i++) {
if (table_get(keys[i]) == NULL) {
fprintf(stderr, "ERROR: Unexpected NULL value.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Unexpected NULL value.\n");
}
}
e = rdtsc();

49
regressions/ck_ht/validate/serial.c
Unescape View File

@ -33,6 +33,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../../common.h"
static void *
ht_malloc(size_t r)
@ -99,7 +100,7 @@ main(void)
ck_ht_hash(&h, &ht, test[i], l);
ck_ht_entry_key_set(&entry, test[i], l);
if (ck_ht_get_spmc(&ht, h, &entry) == false) {
fprintf(stderr, "ERROR (put): Failed to find [%s]\n", test[i]);
ck_error("ERROR (put): Failed to find [%s]\n", test[i]);
} else {
void *k, *v;
@ -107,7 +108,7 @@ main(void)
v = ck_ht_entry_value(&entry);
if (strcmp(k, test[i]) || strcmp(v, test[i])) {
fprintf(stderr, "ERROR: Mismatch: (%s, %s) != (%s, %s)\n",
ck_error("ERROR: Mismatch: (%s, %s) != (%s, %s)\n",
(char *)k, (char *)v, test[i], test[i]);
}
}
@ -116,7 +117,7 @@ main(void)
ck_ht_hash(&h, &ht, negative, strlen(negative));
ck_ht_entry_key_set(&entry, negative, strlen(negative));
if (ck_ht_get_spmc(&ht, h, &entry) == true) {
fprintf(stderr, "ERROR: Found non-existing entry.\n");
ck_error("ERROR: Found non-existing entry.\n");
}
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
@ -128,27 +129,24 @@ main(void)
continue;
if (ck_ht_remove_spmc(&ht, h, &entry) == false) {
fprintf(stderr, "ERROR: Failed to delete existing entry\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to delete existing entry\n");
}
if (ck_ht_get_spmc(&ht, h, &entry) == true)
fprintf(stderr, "ERROR: Able to find [%s] after delete\n", test[i]);
ck_error("ERROR: Able to find [%s] after delete\n", test[i]);
ck_ht_entry_set(&entry, h, test[i], l, test[i]);
if (ck_ht_put_spmc(&ht, h, &entry) == false)
fprintf(stderr, "ERROR: Failed to insert [%s]\n", test[i]);
ck_error("ERROR: Failed to insert [%s]\n", test[i]);
if (ck_ht_remove_spmc(&ht, h, &entry) == false) {
fprintf(stderr, "ERROR: Failed to delete existing entry\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to delete existing entry\n");
}
}
ck_ht_reset_spmc(&ht);
if (ck_ht_count(&ht) != 0) {
fprintf(stderr, "ERROR: Map was not reset.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Map was not reset.\n");
}
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
@ -160,8 +158,7 @@ main(void)
for (i = 0; ck_ht_next(&ht, &iterator, &cursor) == true; i++);
if (i != 42) {
fprintf(stderr, "ERROR: Incorrect number of entries in table.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Incorrect number of entries in table.\n");
}
for (i = 0; i < sizeof(test) / sizeof(*test); i++) {
@ -176,7 +173,7 @@ main(void)
ck_ht_hash(&h, &ht, test[i], l);
ck_ht_entry_key_set(&entry, test[i], l);
if (ck_ht_get_spmc(&ht, h, &entry) == false) {
fprintf(stderr, "ERROR (set): Failed to find [%s]\n", test[i]);
ck_error("ERROR (set): Failed to find [%s]\n", test[i]);
} else {
void *k, *v;
@ -184,7 +181,7 @@ main(void)
v = ck_ht_entry_value(&entry);
if (strcmp(k, test[i]) || strcmp(v, test[i])) {
fprintf(stderr, "ERROR: Mismatch: (%s, %s) != (%s, %s)\n",
ck_error("ERROR: Mismatch: (%s, %s) != (%s, %s)\n",
(char *)k, (char *)v, test[i], test[i]);
}
}
@ -203,19 +200,17 @@ main(void)
continue;
if (strcmp(ck_ht_entry_value(&entry), test[i]) != 0) {
fprintf(stderr, "Mismatch detected: %s, expected %s\n",
ck_error("Mismatch detected: %s, expected %s\n",
(char *)ck_ht_entry_value(&entry),
test[i]);
exit(EXIT_FAILURE);
}
}
ck_ht_iterator_init(&iterator);
while (ck_ht_next(&ht, &iterator, &cursor) == true) {
if (strcmp(ck_ht_entry_value(cursor), "REPLACED") != 0) {
fprintf(stderr, "Mismatch detected: %s, expected REPLACED\n",
ck_error("Mismatch detected: %s, expected REPLACED\n",
(char *)ck_ht_entry_value(cursor));
exit(EXIT_FAILURE);
}
}
@ -228,20 +223,18 @@ main(void)
continue;
if (ck_ht_remove_spmc(&ht, h, &entry) == false) {
fprintf(stderr, "ERROR: Failed to delete existing entry\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to delete existing entry\n");
}
if (ck_ht_get_spmc(&ht, h, &entry) == true)
fprintf(stderr, "ERROR: Able to find [%s] after delete\n", test[i]);
ck_error("ERROR: Able to find [%s] after delete\n", test[i]);
ck_ht_entry_set(&entry, h, test[i], l, test[i]);
if (ck_ht_put_spmc(&ht, h, &entry) == false)
fprintf(stderr, "ERROR: Failed to insert [%s]\n", test[i]);
ck_error("ERROR: Failed to insert [%s]\n", test[i]);
if (ck_ht_remove_spmc(&ht, h, &entry) == false) {
fprintf(stderr, "ERROR: Failed to delete existing entry\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to delete existing entry\n");
}
}
@ -259,8 +252,7 @@ main(void)
}
if (l != 7) {
fprintf(stderr, "ERROR: Got %zu failures rather than 7\n", l);
exit(EXIT_FAILURE);
ck_error("ERROR: Got %zu failures rather than 7\n", l);
}
for (i = 0; i < sizeof(direct) / sizeof(*direct); i++) {
@ -272,9 +264,8 @@ main(void)
ck_ht_iterator_init(&iterator);
while (ck_ht_next(&ht, &iterator, &cursor) == true) {
if (strcmp(ck_ht_entry_value(cursor), "REPLACED") != 0) {
fprintf(stderr, "Mismatch detected: %s, expected REPLACED\n",
ck_error("Mismatch detected: %s, expected REPLACED\n",
(char *)ck_ht_entry_value(cursor));
exit(EXIT_FAILURE);
}
}

20
regressions/ck_pr/benchmark/benchmark.h
Unescape View File

@ -60,25 +60,25 @@ main(int argc, char *argv[])
struct block *context;
if (argc != 3) {
fprintf(stderr, "Usage: " ATOMIC_STRING " <number of threads> <affinity delta>\n");
ck_error("Usage: " ATOMIC_STRING " <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
ck_error("ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
ck_error("ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
}
context = malloc(sizeof(struct block) * nthr);
if (context == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread contexts\n");
ck_error("ERROR: Could not allocate thread contexts\n");
exit(EXIT_FAILURE);
}
@ -87,29 +87,29 @@ main(int argc, char *argv[])
count = malloc(sizeof(uint64_t) * nthr);
if (count == NULL) {
fprintf(stderr, "ERROR: Could not create acquisition buffer\n");
ck_error("ERROR: Could not create acquisition buffer\n");
exit(EXIT_FAILURE);
}
memset(count, 0, sizeof(uint64_t) * nthr);
fprintf(stderr, "Creating threads (fairness)...");
ck_error("Creating threads (fairness)...");
for (i = 0; i < nthr; i++) {
context[i].tid = i;
if (pthread_create(&threads[i], NULL, fairness, context + i)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
ck_error("ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
ck_pr_store_uint(&ready, 1);
sleep(10);
ck_pr_store_uint(&ready, 0);
fprintf(stderr, "Waiting for threads to finish acquisition regression...");
ck_error("Waiting for threads to finish acquisition regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done\n\n");
ck_error("done\n\n");
for (i = 0, v = 0; i < nthr; i++) {
printf("%d %15" PRIu64 "\n", i, count[i]);

3
regressions/ck_pr/benchmark/ck_pr_fas_64.c
Unescape View File

@ -11,6 +11,7 @@
int
main(void)
{
exit(EXIT_FAILURE);
return 0;
}
#endif

34
regressions/ck_queue/validate/ck_list.c
Unescape View File

@ -57,16 +57,14 @@ test_foreach(void)
s = s - 1;
if (n->value != s) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, n->value);
exit(EXIT_FAILURE);
}
next = CK_LIST_NEXT(n, list_entry);
if (next != NULL && next->value != s - 1) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, next->value);
exit(EXIT_FAILURE);
}
i--;
@ -85,16 +83,14 @@ test_foreach(void)
s = s - 1;
if (n->value != s) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, n->value);
exit(EXIT_FAILURE);
}
next = CK_LIST_NEXT(n, list_entry);
if (next != NULL && next->value != s - 1) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, next->value);
exit(EXIT_FAILURE);
}
i--;
@ -104,7 +100,7 @@ test_foreach(void)
break;
}
fprintf(stderr, "(%d, %d) ", j, k);
ck_error("(%d, %d) ", j, k);
return;
}
@ -126,14 +122,12 @@ main(int argc, char *argv[])
int n_threads, i;
if (argc != 3) {
fprintf(stderr, "Usage: %s <number of threads> <number of list entries>\n", argv[0]);
exit(EXIT_FAILURE);
ck_error("Usage: %s <number of threads> <number of list entries>\n", argv[0]);
}
n_threads = atoi(argv[1]);
if (n_threads < 1) {
fprintf(stderr, "ERROR: Number of threads must be >= 1.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be >= 1.\n");
}
thread = malloc(sizeof(pthread_t) * n_threads);
@ -141,11 +135,10 @@ main(int argc, char *argv[])
goal = atoi(argv[2]);
if (goal < 4) {
fprintf(stderr, "ERROR: Number of entries must be >= 4.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of entries must be >= 4.\n");
}
fprintf(stderr, "Beginning serial test...");
ck_error("Beginning serial test...");
CK_LIST_INIT(&head);
for (i = 1; i <= goal; i++) {
@ -164,13 +157,12 @@ main(int argc, char *argv[])
}
if (CK_LIST_EMPTY(&head) == false) {
fprintf(stderr, "List is not empty after bulk removal.\n");
exit(EXIT_FAILURE);
ck_error("List is not empty after bulk removal.\n");
}
fprintf(stderr, "done (success)\n");
ck_error("done (success)\n");
fprintf(stderr, "Beginning parallel traversal...");
ck_error("Beginning parallel traversal...");
n = malloc(sizeof *n);
assert(n != NULL);
@ -216,7 +208,7 @@ main(int argc, char *argv[])
for (i = 0; i < n_threads; i++)
pthread_join(thread[i], NULL);
fprintf(stderr, "done (success)\n");
ck_error("done (success)\n");
return (0);
}

34
regressions/ck_queue/validate/ck_slist.c
Unescape View File

@ -57,16 +57,14 @@ test_foreach(void)
s = s - 1;
if (n->value != s) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, n->value);
exit(EXIT_FAILURE);
}
next = CK_SLIST_NEXT(n, list_entry);
if (next != NULL && next->value != s - 1) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, next->value);
exit(EXIT_FAILURE);
}
i--;
@ -85,16 +83,14 @@ test_foreach(void)
s = s - 1;
if (n->value != s) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, n->value);
exit(EXIT_FAILURE);
}
next = CK_SLIST_NEXT(n, list_entry);
if (next != NULL && next->value != s - 1) {
fprintf(stderr, "\nExpected %d, but got %d.\n",
ck_error("\nExpected %d, but got %d.\n",
s, next->value);
exit(EXIT_FAILURE);
}
i--;
@ -104,7 +100,7 @@ test_foreach(void)
break;
}
fprintf(stderr, "(%d, %d) ", j, k);
ck_error("(%d, %d) ", j, k);
return;
}
@ -126,14 +122,12 @@ main(int argc, char *argv[])
int n_threads, i;
if (argc != 3) {
fprintf(stderr, "Usage: %s <number of threads> <number of list entries>\n", argv[0]);
exit(EXIT_FAILURE);
ck_error("Usage: %s <number of threads> <number of list entries>\n", argv[0]);
}
n_threads = atoi(argv[1]);
if (n_threads < 1) {
fprintf(stderr, "ERROR: Number of threads must be >= 1.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be >= 1.\n");
}
thread = malloc(sizeof(pthread_t) * n_threads);
@ -141,11 +135,10 @@ main(int argc, char *argv[])
goal = atoi(argv[2]);
if (goal < 4) {
fprintf(stderr, "ERROR: Number of entries must be >= 4.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of entries must be >= 4.\n");
}
fprintf(stderr, "Beginning serial test...");
ck_error("Beginning serial test...");
CK_SLIST_INIT(&head);
for (i = 1; i <= goal; i++) {
@ -164,13 +157,12 @@ main(int argc, char *argv[])
}
if (CK_SLIST_EMPTY(&head) == false) {
fprintf(stderr, "List is not empty after bulk removal.\n");
exit(EXIT_FAILURE);
ck_error("List is not empty after bulk removal.\n");
}
fprintf(stderr, "done (success)\n");
ck_error("done (success)\n");
fprintf(stderr, "Beginning parallel traversal...");
ck_error("Beginning parallel traversal...");
n = malloc(sizeof *n);
assert(n != NULL);
@ -219,7 +211,7 @@ main(int argc, char *argv[])
for (i = 0; i < n_threads; i++)
pthread_join(thread[i], NULL);
fprintf(stderr, "done (success)\n");
ck_error("done (success)\n");
return (0);
}

9
regressions/ck_ring/benchmark/latency.c
Unescape View File

@ -26,20 +26,17 @@ main(int argc, char *argv[])
struct entry entry = {0, 0};
if (argc != 2) {
fprintf(stderr, "Usage: latency <size>\n");
exit(EXIT_FAILURE);
ck_error("Usage: latency <size>\n");
}
size = atoi(argv[1]);
if (size <= 4 || (size & (size - 1))) {
fprintf(stderr, "ERROR: Size must be a power of 2 greater than 4.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Size must be a power of 2 greater than 4.\n");
}
buffer = malloc(sizeof(struct entry) * size);
if (buffer == NULL) {
fprintf(stderr, "ERROR: Failed to allocate buffer\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to allocate buffer\n");
}
CK_RING_INIT(entry_ring, &ring, buffer, size);

32
regressions/ck_ring/validate/ck_ring_spmc.c
Unescape View File

@ -89,9 +89,8 @@ test_spmc(void *c)
|| o->value != o->tid
|| o->magic != 0xdead
|| (previous != 0 && previous >= o->value_long)) {
fprintf(stderr, "[0x%p] (%x) (%d, %d) >< (0, %d)\n",
ck_error("[0x%p] (%x) (%d, %d) >< (0, %d)\n",
(void *)o, o->magic, o->tid, o->value, size);
exit(EXIT_FAILURE);
}
o->magic = 0xbeef;
@ -100,15 +99,14 @@ test_spmc(void *c)
previous = o->value_long;
if (ck_pr_faa_uint(&o->ref, 1) != 0) {
fprintf(stderr, "[%p] We dequeued twice.\n", (void *)o);
exit(EXIT_FAILURE);
ck_error("[%p] We dequeued twice.\n", (void *)o);
}
free(o);
}
}
fprintf(stderr, "[%d] Observed %u\n", tid, observed);
ck_error("[%d] Observed %u\n", tid, observed);
return NULL;
}
@ -132,9 +130,8 @@ test(void *c)
assert(entries != NULL);
if (ck_ring_size(ring) != 0) {
fprintf(stderr, "More entries than expected: %u > 0\n",
ck_error("More entries than expected: %u > 0\n",
ck_ring_size(ring));
exit(EXIT_FAILURE);
}
for (i = 0; i < size; i++) {
@ -146,15 +143,13 @@ test(void *c)
}
if (ck_ring_size(ring) != (unsigned int)size) {
fprintf(stderr, "Less entries than expected: %u < %d\n",
ck_error("Less entries than expected: %u < %d\n",
ck_ring_size(ring), size);
exit(EXIT_FAILURE);
}
if (ck_ring_capacity(ring) != ck_ring_size(ring) + 1) {
fprintf(stderr, "Capacity less than expected: %u < %u\n",
ck_error("Capacity less than expected: %u < %u\n",
ck_ring_size(ring), ck_ring_capacity(ring));
exit(EXIT_FAILURE);
}
barrier = 1;
@ -167,15 +162,13 @@ test(void *c)
while (ck_ring_dequeue_spmc(ring + context->previous, &entry) == false);
if (context->previous != (unsigned int)entry->tid) {
fprintf(stderr, "[%u:%p] %u != %u\n",
ck_error("[%u:%p] %u != %u\n",
context->tid, (void *)entry, entry->tid, context->previous);
exit(EXIT_FAILURE);
}
if (entry->value < 0 || entry->value >= size) {
fprintf(stderr, "[%u:%p] %u </> %u\n",
ck_error("[%u:%p] %u </> %u\n",
context->tid, (void *)entry, entry->tid, context->previous);
exit(EXIT_FAILURE);
}
entry->tid = context->tid;
@ -197,8 +190,7 @@ main(int argc, char *argv[])
pthread_t *thread;
if (argc != 4) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <threads> <affinity delta> <size>\n");
}
a.request = 0;
@ -220,7 +212,7 @@ main(int argc, char *argv[])
thread = malloc(sizeof(pthread_t) * nthr);
assert(thread);
fprintf(stderr, "SPSC test:");
ck_error("SPSC test:");
for (i = 0; i < nthr; i++) {
context[i].tid = i;
if (i == 0) {
@ -244,9 +236,9 @@ main(int argc, char *argv[])
for (i = 0; i < nthr; i++)
pthread_join(thread[i], NULL);
fprintf(stderr, " done\n");
ck_error(" done\n");
fprintf(stderr, "SPMC test:\n");
ck_error("SPMC test:\n");
buffer = malloc(sizeof(void *) * (size + 1));
assert(buffer);
memset(buffer, 0, sizeof(void *) * (size + 1));

32
regressions/ck_ring/validate/ck_ring_spmc_template.c
Unescape View File

@ -90,9 +90,8 @@ test_spmc(void *c)
|| o.value != o.tid
|| o.magic != 0xdead
|| (previous != 0 && previous >= o.value_long)) {
fprintf(stderr, "(%x) (%d, %d) >< (0, %d)\n",
ck_error("(%x) (%d, %d) >< (0, %d)\n",
o.magic, o.tid, o.value, size);
exit(EXIT_FAILURE);
}
o.magic = 0xbeef;
@ -101,13 +100,12 @@ test_spmc(void *c)
previous = o.value_long;
if (ck_pr_faa_uint(&o.ref, 1) != 0) {
fprintf(stderr, "We dequeued twice.\n");
exit(EXIT_FAILURE);
ck_error("We dequeued twice.\n");
}
}
}
fprintf(stderr, "[%d] Observed %u\n", tid, observed);
ck_error("[%d] Observed %u\n", tid, observed);
return NULL;
}
@ -126,9 +124,8 @@ test(void *c)
if (context->tid == 0) {
if (CK_RING_SIZE(spmc_ring, ring) != 0) {
fprintf(stderr, "More entries than expected: %u > 0\n",
ck_error("More entries than expected: %u > 0\n",
CK_RING_SIZE(spmc_ring, ring));
exit(EXIT_FAILURE);
}
for (i = 0; i < size; i++) {
@ -140,15 +137,13 @@ test(void *c)
}
if (CK_RING_SIZE(spmc_ring, ring) != (unsigned int)size) {
fprintf(stderr, "Less entries than expected: %u < %d\n",
ck_error("Less entries than expected: %u < %d\n",
CK_RING_SIZE(spmc_ring, ring), size);
exit(EXIT_FAILURE);
}
if (CK_RING_CAPACITY(spmc_ring, ring) != CK_RING_SIZE(spmc_ring, ring) + 1) {
fprintf(stderr, "Capacity less than expected: %u < %u\n",
ck_error("Capacity less than expected: %u < %u\n",
CK_RING_SIZE(spmc_ring, ring), CK_RING_CAPACITY(spmc_ring, ring));
exit(EXIT_FAILURE);
}
barrier = 1;
@ -161,15 +156,13 @@ test(void *c)
while (CK_RING_DEQUEUE_SPMC(spmc_ring, ring + context->previous, &entry) == false);
if (context->previous != (unsigned int)entry.tid) {
fprintf(stderr, "[%u] %u != %u\n",
ck_error("[%u] %u != %u\n",
context->tid, entry.tid, context->previous);
exit(EXIT_FAILURE);
}
if (entry.value < 0 || entry.value >= size) {
fprintf(stderr, "[%u] %u </> %u\n",
ck_error("[%u] %u </> %u\n",
context->tid, entry.tid, context->previous);
exit(EXIT_FAILURE);
}
entry.tid = context->tid;
@ -191,8 +184,7 @@ main(int argc, char *argv[])
pthread_t *thread;
if (argc != 4) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <threads> <affinity delta> <size>\n");
}
a.request = 0;
@ -214,7 +206,7 @@ main(int argc, char *argv[])
thread = malloc(sizeof(pthread_t) * nthr);
assert(thread);
fprintf(stderr, "SPSC test:");
ck_error("SPSC test:");
for (i = 0; i < nthr; i++) {
context[i].tid = i;
if (i == 0) {
@ -238,9 +230,9 @@ main(int argc, char *argv[])
for (i = 0; i < nthr; i++)
pthread_join(thread[i], NULL);
fprintf(stderr, " done\n");
ck_error(" done\n");
fprintf(stderr, "SPMC test:\n");
ck_error("SPMC test:\n");
buffer = malloc(sizeof(struct entry) * (size + 1));
assert(buffer);
memset(buffer, 0, sizeof(struct entry) * (size + 1));

18
regressions/ck_ring/validate/ck_ring_spsc.c
Unescape View File

@ -73,9 +73,8 @@ test(void *c)
assert(entries != NULL);
if (ck_ring_size(ring) != 0) {
fprintf(stderr, "More entries than expected: %u > 0\n",
ck_error("More entries than expected: %u > 0\n",
ck_ring_size(ring));
exit(EXIT_FAILURE);
}
for (i = 0; i < size; i++) {
@ -87,15 +86,13 @@ test(void *c)
}
if (ck_ring_size(ring) != (unsigned int)size) {
fprintf(stderr, "Less entries than expected: %u < %d\n",
ck_error("Less entries than expected: %u < %d\n",
ck_ring_size(ring), size);
exit(EXIT_FAILURE);
}
if (ck_ring_capacity(ring) != ck_ring_size(ring) + 1) {
fprintf(stderr, "Capacity less than expected: %u < %u\n",
ck_error("Capacity less than expected: %u < %u\n",
ck_ring_size(ring), ck_ring_capacity(ring));
exit(EXIT_FAILURE);
}
barrier = 1;
@ -108,15 +105,13 @@ test(void *c)
while (ck_ring_dequeue_spsc(ring + context->previous, &entry) == false);
if (context->previous != (unsigned int)entry->tid) {
fprintf(stderr, "[%u:%p] %u != %u\n",
ck_error("[%u:%p] %u != %u\n",
context->tid, (void *)entry, entry->tid, context->previous);
exit(EXIT_FAILURE);
}
if (entry->value != j) {
fprintf(stderr, "[%u:%p] %u != %u\n",
ck_error("[%u:%p] %u != %u\n",
context->tid, (void *)entry, entry->tid, context->previous);
exit(EXIT_FAILURE);
}
entry->tid = context->tid;
@ -137,8 +132,7 @@ main(int argc, char *argv[])
pthread_t *thread;
if (argc != 4) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <threads> <affinity delta> <size>\n");
}
a.request = 0;

15
regressions/ck_ring/validate/ck_ring_spsc_template.c
Unescape View File

@ -74,9 +74,8 @@ test(void *c)
assert(entries != NULL);
if (CK_RING_SIZE(entry_ring, ring) != 0) {
fprintf(stderr, "Ring should be empty: %u\n",
ck_error("Ring should be empty: %u\n",
CK_RING_SIZE(entry_ring, ring));
exit(EXIT_FAILURE);
}
for (i = 0; i < size; i++) {
@ -88,10 +87,9 @@ test(void *c)
if (CK_RING_SIZE(entry_ring, ring) !=
CK_RING_CAPACITY(entry_ring, ring) - 1) {
fprintf(stderr, "Ring has incorrect size or capacity: %u != %u\n",
ck_error("Ring has incorrect size or capacity: %u != %u\n",
CK_RING_SIZE(entry_ring, ring),
CK_RING_CAPACITY(entry_ring, ring));
exit(EXIT_FAILURE);
}
barrier = 1;
@ -104,15 +102,13 @@ test(void *c)
while (CK_RING_DEQUEUE_SPSC(entry_ring, ring + context->previous, &entry) == false);
if (context->previous != (unsigned int)entry.tid) {
fprintf(stderr, "[%u] %u != %u\n",
ck_error("[%u] %u != %u\n",
context->tid, entry.tid, context->previous);
exit(EXIT_FAILURE);
}
if (entry.value != j) {
fprintf(stderr, "[%u] %u != %u\n",
ck_error("[%u] %u != %u\n",
context->tid, entry.tid, context->previous);
exit(EXIT_FAILURE);
}
entry.tid = context->tid;
@ -133,8 +129,7 @@ main(int argc, char *argv[])
pthread_t *thread;
if (argc != 4) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <threads> <affinity delta> <size>\n");
}
a.request = 0;

23
regressions/ck_rwlock/benchmark/throughput.c
Unescape View File

@ -117,47 +117,42 @@ main(int argc, char *argv[])
uint64_t *latency;
if (argc != 3) {
fprintf(stderr, "Usage: throughput <delta> <threads>\n");
exit(EXIT_FAILURE);
ck_error("Usage: throughput <delta> <threads>\n");
}
threads = atoi(argv[2]);
if (threads <= 0) {
fprintf(stderr, "ERROR: Threads must be a value > 0.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Threads must be a value > 0.\n");
}
p = malloc(sizeof(pthread_t) * threads);
if (p == NULL) {
fprintf(stderr, "ERROR: Failed to initialize thread.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to initialize thread.\n");
}
latency = malloc(sizeof(uint64_t) * threads);
if (latency == NULL) {
fprintf(stderr, "ERROR: Failed to create latency buffer.\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to create latency buffer.\n");
}
affinity.delta = atoi(argv[1]);
affinity.request = 0;
fprintf(stderr, "Creating threads (rwlock)...");
ck_error("Creating threads (rwlock)...");
for (t = 0; t < threads; t++) {
if (pthread_create(&p[t], NULL, thread_rwlock, latency + t) != 0) {
fprintf(stderr, "ERROR: Could not create thread %d\n", t);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", t);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
sleep(10);
ck_pr_store_uint(&flag, 1);
fprintf(stderr, "Waiting for threads to finish acquisition regression...");
ck_error("Waiting for threads to finish acquisition regression...");
for (t = 0; t < threads; t++)
pthread_join(p[t], NULL);
fprintf(stderr, "done\n\n");
ck_error("done\n\n");
for (t = 1; t <= threads; t++)
printf("%10u %20" PRIu64 "\n", t, latency[t - 1]);

55
regressions/ck_rwlock/validate/validate.c
Unescape View File

@ -74,8 +74,7 @@ thread_recursive(void *null CK_CC_UNUSED)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
ck_pr_inc_uint(&locked);
@ -89,8 +88,7 @@ thread_recursive(void *null CK_CC_UNUSED)
l = ck_pr_load_uint(&locked);
if (l != 8) {
fprintf(stderr, "ERROR [WR:%d]: %u != 2\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
}
ck_pr_dec_uint(&locked);
@ -104,8 +102,7 @@ thread_recursive(void *null CK_CC_UNUSED)
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
}
ck_rwlock_recursive_write_unlock(&r_lock);
@ -117,8 +114,7 @@ thread_recursive(void *null CK_CC_UNUSED)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [RD:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
}
}
ck_rwlock_recursive_read_unlock(&r_lock);
@ -143,8 +139,7 @@ thread(void *null CK_CC_UNUSED)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
ck_pr_inc_uint(&locked);
@ -158,8 +153,7 @@ thread(void *null CK_CC_UNUSED)
l = ck_pr_load_uint(&locked);
if (l != 8) {
fprintf(stderr, "ERROR [WR:%d]: %u != 2\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 2\n", __LINE__, l);
}
ck_pr_dec_uint(&locked);
@ -173,8 +167,7 @@ thread(void *null CK_CC_UNUSED)
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [WR:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [WR:%d]: %u != 0\n", __LINE__, l);
}
}
ck_rwlock_write_unlock(&lock);
@ -183,8 +176,7 @@ thread(void *null CK_CC_UNUSED)
{
l = ck_pr_load_uint(&locked);
if (l != 0) {
fprintf(stderr, "ERROR [RD:%d]: %u != 0\n", __LINE__, l);
exit(EXIT_FAILURE);
ck_error("ERROR [RD:%d]: %u != 0\n", __LINE__, l);
}
}
ck_rwlock_read_unlock(&lock);
@ -200,51 +192,46 @@ main(int argc, char *argv[])
int i;
if (argc != 3) {
fprintf(stderr, "Usage: validate <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: validate <number of threads> <affinity delta>\n");
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate thread structures\n");
}
a.delta = atoi(argv[2]);
fprintf(stderr, "Creating threads (mutual exclusion)...");
ck_error("Creating threads (mutual exclusion)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread, NULL)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
fprintf(stderr, "Creating threads (mutual exclusion, recursive)...");
ck_error("Creating threads (mutual exclusion, recursive)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread_recursive, NULL)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Could not create thread %d\n", i);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);
}

20
regressions/ck_sequence/validate/ck_sequence.c
Unescape View File

@ -79,17 +79,15 @@ consumer(void *unused CK_CC_UNUSED)
} while (ck_sequence_read_retry(&seqlock, version) == true);
if (copy.b != copy.a + 1000) {
fprintf(stderr, "ERROR: Failed regression: copy.b (%u != %u + %u / %u)\n", copy.b, copy.a, 1000, copy.a + 1000);
exit(EXIT_FAILURE);
ck_error("ERROR: Failed regression: copy.b (%u != %u + %u / %u)\n", copy.b, copy.a, 1000, copy.a + 1000);
}
if (copy.c != copy.a + copy.b) {
fprintf(stderr, "ERROR: Failed regression: copy.c (%u != %u + %u / %u)\n", copy.c, copy.a, copy.b, copy.a + copy.b);
exit(EXIT_FAILURE);
ck_error("ERROR: Failed regression: copy.c (%u != %u + %u / %u)\n", copy.c, copy.a, copy.b, copy.a + copy.b);
}
}
fprintf(stderr, "%u retries.\n", retries - STEPS);
ck_error("%u retries.\n", retries - STEPS);
ck_pr_dec_uint(&barrier);
return (NULL);
}
@ -102,20 +100,17 @@ main(int argc, char *argv[])
int n_threads, i;
if (argc != 3) {
fprintf(stderr, "Usage: ck_sequence <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
ck_error("Usage: ck_sequence <number of threads> <affinity delta>\n");
}
n_threads = atoi(argv[1]);
if (n_threads <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Number of threads must be greater than 0\n");
}
threads = malloc(sizeof(pthread_t) * n_threads);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate memory for threads\n");
exit(EXIT_FAILURE);
ck_error("ERROR: Could not allocate memory for threads\n");
}
affinerator.delta = atoi(argv[2]);
@ -123,8 +118,7 @@ main(int argc, char *argv[])
for (i = 0; i < n_threads; i++) {
if (pthread_create(&threads[i], NULL, consumer, NULL)) {
fprintf(stderr, "ERROR: Failed to create thread %d\n", i);
exit(EXIT_FAILURE);
ck_error("ERROR: Failed to create thread %d\n", i);
}
}

22
regressions/ck_spinlock/benchmark/throughput.h
Unescape View File

@ -136,13 +136,13 @@ main(int argc, char *argv[])
struct block *context;
if (argc != 4) {
fprintf(stderr, "Usage: " LOCK_NAME " <number of threads> <affinity delta> <critical section>\n");
ck_error("Usage: " LOCK_NAME " <number of threads> <affinity delta> <critical section>\n");
exit(EXIT_FAILURE);
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
ck_error("ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
}
@ -152,19 +152,19 @@ main(int argc, char *argv[])
critical = atoi(argv[3]);
if (critical < 0) {
fprintf(stderr, "ERROR: critical section cannot be negative\n");
ck_error("ERROR: critical section cannot be negative\n");
exit(EXIT_FAILURE);
}
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
ck_error("ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
}
context = malloc(sizeof(struct block) * nthr);
if (context == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread contexts\n");
ck_error("ERROR: Could not allocate thread contexts\n");
exit(EXIT_FAILURE);
}
@ -173,29 +173,29 @@ main(int argc, char *argv[])
count = malloc(sizeof(*count) * nthr);
if (count == NULL) {
fprintf(stderr, "ERROR: Could not create acquisition buffer\n");
ck_error("ERROR: Could not create acquisition buffer\n");
exit(EXIT_FAILURE);
}
memset(count, 0, sizeof(*count) * nthr);
fprintf(stderr, "Creating threads (fairness)...");
ck_error("Creating threads (fairness)...");
for (i = 0; i < nthr; i++) {
context[i].tid = i;
if (pthread_create(&threads[i], NULL, fairness, context + i)) {
fprintf(stderr, "ERROR: Could not create thread %d\n", i);
ck_error("ERROR: Could not create thread %d\n", i);
exit(EXIT_FAILURE);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
ck_pr_store_uint(&ready, 1);
sleep(10);
ck_pr_store_uint(&ready, 0);
fprintf(stderr, "Waiting for threads to finish acquisition regression...");
ck_error("Waiting for threads to finish acquisition regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done\n\n");
ck_error("done\n\n");
for (i = 0, v = 0; i < nthr; i++) {
printf("%d %15" PRIu64 "\n", i, count[i].value);

20
regressions/ck_spinlock/validate/validate.h
Unescape View File

@ -81,7 +81,7 @@ thread(void *null CK_CC_UNUSED)
j = ck_pr_load_uint(&locked);
if (j != 5) {
fprintf(stderr, "ERROR (WR): Race condition (%u)\n", j);
ck_error("ERROR (WR): Race condition (%u)\n", j);
exit(EXIT_FAILURE);
}
@ -96,7 +96,7 @@ thread(void *null CK_CC_UNUSED)
j = ck_pr_load_uint(&locked);
if (j != 0) {
fprintf(stderr, "ERROR (RD): Race condition (%u)\n", j);
ck_error("ERROR (RD): Race condition (%u)\n", j);
exit(EXIT_FAILURE);
}
UNLOCK;
@ -112,13 +112,13 @@ main(int argc, char *argv[])
pthread_t *threads;
if (argc != 3) {
fprintf(stderr, "Usage: " LOCK_NAME " <number of threads> <affinity delta>\n");
ck_error("Usage: " LOCK_NAME " <number of threads> <affinity delta>\n");
exit(EXIT_FAILURE);
}
nthr = atoi(argv[1]);
if (nthr <= 0) {
fprintf(stderr, "ERROR: Number of threads must be greater than 0\n");
ck_error("ERROR: Number of threads must be greater than 0\n");
exit(EXIT_FAILURE);
}
@ -128,26 +128,26 @@ main(int argc, char *argv[])
threads = malloc(sizeof(pthread_t) * nthr);
if (threads == NULL) {
fprintf(stderr, "ERROR: Could not allocate thread structures\n");
ck_error("ERROR: Could not allocate thread structures\n");
exit(EXIT_FAILURE);
}
a.delta = atoi(argv[2]);
a.request = 0;
fprintf(stderr, "Creating threads (mutual exclusion)...");
ck_error("Creating threads (mutual exclusion)...");
for (i = 0; i < nthr; i++) {
if (pthread_create(&threads[i], NULL, thread, NULL)) {
fprintf(stderr, "ERROR: Could not create thread %" PRIu64 "\n", i);
ck_error("ERROR: Could not create thread %" PRIu64 "\n", i);
exit(EXIT_FAILURE);
}
}
fprintf(stderr, "done\n");
ck_error("done\n");
fprintf(stderr, "Waiting for threads to finish correctness regression...");
ck_error("Waiting for threads to finish correctness regression...");
for (i = 0; i < nthr; i++)
pthread_join(threads[i], NULL);
fprintf(stderr, "done (passed)\n");
ck_error("done (passed)\n");
return (0);
}

12
regressions/ck_stack/validate/pair.c
Unescape View File

@ -178,8 +178,7 @@ main(int argc, char *argv[])
#endif
if (argc != 4) {
fprintf(stderr, "Usage: stack <threads> <delta> <critical>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <threads> <delta> <critical>\n");
}
{
@ -190,8 +189,7 @@ main(int argc, char *argv[])
perror("ERROR: too many threads");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
d = strtol(argv[2], &e, 10);
@ -199,8 +197,7 @@ main(int argc, char *argv[])
perror("ERROR: delta is too large");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
critical = strtoul(argv[3], &e, 10);
@ -208,8 +205,7 @@ main(int argc, char *argv[])
perror("ERROR: critical section is too large");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
}

12
regressions/ck_stack/validate/pop.c
Unescape View File

@ -198,8 +198,7 @@ main(int argc, char *argv[])
#endif
if (argc != 4) {
fprintf(stderr, "Usage: stack <threads> <delta> <critical>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <threads> <delta> <critical>\n");
}
{
@ -210,8 +209,7 @@ main(int argc, char *argv[])
perror("ERROR: too many threads");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
d = strtol(argv[2], &e, 10);
@ -219,8 +217,7 @@ main(int argc, char *argv[])
perror("ERROR: delta is too large");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
critical = strtoul(argv[3], &e, 10);
@ -228,8 +225,7 @@ main(int argc, char *argv[])
perror("ERROR: critical section is too large");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
}

12
regressions/ck_stack/validate/push.c
Unescape View File

@ -164,8 +164,7 @@ main(int argc, char *argv[])
struct timeval stv, etv;
if (argc != 4) {
fprintf(stderr, "Usage: stack <threads> <delta> <critical>\n");
exit(EXIT_FAILURE);
ck_error("Usage: stack <threads> <delta> <critical>\n");
}
{
@ -176,8 +175,7 @@ main(int argc, char *argv[])
perror("ERROR: too many threads");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
d = strtol(argv[2], &e, 10);
@ -185,8 +183,7 @@ main(int argc, char *argv[])
perror("ERROR: delta is too large");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
critical = strtoul(argv[3], &e, 10);
@ -194,8 +191,7 @@ main(int argc, char *argv[])
perror("ERROR: critical section is too large");
exit(EXIT_FAILURE);
} else if (*e != '\0') {
fprintf(stderr, "ERROR: input format is incorrect\n");
exit(EXIT_FAILURE);
ck_error("ERROR: input format is incorrect\n");
}
}

13
regressions/common.h
Unescape View File

@ -26,6 +26,8 @@
#include <ck_cc.h>
#include <ck_pr.h>
#include <stdarg.h>
#include <stdlib.h>
#ifdef __linux__
#include <sched.h>
@ -147,3 +149,14 @@ rdtsc(void)
#endif
}
CK_CC_USED static void
ck_error(const char *message, ...)
{
va_list ap;
va_start(ap, message);
vfprintf(stderr, message, ap);
va_end(ap);
exit(EXIT_FAILURE);
}

Write Preview
Loading…
Cancel
Save