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_pr/benchmark/Makefile | 31 +++++++ regressions/ck_pr/benchmark/benchmark.h | 130 +++++++++++++++++++++++++++ regressions/ck_pr/benchmark/ck_pr_add_64.c | 16 ++++ regressions/ck_pr/benchmark/ck_pr_cas_64.c | 16 ++++ regressions/ck_pr/benchmark/ck_pr_cas_64_2.c | 17 ++++ regressions/ck_pr/benchmark/ck_pr_faa_64.c | 16 ++++ regressions/ck_pr/benchmark/ck_pr_fas_64.c | 17 ++++ regressions/ck_pr/benchmark/ck_pr_neg_64.c | 16 ++++ regressions/ck_pr/benchmark/fp.c | 66 ++++++++++++++ 9 files changed, 325 insertions(+) create mode 100644 regressions/ck_pr/benchmark/Makefile create mode 100644 regressions/ck_pr/benchmark/benchmark.h create mode 100644 regressions/ck_pr/benchmark/ck_pr_add_64.c create mode 100644 regressions/ck_pr/benchmark/ck_pr_cas_64.c create mode 100644 regressions/ck_pr/benchmark/ck_pr_cas_64_2.c create mode 100644 regressions/ck_pr/benchmark/ck_pr_faa_64.c create mode 100644 regressions/ck_pr/benchmark/ck_pr_fas_64.c create mode 100644 regressions/ck_pr/benchmark/ck_pr_neg_64.c create mode 100644 regressions/ck_pr/benchmark/fp.c (limited to 'regressions/ck_pr/benchmark') diff --git a/regressions/ck_pr/benchmark/Makefile b/regressions/ck_pr/benchmark/Makefile new file mode 100644 index 0000000..55183d8 --- /dev/null +++ b/regressions/ck_pr/benchmark/Makefile @@ -0,0 +1,31 @@ +.PHONY: clean + +all: ck_pr_cas_64 ck_pr_fas_64 ck_pr_cas_64_2 ck_pr_add_64 ck_pr_faa_64 ck_pr_neg_64 fp + +fp: fp.c + $(CC) $(CFLAGS) -o fp fp.c + +ck_pr_cas_64_2: ck_pr_cas_64_2.c + $(CC) $(CFLAGS) -o ck_pr_cas_64_2 ck_pr_cas_64_2.c -lm + +ck_pr_cas_64: ck_pr_cas_64.c + $(CC) $(CFLAGS) -o ck_pr_cas_64 ck_pr_cas_64.c -lm + +ck_pr_fas_64: ck_pr_fas_64.c + $(CC) $(CFLAGS) -o ck_pr_fas_64 ck_pr_fas_64.c -lm + +ck_pr_add_64: ck_pr_add_64.c + $(CC) $(CFLAGS) -o ck_pr_add_64 ck_pr_add_64.c -lm + +ck_pr_faa_64: ck_pr_faa_64.c + $(CC) $(CFLAGS) -o ck_pr_faa_64 ck_pr_faa_64.c -lm + +ck_pr_neg_64: ck_pr_neg_64.c + $(CC) $(CFLAGS) -o ck_pr_neg_64 ck_pr_neg_64.c -lm + +clean: + rm -rf ck_pr_cas_64 ck_pr_fas_64 ck_pr_cas_64_2 ck_pr_add_64 \ + ck_pr_faa_64 ck_pr_neg_64 *.dSYM *.exe + +include ../../../build/regressions.build +CFLAGS+=$(PTHREAD_CFLAGS) -D_GNU_SOURCE diff --git a/regressions/ck_pr/benchmark/benchmark.h b/regressions/ck_pr/benchmark/benchmark.h new file mode 100644 index 0000000..f9e4ed2 --- /dev/null +++ b/regressions/ck_pr/benchmark/benchmark.h @@ -0,0 +1,130 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "../../common.h" + +/* 8! = 40320, evenly divide 1 .. 8 processor workload. */ +#define WORKLOAD (40320 * 2056) + +struct block { + unsigned int tid; +}; + +static struct affinity a; +static unsigned int ready; +static uint64_t *count; +static uint64_t nthr; + +static uint64_t object[2] CK_CC_CACHELINE; + +static void * +fairness(void *null) +{ + struct block *context = null; + unsigned int i = context->tid; + + if (aff_iterate(&a)) { + perror("ERROR: Could not affine thread"); + exit(EXIT_FAILURE); + } + + while (ck_pr_load_uint(&ready) == 0); + while (ck_pr_load_uint(&ready)) { + ATOMIC; + ATOMIC; + ATOMIC; + ATOMIC; + ck_pr_store_64(count + i, count[i] + 1); + } + + return (NULL); +} + +int +main(int argc, char *argv[]) +{ + uint64_t v, d; + unsigned int i; + pthread_t *threads; + struct block *context; + + if (argc != 3) { + ck_error("Usage: " ATOMIC_STRING " \n"); + exit(EXIT_FAILURE); + } + + nthr = atoi(argv[1]); + if (nthr <= 0) { + ck_error("ERROR: Number of threads must be greater than 0\n"); + exit(EXIT_FAILURE); + } + + threads = malloc(sizeof(pthread_t) * nthr); + if (threads == NULL) { + ck_error("ERROR: Could not allocate thread structures\n"); + exit(EXIT_FAILURE); + } + + context = malloc(sizeof(struct block) * nthr); + if (context == NULL) { + ck_error("ERROR: Could not allocate thread contexts\n"); + exit(EXIT_FAILURE); + } + + a.delta = atoi(argv[2]); + a.request = 0; + + count = malloc(sizeof(uint64_t) * nthr); + if (count == NULL) { + ck_error("ERROR: Could not create acquisition buffer\n"); + exit(EXIT_FAILURE); + } + memset(count, 0, sizeof(uint64_t) * nthr); + + fprintf(stderr, "Creating threads (fairness)..."); + for (i = 0; i < nthr; i++) { + context[i].tid = i; + if (pthread_create(&threads[i], NULL, fairness, context + i)) { + ck_error("ERROR: Could not create thread %d\n", i); + exit(EXIT_FAILURE); + } + } + fprintf(stderr, "done\n"); + + ck_pr_store_uint(&ready, 1); + common_sleep(10); + ck_pr_store_uint(&ready, 0); + + fprintf(stderr, "Waiting for threads to finish acquisition regression..."); + for (i = 0; i < nthr; i++) + pthread_join(threads[i], NULL); + fprintf(stderr, "done\n\n"); + + for (i = 0, v = 0; i < nthr; i++) { + printf("%d %15" PRIu64 "\n", i, count[i]); + v += count[i]; + } + + printf("\n# total : %15" PRIu64 "\n", v); + printf("# throughput : %15" PRIu64 " a/s\n", (v /= nthr) / 10); + + for (i = 0, d = 0; i < nthr; i++) + d += (count[i] - v) * (count[i] - v); + + printf("# average : %15" PRIu64 "\n", v); + printf("# deviation : %.2f (%.2f%%)\n\n", sqrt(d / nthr), (sqrt(d / nthr) / v) * 100.00); + + return (0); +} + diff --git a/regressions/ck_pr/benchmark/ck_pr_add_64.c b/regressions/ck_pr/benchmark/ck_pr_add_64.c new file mode 100644 index 0000000..9c4d51f --- /dev/null +++ b/regressions/ck_pr/benchmark/ck_pr_add_64.c @@ -0,0 +1,16 @@ +#include + +#ifdef CK_F_PR_ADD_64 +#define ATOMIC ck_pr_add_64(object, 1) +#define ATOMIC_STRING "ck_pr_add_64" +#include "benchmark.h" +#else +#warning Did not find ADD_64 implementation. +#include + +int +main(void) +{ + exit(EXIT_FAILURE); +} +#endif diff --git a/regressions/ck_pr/benchmark/ck_pr_cas_64.c b/regressions/ck_pr/benchmark/ck_pr_cas_64.c new file mode 100644 index 0000000..90dcb64 --- /dev/null +++ b/regressions/ck_pr/benchmark/ck_pr_cas_64.c @@ -0,0 +1,16 @@ +#include + +#ifdef CK_F_PR_CAS_64 +#define ATOMIC ck_pr_cas_64(object, 1, 1) +#define ATOMIC_STRING "ck_pr_cas_64" +#include "benchmark.h" +#else +#warning Did not find CAS_64 implementation. +#include + +int +main(void) +{ + exit(EXIT_FAILURE); +} +#endif diff --git a/regressions/ck_pr/benchmark/ck_pr_cas_64_2.c b/regressions/ck_pr/benchmark/ck_pr_cas_64_2.c new file mode 100644 index 0000000..e959b39 --- /dev/null +++ b/regressions/ck_pr/benchmark/ck_pr_cas_64_2.c @@ -0,0 +1,17 @@ +#include + +#ifdef CK_F_PR_CAS_64_2 +#define ATOMIC { uint64_t z[2] = {1, 2}; ck_pr_cas_64_2(object, z, z); } +#define ATOMIC_STRING "ck_pr_cas_64_2" +#include "benchmark.h" +#else +#include +#include + +int +main(void) +{ + fprintf(stderr, "Unsupported.\n"); + return 0; +} +#endif diff --git a/regressions/ck_pr/benchmark/ck_pr_faa_64.c b/regressions/ck_pr/benchmark/ck_pr_faa_64.c new file mode 100644 index 0000000..9bdc87d --- /dev/null +++ b/regressions/ck_pr/benchmark/ck_pr_faa_64.c @@ -0,0 +1,16 @@ +#include + +#ifdef CK_F_PR_FAA_64 +#define ATOMIC ck_pr_faa_64(object, 1) +#define ATOMIC_STRING "ck_pr_faa_64" +#include "benchmark.h" +#else +#warning Did not find FAA_64 implementation. +#include + +int +main(void) +{ + exit(EXIT_FAILURE); +} +#endif diff --git a/regressions/ck_pr/benchmark/ck_pr_fas_64.c b/regressions/ck_pr/benchmark/ck_pr_fas_64.c new file mode 100644 index 0000000..facd759 --- /dev/null +++ b/regressions/ck_pr/benchmark/ck_pr_fas_64.c @@ -0,0 +1,17 @@ +#include + +#ifdef CK_F_PR_FAS_64 +#define ATOMIC ck_pr_fas_64(object, 1) +#define ATOMIC_STRING "ck_pr_fas_64" +#include "benchmark.h" +#else +#warning Did not find FAS_64 implementation. +#include + +int +main(void) +{ + + return 0; +} +#endif diff --git a/regressions/ck_pr/benchmark/ck_pr_neg_64.c b/regressions/ck_pr/benchmark/ck_pr_neg_64.c new file mode 100644 index 0000000..d4e0ad9 --- /dev/null +++ b/regressions/ck_pr/benchmark/ck_pr_neg_64.c @@ -0,0 +1,16 @@ +#include + +#ifdef CK_F_PR_NEG_64 +#define ATOMIC ck_pr_neg_64(object) +#define ATOMIC_STRING "ck_pr_neg_64" +#include "benchmark.h" +#else +#warning Did not find NEG_64 implementation. +#include + +int +main(void) +{ + exit(EXIT_FAILURE); +} +#endif diff --git a/regressions/ck_pr/benchmark/fp.c b/regressions/ck_pr/benchmark/fp.c new file mode 100644 index 0000000..f7aa157 --- /dev/null +++ b/regressions/ck_pr/benchmark/fp.c @@ -0,0 +1,66 @@ +#include +#include +#include + +#include "../../common.h" + +#ifndef IR +#define IR 3000000 +#endif /* IR */ + +static int a CK_CC_CACHELINE; +static int b CK_CC_CACHELINE; + +int +main(void) +{ + uint64_t s, e; + unsigned int i; + + s = rdtsc(); + for (i = 0; i < IR; i++) { + ck_pr_load_int(&a); + ck_pr_fence_strict_load(); + ck_pr_load_int(&b); + } + e = rdtsc(); + printf("[A] fence_load: %" PRIu64 "\n", (e - s) / IR); + + s = rdtsc(); + for (i = 0; i < IR; i++) { + if (ck_pr_load_int(&a) == 0) + ck_pr_barrier(); + ck_pr_fence_strict_lock(); + ck_pr_load_int(&b); + } + e = rdtsc(); + printf("[A] fence_lock: %" PRIu64 "\n", (e - s) / IR); + + s = rdtsc(); + for (i = 0; i < IR; i++) { + ck_pr_store_int(&a, 0); + ck_pr_fence_strict_store(); + ck_pr_store_int(&b, 0); + } + e = rdtsc(); + printf("[B] fence_store: %" PRIu64 "\n", (e - s) / IR); + + s = rdtsc(); + for (i = 0; i < IR; i++) { + ck_pr_store_int(&a, 0); + ck_pr_fence_strict_memory(); + ck_pr_load_int(&b); + } + e = rdtsc(); + printf("[C] fence_memory: %" PRIu64 "\n", (e - s) / IR); + + s = rdtsc(); + for (i = 0; i < IR; i++) { + ck_pr_store_int(&a, 0); + ck_pr_faa_int(&a, 0); + ck_pr_load_int(&b); + } + e = rdtsc(); + printf("[C] atomic: %" PRIu64 "\n", (e - s) / IR); + return 0; +} -- cgit v1.2.3