int
main(int argc, char *argv[])
{
int i, r;
struct context *context;
pthread_t *thread;
if (argc != 4) {
ck_error("Usage: validate <threads> <affinity delta> <size>\n");
}
a.request = 0;
a.delta = atoi(argv[2]);
nthr = atoi(argv[1]);
assert(nthr >= 1);
size = atoi(argv[3]);
assert(size > 0);
fifo = malloc(sizeof(ck_fifo_spsc_t) * nthr);
assert(fifo);
context = malloc(sizeof(*context) * nthr);
assert(context);
thread = malloc(sizeof(pthread_t) * nthr);
assert(thread);
for (i = 0; i < nthr; i++) {
ck_fifo_spsc_entry_t *garbage;
context[i].tid = i;
if (i == 0) {
context[i].previous = nthr - 1;
context[i].next = i + 1;
} else if (i == nthr - 1) {
context[i].next = 0;
context[i].previous = i - 1;
} else {
context[i].next = i + 1;
context[i].previous = i - 1;
}
ck_fifo_spsc_init(fifo + i, malloc(sizeof(ck_fifo_spsc_entry_t)));
ck_fifo_spsc_deinit(fifo + i, &garbage);
if (garbage == NULL)
ck_error("ERROR: Expected non-NULL stub node on deinit.\n");
free(garbage);
ck_fifo_spsc_init(fifo + i, malloc(sizeof(ck_fifo_spsc_entry_t)));
r = pthread_create(thread + i, NULL, test, context + i);
assert(r == 0);
}
for (i = 0; i < nthr; i++)
pthread_join(thread[i], NULL);
return (0);
}
int
main(int argc, char *argv[])
{
int i, r;
struct context *context;
pthread_t *thread;
if (argc != 4) {
fprintf(stderr, "Usage: validate <threads> <affinity delta> <size>\n");
exit(EXIT_FAILURE);
}
a.request = 0;
a.delta = atoi(argv[2]);
nthr = atoi(argv[1]);
assert(nthr >= 1);
size = atoi(argv[3]);
assert(size > 0);
fifo = malloc(sizeof(ck_fifo_spsc_t) * nthr);
assert(fifo);
context = malloc(sizeof(*context) * nthr);
assert(context);
thread = malloc(sizeof(pthread_t) * nthr);
assert(thread);
for (i = 0; i < nthr; i++) {
context[i].tid = i;
if (i == 0) {
context[i].previous = nthr - 1;
context[i].next = i + 1;
} else if (i == nthr - 1) {
context[i].next = 0;
context[i].previous = i - 1;
} else {
context[i].next = i + 1;
context[i].previous = i - 1;
}
ck_fifo_spsc_init(fifo + i, malloc(sizeof(ck_fifo_spsc_entry_t)));
r = pthread_create(thread + i, NULL, test, context + i);
assert(r == 0);
}
for (i = 0; i < nthr; i++)
pthread_join(thread[i], NULL);
return (0);
}
static int
get_my_lane() {
if(my_lane.fifo == NULL) {
int new_thread;
my_lane.fifo = calloc(1, sizeof(ck_fifo_spsc_t));
ck_fifo_spsc_init(my_lane.fifo, malloc(sizeof(ck_fifo_spsc_entry_t)));
for(new_thread=0;new_thread<nthreads;new_thread++) {
if(mtev_atomic_casptr(&thread_queues[new_thread], my_lane.fifo, NULL) == NULL) break;
}
mtevAssert(new_thread<nthreads);
my_lane.id = new_thread;
mtevL(mtev_debug, "Assigning thread(%p) to %d\n", (void*)(uintptr_t)pthread_self(), my_lane.id);
}
return my_lane.id;
}
void
fqd_start_worker_threads(int thread_count)
{
int i = 0;
worker_thread_count = thread_count;
work_queues = calloc(thread_count, sizeof(ck_fifo_spsc_t));
work_queue_backlogs = calloc(thread_count, sizeof(uint32_t));
worker_threads = calloc(thread_count, sizeof(pthread_t));
worker_thread_ids = calloc(thread_count, sizeof(int));
for ( ; i < thread_count; i++) {
worker_thread_ids[i] = i;
ck_fifo_spsc_init(&work_queues[i], malloc(sizeof(ck_fifo_spsc_entry_t)));
pthread_create(&worker_threads[i], NULL, fqd_worker_thread, &worker_thread_ids[i]);
}
}
int
main(void)
{
ck_spinlock_fas_t mutex = CK_SPINLOCK_FAS_INITIALIZER;
void *r;
uint64_t s, e, a;
unsigned int i;
unsigned int j;
#if defined(CK_F_FIFO_SPSC)
ck_fifo_spsc_t spsc_fifo;
ck_fifo_spsc_entry_t spsc_entry[ENTRIES];
ck_fifo_spsc_entry_t spsc_stub;
#endif
#if defined(CK_F_FIFO_MPMC)
ck_fifo_mpmc_t mpmc_fifo;
ck_fifo_mpmc_entry_t mpmc_entry[ENTRIES];
ck_fifo_mpmc_entry_t mpmc_stub;
ck_fifo_mpmc_entry_t *garbage;
#endif
#ifdef CK_F_FIFO_SPSC
a = 0;
for (i = 0; i < STEPS; i++) {
ck_fifo_spsc_init(&spsc_fifo, &spsc_stub);
s = rdtsc();
for (j = 0; j < ENTRIES; j++) {
ck_spinlock_fas_lock(&mutex);
ck_fifo_spsc_enqueue(&spsc_fifo, spsc_entry + j, NULL);
ck_spinlock_fas_unlock(&mutex);
}
e = rdtsc();
a += e - s;
}
printf(" spinlock_enqueue: %16" PRIu64 "\n", a / STEPS / (sizeof(spsc_entry) / sizeof(*spsc_entry)));
a = 0;
for (i = 0; i < STEPS; i++) {
ck_fifo_spsc_init(&spsc_fifo, &spsc_stub);
for (j = 0; j < ENTRIES; j++)
ck_fifo_spsc_enqueue(&spsc_fifo, spsc_entry + j, NULL);
s = rdtsc();
for (j = 0; j < ENTRIES; j++) {
ck_spinlock_fas_lock(&mutex);
ck_fifo_spsc_dequeue(&spsc_fifo, &r);
ck_spinlock_fas_unlock(&mutex);
}
e = rdtsc();
a += e - s;
}
printf(" spinlock_dequeue: %16" PRIu64 "\n", a / STEPS / (sizeof(spsc_entry) / sizeof(*spsc_entry)));
a = 0;
for (i = 0; i < STEPS; i++) {
ck_fifo_spsc_init(&spsc_fifo, &spsc_stub);
s = rdtsc();
for (j = 0; j < ENTRIES; j++)
ck_fifo_spsc_enqueue(&spsc_fifo, spsc_entry + j, NULL);
e = rdtsc();
a += e - s;
}
printf("ck_fifo_spsc_enqueue: %16" PRIu64 "\n", a / STEPS / (sizeof(spsc_entry) / sizeof(*spsc_entry)));
a = 0;
for (i = 0; i < STEPS; i++) {
ck_fifo_spsc_init(&spsc_fifo, &spsc_stub);
for (j = 0; j < ENTRIES; j++)
ck_fifo_spsc_enqueue(&spsc_fifo, spsc_entry + j, NULL);
s = rdtsc();
for (j = 0; j < ENTRIES; j++)
ck_fifo_spsc_dequeue(&spsc_fifo, &r);
e = rdtsc();
a += e - s;
}
printf("ck_fifo_spsc_dequeue: %16" PRIu64 "\n", a / STEPS / (sizeof(spsc_entry) / sizeof(*spsc_entry)));
#endif
#ifdef CK_F_FIFO_MPMC
a = 0;
for (i = 0; i < STEPS; i++) {
ck_fifo_mpmc_init(&mpmc_fifo, &mpmc_stub);
s = rdtsc();
for (j = 0; j < ENTRIES; j++)
ck_fifo_mpmc_enqueue(&mpmc_fifo, mpmc_entry + j, NULL);
e = rdtsc();
a += e - s;
}
printf("ck_fifo_mpmc_enqueue: %16" PRIu64 "\n", a / STEPS / (sizeof(mpmc_entry) / sizeof(*mpmc_entry)));
a = 0;
for (i = 0; i < STEPS; i++) {
ck_fifo_mpmc_init(&mpmc_fifo, &mpmc_stub);
for (j = 0; j < ENTRIES; j++)
ck_fifo_mpmc_enqueue(&mpmc_fifo, mpmc_entry + j, NULL);
s = rdtsc();
for (j = 0; j < ENTRIES; j++)
ck_fifo_mpmc_dequeue(&mpmc_fifo, &r, &garbage);
e = rdtsc();
a += e - s;
}
printf("ck_fifo_mpmc_dequeue: %16" PRIu64 "\n", a / STEPS / (sizeof(mpmc_entry) / sizeof(*mpmc_entry)));
#endif
return 0;
}
