From e36b37583bebd229102f46c4ed7d2f6fad8697d4 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 23 Jul 2021 13:24:09 +0200 Subject: Adding upstream version 0.6.0. Signed-off-by: Daniel Baumann --- regressions/ck_stack/validate/Makefile | 56 +++++++ regressions/ck_stack/validate/pair.c | 249 ++++++++++++++++++++++++++++++ regressions/ck_stack/validate/pop.c | 269 +++++++++++++++++++++++++++++++++ regressions/ck_stack/validate/push.c | 248 ++++++++++++++++++++++++++++++ regressions/ck_stack/validate/serial.c | 84 ++++++++++ 5 files changed, 906 insertions(+) create mode 100644 regressions/ck_stack/validate/Makefile create mode 100644 regressions/ck_stack/validate/pair.c create mode 100644 regressions/ck_stack/validate/pop.c create mode 100644 regressions/ck_stack/validate/push.c create mode 100644 regressions/ck_stack/validate/serial.c (limited to 'regressions/ck_stack/validate') diff --git a/regressions/ck_stack/validate/Makefile b/regressions/ck_stack/validate/Makefile new file mode 100644 index 0000000..519dca1 --- /dev/null +++ b/regressions/ck_stack/validate/Makefile @@ -0,0 +1,56 @@ +.PHONY: check clean distribution + +OBJECTS=serial mpnc_push mpmc_push upmc_push spinlock_push spinlock_eb_push \ + mpmc_pop upmc_pop spinlock_pop spinlock_eb_pop \ + upmc_trypop mpmc_trypop mpmc_trypair \ + mpmc_pair spinlock_pair spinlock_eb_pair pthreads_pair \ + mpmc_trypush upmc_trypush + +all: $(OBJECTS) + +check: all + ./serial + ./mpmc_pair $(CORES) 1 0 + ./upmc_trypop $(CORES) 1 0 + ./mpmc_trypop $(CORES) 1 0 + ./mpmc_trypair $(CORES) 1 0 + ./mpmc_pop $(CORES) 1 0 + ./upmc_pop $(CORES) 1 0 + ./mpnc_push $(CORES) 1 0 + ./mpmc_push $(CORES) 1 0 + ./upmc_push $(CORES) 1 0 + ./mpmc_trypush $(CORES) 1 0 + ./upmc_trypush $(CORES) 1 0 + +serial: serial.c + $(CC) $(CFLAGS) -o serial serial.c + +mpmc_trypush upmc_trypush mpnc_push mpmc_push upmc_push spinlock_push spinlock_eb_push: push.c + $(CC) -DTRYUPMC $(CFLAGS) -o upmc_trypush push.c + $(CC) -DTRYMPMC $(CFLAGS) -o mpmc_trypush push.c + $(CC) -DMPNC $(CFLAGS) -o mpnc_push push.c + $(CC) -DMPMC $(CFLAGS) -o mpmc_push push.c + $(CC) -DUPMC $(CFLAGS) -o upmc_push push.c + $(CC) -DSPINLOCK $(CFLAGS) -o spinlock_push push.c + $(CC) -DSPINLOCK -DEB $(CFLAGS) -o spinlock_eb_push push.c + +upmc_trypop mpmc_trypop mpmc_pop tryupmc_pop upmc_pop spinlock_pop spinlock_eb_pop: pop.c + $(CC) -DTRYMPMC $(CFLAGS) -o mpmc_trypop pop.c + $(CC) -DTRYUPMC $(CFLAGS) -o upmc_trypop pop.c + $(CC) -DMPMC $(CFLAGS) -o mpmc_pop pop.c + $(CC) -DUPMC $(CFLAGS) -o upmc_pop pop.c + $(CC) -DSPINLOCK $(CFLAGS) -o spinlock_pop pop.c + $(CC) -DEB -DSPINLOCK $(CFLAGS) -o spinlock_eb_pop pop.c + +mpmc_trypair mpmc_pair spinlock_pair spinlock_eb_pair pthreads_pair: pair.c + $(CC) -DTRYMPMC $(CFLAGS) -o mpmc_trypair pair.c + $(CC) -DMPMC $(CFLAGS) -o mpmc_pair pair.c + $(CC) -DSPINLOCK $(CFLAGS) -o spinlock_pair pair.c + $(CC) -DEB -DSPINLOCK $(CFLAGS) -o spinlock_eb_pair pair.c + $(CC) -DPTHREADS $(CFLAGS) -o pthreads_pair pair.c + +clean: + rm -rf *~ *.o *.dSYM *.exe $(OBJECTS) + +include ../../../build/regressions.build +CFLAGS+=$(PTHREAD_CFLAGS) -D_GNU_SOURCE diff --git a/regressions/ck_stack/validate/pair.c b/regressions/ck_stack/validate/pair.c new file mode 100644 index 0000000..c0f1bb1 --- /dev/null +++ b/regressions/ck_stack/validate/pair.c @@ -0,0 +1,249 @@ +/* + * Copyright 2009 Samy Al Bahra. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#include +#ifdef SPINLOCK +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../../common.h" + +#ifndef ITEMS +#define ITEMS (5765760) +#endif + +#define TVTOD(tv) ((tv).tv_sec+((tv).tv_usec / (double)1000000)) + +struct entry { + int value; +#if defined(SPINLOCK) || defined(PTHREADS) + struct entry *next; +#else + ck_stack_entry_t next; +#endif +} CK_CC_CACHELINE; + +#ifdef SPINLOCK +static struct entry *stack CK_CC_CACHELINE; +ck_spinlock_fas_t stack_spinlock = CK_SPINLOCK_FAS_INITIALIZER; +#define UNLOCK ck_spinlock_fas_unlock +#if defined(EB) +#define LOCK ck_spinlock_fas_lock_eb +#else +#define LOCK ck_spinlock_fas_lock +#endif +#elif defined(PTHREADS) +static struct entry *stack CK_CC_CACHELINE; +pthread_mutex_t stack_spinlock = PTHREAD_MUTEX_INITIALIZER; +#define LOCK pthread_mutex_lock +#define UNLOCK pthread_mutex_unlock +#else +static ck_stack_t stack CK_CC_CACHELINE; +CK_STACK_CONTAINER(struct entry, next, getvalue) +#endif + +static struct affinity affinerator; +static unsigned long long nthr; +static volatile unsigned int barrier = 0; +static unsigned int critical; + +static void * +stack_thread(void *buffer) +{ +#if (defined(MPMC) && defined(CK_F_STACK_POP_MPMC)) || (defined(UPMC) && defined(CK_F_STACK_POP_UPMC)) || (defined(TRYUPMC) && defined(CK_F_STACK_TRYPOP_UPMC)) || (defined(TRYMPMC) && defined(CK_F_STACK_TRYPOP_MPMC)) + ck_stack_entry_t *ref; +#endif + struct entry *entry = buffer; + unsigned long long i, n = ITEMS; + unsigned int seed; + int j; + + if (aff_iterate(&affinerator)) { + perror("ERROR: failed to affine thread"); + exit(EXIT_FAILURE); + } + + while (barrier == 0); + + for (i = 0; i < n; i++) { +#if defined(MPMC) + ck_stack_push_mpmc(&stack, &entry->next); +#elif defined(TRYMPMC) + while (ck_stack_trypush_mpmc(&stack, &entry->next) == false) + ck_pr_stall(); +#elif defined(UPMC) + ck_stack_push_upmc(&stack, &entry->next); +#elif defined(TRYUPMC) + while (ck_stack_trypush_upmc(&stack, &entry->next) == false) + ck_pr_stall(); +#elif defined(SPINLOCK) || defined(PTHREADS) + LOCK(&stack_spinlock); + ck_pr_store_ptr(&entry->next, stack); + ck_pr_store_ptr(&stack, entry); + UNLOCK(&stack_spinlock); +#else +# error Undefined operation. +#endif + + if (critical) { + j = common_rand_r(&seed) % critical; + while (j--) + __asm__ __volatile__("" ::: "memory"); + } + +#if defined(MPMC) +#ifdef CK_F_STACK_POP_MPMC + ref = ck_stack_pop_mpmc(&stack); + entry = getvalue(ref); +#endif +#elif defined(TRYMPMC) +#ifdef CK_F_STACK_TRYPOP_MPMC + while (ck_stack_trypop_mpmc(&stack, &ref) == false) + ck_pr_stall(); + entry = getvalue(ref); +#endif /* CK_F_STACK_TRYPOP_MPMC */ +#elif defined(UPMC) + ref = ck_stack_pop_upmc(&stack); + entry = getvalue(ref); +#elif defined(SPINLOCK) || defined(PTHREADS) + LOCK(&stack_spinlock); + entry = stack; + stack = stack->next; + UNLOCK(&stack_spinlock); +#else +# error Undefined operation. +#endif + } + + return (NULL); +} + +static void +stack_assert(void) +{ + +#if defined(SPINLOCK) || defined(PTHREADS) + assert(stack == NULL); +#else + assert(CK_STACK_ISEMPTY(&stack)); +#endif + return; +} + +int +main(int argc, char *argv[]) +{ + struct entry *bucket; + unsigned long long i, d; + pthread_t *thread; + struct timeval stv, etv; + +#if (defined(TRYMPMC) || defined(MPMC)) && (!defined(CK_F_STACK_PUSH_MPMC) || !defined(CK_F_STACK_POP_MPMC)) + fprintf(stderr, "Unsupported.\n"); + return 0; +#endif + + if (argc != 4) { + ck_error("Usage: stack \n"); + } + + { + char *e; + + nthr = strtol(argv[1], &e, 10); + if (errno == ERANGE) { + perror("ERROR: too many threads"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + + d = strtol(argv[2], &e, 10); + if (errno == ERANGE) { + perror("ERROR: delta is too large"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + + critical = strtoul(argv[3], &e, 10); + if (errno == ERANGE) { + perror("ERROR: critical section is too large"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + } + + srand(getpid()); + + affinerator.request = 0; + affinerator.delta = d; + + bucket = malloc(sizeof(struct entry) * nthr); + assert(bucket != NULL); + + thread = malloc(sizeof(pthread_t) * nthr); + assert(thread != NULL); + + for (i = 0; i < nthr; i++) + pthread_create(&thread[i], NULL, stack_thread, bucket + i); + + barrier = 1; + + for (i = 0; i < nthr; i++) + pthread_join(thread[i], NULL); + + barrier = 0; + + for (i = 0; i < nthr; i++) + pthread_create(&thread[i], NULL, stack_thread, bucket + i); + + common_gettimeofday(&stv, NULL); + barrier = 1; + for (i = 0; i < nthr; i++) + pthread_join(thread[i], NULL); + common_gettimeofday(&etv, NULL); + + stack_assert(); +#ifdef _WIN32 + printf("%3llu %.6f\n", nthr, TVTOD(etv) - TVTOD(stv)); +#else + printf("%3llu %.6lf\n", nthr, TVTOD(etv) - TVTOD(stv)); +#endif + return 0; +} diff --git a/regressions/ck_stack/validate/pop.c b/regressions/ck_stack/validate/pop.c new file mode 100644 index 0000000..0d69d42 --- /dev/null +++ b/regressions/ck_stack/validate/pop.c @@ -0,0 +1,269 @@ +/* + * Copyright 2009-2015 Samy Al Bahra. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#include +#ifdef SPINLOCK +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../../common.h" + +#ifndef ITEMS +#define ITEMS (5765760 * 2) +#endif + +#define TVTOD(tv) ((tv).tv_sec+((tv).tv_usec / (double)1000000)) + +struct entry { + int value; +#ifdef SPINLOCK + struct entry *next; +#else + ck_stack_entry_t next; +#endif +}; + +#ifdef SPINLOCK +static struct entry *stack CK_CC_CACHELINE; +ck_spinlock_fas_t stack_spinlock = CK_SPINLOCK_FAS_INITIALIZER; +#define UNLOCK ck_spinlock_fas_unlock +#if defined(EB) +#define LOCK ck_spinlock_fas_lock_eb +#else +#define LOCK ck_spinlock_fas_lock +#endif +#else +static ck_stack_t stack CK_CC_CACHELINE; +CK_STACK_CONTAINER(struct entry, next, getvalue) +#endif + +static struct affinity affinerator = AFFINITY_INITIALIZER; +static unsigned long long nthr; +static volatile unsigned int barrier = 0; +static unsigned int critical; + +static void * +stack_thread(void *unused CK_CC_UNUSED) +{ +#if (defined(MPMC) && defined(CK_F_STACK_POP_MPMC)) || (defined(UPMC) && defined(CK_F_STACK_POP_UPMC)) || (defined(TRYMPMC) && defined(CK_F_STACK_TRYPOP_MPMC)) || (defined(TRYUPMC) && defined(CK_F_STACK_TRYPOP_UPMC)) + ck_stack_entry_t *ref; +#endif + struct entry *entry = NULL; + unsigned long long i, n = ITEMS / nthr; + unsigned int seed; + int j, previous = INT_MAX; + + if (aff_iterate(&affinerator)) { + perror("ERROR: failed to affine thread"); + exit(EXIT_FAILURE); + } + + while (barrier == 0); + + for (i = 0; i < n; i++) { +#ifdef MPMC +#ifdef CK_F_STACK_POP_MPMC + ref = ck_stack_pop_mpmc(&stack); + assert(ref); + entry = getvalue(ref); +#endif /* CK_F_STACK_POP_MPMC */ +#elif defined(TRYMPMC) +#ifdef CK_F_STACK_TRYPOP_MPMC + while (ck_stack_trypop_mpmc(&stack, &ref) == false) + ck_pr_stall(); + assert(ref); + entry = getvalue(ref); +#endif /* CK_F_STACK_TRYPOP_MPMC */ +#elif defined(UPMC) + ref = ck_stack_pop_upmc(&stack); + assert(ref); + entry = getvalue(ref); +#elif defined(TRYUPMC) + while (ck_stack_trypop_upmc(&stack, &ref) == false) + ck_pr_stall(); + assert(ref); + entry = getvalue(ref); +#elif defined(SPINLOCK) + LOCK(&stack_spinlock); + entry = stack; + stack = stack->next; + UNLOCK(&stack_spinlock); +#else +# error Undefined operation. +#endif + + if (critical) { + j = common_rand_r(&seed) % critical; + while (j--) + __asm__ __volatile__("" ::: "memory"); + } + + assert (previous >= entry->value); + previous = entry->value; + } + + return (NULL); +} + +static void +stack_assert(void) +{ + +#ifdef SPINLOCK + assert(stack == NULL); +#else + assert(CK_STACK_ISEMPTY(&stack)); +#endif + return; +} + +static void +push_stack(struct entry *bucket) +{ + unsigned long long i; + +#ifdef SPINLOCK + stack = NULL; +#else + ck_stack_init(&stack); +#endif + + for (i = 0; i < ITEMS; i++) { + bucket[i].value = i % INT_MAX; +#ifdef SPINLOCK + bucket[i].next = stack; + stack = bucket + i; +#else + ck_stack_push_spnc(&stack, &bucket[i].next); +#endif + } + +#ifndef SPINLOCK + ck_stack_entry_t *entry; + i = 0; + CK_STACK_FOREACH(&stack, entry) { + i++; + } + assert(i == ITEMS); +#endif + + return; +} + +int +main(int argc, char *argv[]) +{ + struct entry *bucket; + unsigned long long i, d; + pthread_t *thread; + struct timeval stv, etv; + +#if (defined(TRYMPMC) || defined(MPMC)) && (!defined(CK_F_STACK_PUSH_MPMC) || !defined(CK_F_STACK_POP_MPMC)) + fprintf(stderr, "Unsupported.\n"); + return 0; +#endif + + if (argc != 4) { + ck_error("Usage: stack \n"); + } + + { + char *e; + + nthr = strtol(argv[1], &e, 10); + if (errno == ERANGE) { + perror("ERROR: too many threads"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + + d = strtol(argv[2], &e, 10); + if (errno == ERANGE) { + perror("ERROR: delta is too large"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + + critical = strtoul(argv[3], &e, 10); + if (errno == ERANGE) { + perror("ERROR: critical section is too large"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + } + + srand(getpid()); + + affinerator.delta = d; + bucket = malloc(sizeof(struct entry) * ITEMS); + assert(bucket != NULL); + + thread = malloc(sizeof(pthread_t) * nthr); + assert(thread != NULL); + + push_stack(bucket); + for (i = 0; i < nthr; i++) + pthread_create(&thread[i], NULL, stack_thread, NULL); + + barrier = 1; + + for (i = 0; i < nthr; i++) + pthread_join(thread[i], NULL); + + barrier = 0; + + push_stack(bucket); + for (i = 0; i < nthr; i++) + pthread_create(&thread[i], NULL, stack_thread, NULL); + + common_gettimeofday(&stv, NULL); + barrier = 1; + for (i = 0; i < nthr; i++) + pthread_join(thread[i], NULL); + common_gettimeofday(&etv, NULL); + + stack_assert(); +#ifdef _WIN32 + printf("%3llu %.6f\n", nthr, TVTOD(etv) - TVTOD(stv)); +#else + printf("%3llu %.6lf\n", nthr, TVTOD(etv) - TVTOD(stv)); +#endif + return 0; +} diff --git a/regressions/ck_stack/validate/push.c b/regressions/ck_stack/validate/push.c new file mode 100644 index 0000000..2b3ea33 --- /dev/null +++ b/regressions/ck_stack/validate/push.c @@ -0,0 +1,248 @@ +/* + * Copyright 2009-2015 Samy Al Bahra. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#ifdef SPINLOCK +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../../common.h" + +#ifndef ITEMS +#define ITEMS (5765760 * 2) +#endif + +#define TVTOD(tv) ((tv).tv_sec+((tv).tv_usec / (double)1000000)) + +struct entry { + int value; +#ifdef SPINLOCK + struct entry *next; +#else + ck_stack_entry_t next; +#endif +}; + +#ifdef SPINLOCK +static struct entry *stack CK_CC_CACHELINE; +#else +static ck_stack_t stack CK_CC_CACHELINE; +#endif + +CK_STACK_CONTAINER(struct entry, next, getvalue) + +static struct affinity affinerator = AFFINITY_INITIALIZER; +static unsigned long long nthr; +static volatile unsigned int barrier = 0; +static unsigned int critical; + +#if defined(SPINLOCK) +ck_spinlock_fas_t stack_spinlock = CK_SPINLOCK_FAS_INITIALIZER; +#define UNLOCK ck_spinlock_fas_unlock +#if defined(EB) +#define LOCK ck_spinlock_fas_lock_eb +#else +#define LOCK ck_spinlock_fas_lock +#endif +#elif defined(PTHREAD) +pthread_mutex_t stack_spinlock = PTHREAD_MUTEX_INITIALIZER; +#define LOCK pthread_mutex_lock +#define UNLOCK pthread_mutex_unlock +#endif + +static void * +stack_thread(void *buffer) +{ + struct entry *bucket = buffer; + unsigned long long i, n = ITEMS / nthr; + unsigned int seed; + int j; + + if (aff_iterate(&affinerator)) { + perror("ERROR: failed to affine thread"); + exit(EXIT_FAILURE); + } + + while (barrier == 0); + + for (i = 0; i < n; i++) { + bucket[i].value = (i + 1) * 2; + +#if defined(MPNC) + ck_stack_push_mpnc(&stack, &bucket[i].next); +#elif defined(MPMC) + ck_stack_push_mpmc(&stack, &bucket[i].next); +#elif defined(TRYMPMC) + while (ck_stack_trypush_mpmc(&stack, &bucket[i].next) == false) + ck_pr_stall(); +#elif defined(TRYUPMC) + while (ck_stack_trypush_upmc(&stack, &bucket[i].next) == false) + ck_pr_stall(); +#elif defined(UPMC) + ck_stack_push_upmc(&stack, &bucket[i].next); +#elif defined(SPINLOCK) || defined(PTHREADS) + LOCK(&stack_spinlock); + bucket[i].next = stack; + stack = bucket + i; + UNLOCK(&stack_spinlock); +#else +# error Undefined operation. +#endif + + if (critical) { + j = common_rand_r(&seed) % critical; + while (j--) + __asm__ __volatile__("" ::: "memory"); + } + } + + return (NULL); +} + +static void +stack_assert(void) +{ +#ifndef SPINLOCK + ck_stack_entry_t *n; +#endif + struct entry *p; + unsigned long long c = 0; + +#ifdef SPINLOCK + for (p = stack; p; p = p->next) + c++; +#else + CK_STACK_FOREACH(&stack, n) { + p = getvalue(n); + (void)((volatile struct entry *)p)->value; + c++; + } +#endif + + assert(c == ITEMS); + return; +} + +int +main(int argc, char *argv[]) +{ + struct entry *bucket; + unsigned long long i, d, n; + pthread_t *thread; + struct timeval stv, etv; + + if (argc != 4) { + ck_error("Usage: stack \n"); + } + + { + char *e; + + nthr = strtol(argv[1], &e, 10); + if (errno == ERANGE) { + perror("ERROR: too many threads"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + + d = strtol(argv[2], &e, 10); + if (errno == ERANGE) { + perror("ERROR: delta is too large"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + + critical = strtoul(argv[3], &e, 10); + if (errno == ERANGE) { + perror("ERROR: critical section is too large"); + exit(EXIT_FAILURE); + } else if (*e != '\0') { + ck_error("ERROR: input format is incorrect\n"); + } + } + + srand(getpid()); + + affinerator.request = 0; + affinerator.delta = d; + n = ITEMS / nthr; + +#ifndef SPINLOCK + ck_stack_init(&stack); +#else + stack = NULL; +#endif + + bucket = malloc(sizeof(struct entry) * ITEMS); + assert(bucket != NULL); + + thread = malloc(sizeof(pthread_t) * nthr); + assert(thread != NULL); + + for (i = 0; i < nthr; i++) + pthread_create(&thread[i], NULL, stack_thread, bucket + i * n); + + barrier = 1; + + for (i = 0; i < nthr; i++) + pthread_join(thread[i], NULL); + + barrier = 0; + +#ifndef SPINLOCK + ck_stack_init(&stack); +#else + stack = NULL; +#endif + + for (i = 0; i < nthr; i++) + pthread_create(&thread[i], NULL, stack_thread, bucket + i * n); + + common_gettimeofday(&stv, NULL); + barrier = 1; + for (i = 0; i < nthr; i++) + pthread_join(thread[i], NULL); + common_gettimeofday(&etv, NULL); + + stack_assert(); +#ifdef _WIN32 + printf("%3llu %.6f\n", nthr, TVTOD(etv) - TVTOD(stv)); +#else + printf("%3llu %.6lf\n", nthr, TVTOD(etv) - TVTOD(stv)); +#endif + return 0; +} diff --git a/regressions/ck_stack/validate/serial.c b/regressions/ck_stack/validate/serial.c new file mode 100644 index 0000000..eb667ca --- /dev/null +++ b/regressions/ck_stack/validate/serial.c @@ -0,0 +1,84 @@ +/* + * Copyright 2009-2015 Samy Al Bahra. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#include + +#include + +#ifndef SIZE +#define SIZE 1024000 +#endif + +struct entry { + int value; + ck_stack_entry_t next; +}; + +CK_STACK_CONTAINER(struct entry, next, get_entry) + +#define LOOP(PUSH, POP) \ + for (i = 0; i < SIZE; i++) { \ + entries[i].value = i; \ + PUSH(stack, &entries[i].next); \ + } \ + for (i = SIZE - 1; i >= 0; i--) { \ + entry = POP(stack); \ + assert(entry); \ + assert(get_entry(entry)->value == i); \ + } + +static void +serial(ck_stack_t *stack) +{ + struct entry *entries; + ck_stack_entry_t *entry; + int i; + + ck_stack_init(stack); + + entries = malloc(sizeof(struct entry) * SIZE); + assert(entries != NULL); + + LOOP(ck_stack_push_upmc, ck_stack_pop_upmc); +#ifdef CK_F_STACK_POP_MPMC + LOOP(ck_stack_push_mpmc, ck_stack_pop_mpmc); +#endif + LOOP(ck_stack_push_mpnc, ck_stack_pop_upmc); + LOOP(ck_stack_push_spnc, ck_stack_pop_npsc); + + return; +} + +int +main(void) +{ + ck_stack_t stack CK_CC_CACHELINE; + + serial(&stack); + return (0); +} -- cgit v1.2.3