--- /dev/null
+/*
+ * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, you can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * See the COPYRIGHT file distributed with this work for additional
+ * information regarding copyright ownership.
+ */
+
+#pragma once
+
+/*! \file */
+
+#include <pthread.h>
+#include <stdlib.h>
+
+#include <isc/atomic.h>
+#include <isc/lang.h>
+#include <isc/util.h>
+
+ISC_LANG_BEGINDECLS
+
+/*
+ * We use macros instead of static inline functions so that the exact code
+ * location can be reported when PTHREADS_RUNTIME_CHECK() fails or when mutrace
+ * reports lock contention.
+ */
+
+#ifdef ISC_TRACK_PTHREADS_OBJECTS
+
+#define isc_spinlock_init(sp) \
+ { \
+ *sp = malloc(sizeof(**sp)); \
+ isc__spinlock_init(*sp); \
+ }
+#define isc_spinlock_lock(sp) isc__spinlock_lock(*sp)
+#define isc_spinlock_unlock(sp) isc__spinlock_unlock(*sp)
+#define isc_spinlock_destroy(sp) \
+ { \
+ isc__spinlock_destroy(*sp); \
+ free((void *)*sp); \
+ }
+
+#else /* ISC_TRACK_PTHREADS_OBJECTS */
+
+#define isc_spinlock_init(sp) isc__spinlock_init(sp)
+#define isc_spinlock_lock(sp) isc__spinlock_lock(sp)
+#define isc_spinlock_unlock(sp) isc__spinlock_unlock(sp)
+#define isc_spinlock_destroy(sp) isc__spinlock_destroy(sp)
+
+#endif /* ISC_TRACK_PTHREADS_OBJECTS */
+
+#if HAVE_PTHREAD_SPIN_INIT
+
+#if ISC_TRACK_PTHREADS_OBJECTS
+typedef pthread_spinlock_t *isc_spinlock_t;
+#else /* ISC_TRACK_PTHREADS_OBJECTS */
+typedef pthread_spinlock_t isc_spinlock_t;
+#endif /* ISC_TRACK_PTHREADS_OBJECTS */
+
+#define isc__spinlock_init(sp) \
+ { \
+ int _ret = pthread_spin_init(sp, PTHREAD_PROCESS_PRIVATE); \
+ PTHREADS_RUNTIME_CHECK(pthread_spin_init, _ret); \
+ }
+
+#define isc__spinlock_lock(sp) \
+ { \
+ int _ret = pthread_spin_lock(sp); \
+ PTHREADS_RUNTIME_CHECK(pthread_spin_lock, _ret); \
+ }
+
+#define isc__spinlock_unlock(sp) \
+ { \
+ int _ret = pthread_spin_unlock(sp); \
+ PTHREADS_RUNTIME_CHECK(pthread_spin_unlock, _ret); \
+ }
+
+#define isc__spinlock_destroy(sp) \
+ { \
+ int _ret = pthread_spin_destroy(sp); \
+ PTHREADS_RUNTIME_CHECK(pthread_spin_destroy, _ret); \
+ }
+
+#else /* HAVE_PTHREAD_SPIN_INIT */
+
+#if ISC_TRACK_PTHREADS_OBJECTS
+typedef atomic_uint_fast32_t *isc_spinlock_t;
+#else /* ISC_TRACK_PTHREADS_OBJECTS */
+typedef atomic_uint_fast32_t isc_spinlock_t;
+#endif /* ISC_TRACK_PTHREADS_OBJECTS */
+
+#define isc__spinlock_init(sp) \
+ { \
+ atomic_init(sp, 0); \
+ }
+
+#define isc__spinlock_lock(sp) \
+ { \
+ while (!atomic_compare_exchange_weak_acq_rel( \
+ sp, &(uint_fast32_t){ 0 }, 1)) \
+ { \
+ do { \
+ isc_pause(); \
+ } while (atomic_load_relaxed(sp) != 0); \
+ } \
+ }
+
+#define isc__spinlock_unlock(sp) \
+ { \
+ atomic_store_release(sp, 0); \
+ }
+
+#define isc__spinlock_destroy(sp) \
+ { \
+ INSIST(atomic_load(sp) == 0); \
+ }
+
+#endif
+
+ISC_LANG_ENDDECLS
--- /dev/null
+/*
+ * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, you can obtain one at https://mozilla.org/MPL/2.0/.
+ *
+ * See the COPYRIGHT file distributed with this work for additional
+ * information regarding copyright ownership.
+ */
+
+#include <fcntl.h>
+#include <sched.h> /* IWYU pragma: keep */
+#include <setjmp.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define UNIT_TESTING
+#include <cmocka.h>
+
+#ifdef HAVE_PTHREAD_SPIN_INIT
+#define HAD_PTHREAD_SPIN_INIT 1
+#undef HAVE_PTHREAD_SPIN_INIT
+#endif
+
+#include <isc/atomic.h>
+#include <isc/file.h>
+#include <isc/mem.h>
+#include <isc/os.h>
+#include <isc/pause.h>
+#include <isc/result.h>
+#include <isc/spinlock.h>
+#include <isc/stdio.h>
+#include <isc/thread.h>
+#include <isc/time.h>
+#include <isc/util.h>
+
+#include <tests/isc.h>
+
+static unsigned int loops = 100;
+static unsigned int delay_loop = 1;
+
+static int
+setup_env(void **unused __attribute__((__unused__))) {
+ char *env = getenv("ISC_BENCHMARK_LOOPS");
+ if (env != NULL) {
+ loops = atoi(env);
+ }
+ assert_int_not_equal(loops, 0);
+
+ env = getenv("ISC_BENCHMARK_DELAY");
+ if (env != NULL) {
+ delay_loop = atoi(env);
+ }
+ assert_int_not_equal(delay_loop, 0);
+
+ return (0);
+}
+
+ISC_RUN_TEST_IMPL(isc_spinlock) {
+ isc_spinlock_t lock;
+
+ isc_spinlock_init(&lock);
+
+ for (size_t i = 0; i < loops; i++) {
+ isc_spinlock_lock(&lock);
+ isc_pause_n(delay_loop);
+ isc_spinlock_unlock(&lock);
+ }
+
+ isc_spinlock_destroy(&lock);
+}
+
+#define ITERS 20
+
+#define DC 200
+#define CNT_MIN 800
+#define CNT_MAX 1600
+
+static size_t shared_counter = 0;
+static size_t expected_counter = SIZE_MAX;
+
+#if HAD_PTHREAD_SPIN_INIT
+static pthread_spinlock_t spin;
+
+static isc_threadresult_t
+pthread_spin_thread(isc_threadarg_t arg) {
+ size_t cont = *(size_t *)arg;
+
+ for (size_t i = 0; i < loops; i++) {
+ pthread_spin_lock(&spin);
+ size_t v = shared_counter;
+ isc_pause_n(delay_loop);
+ shared_counter = v + 1;
+ pthread_spin_unlock(&spin);
+ isc_pause_n(cont);
+ }
+
+ return ((isc_threadresult_t)0);
+}
+#endif
+
+static isc_spinlock_t lock;
+
+static isc_threadresult_t
+isc_spinlock_thread(isc_threadarg_t arg) {
+ size_t cont = *(size_t *)arg;
+
+ for (size_t i = 0; i < loops; i++) {
+ isc_spinlock_lock(&lock);
+ size_t v = shared_counter;
+ isc_pause_n(delay_loop);
+ shared_counter = v + 1;
+ isc_spinlock_unlock(&lock);
+ isc_pause_n(cont);
+ }
+
+ return ((isc_threadresult_t)0);
+}
+
+ISC_RUN_TEST_IMPL(isc_spinlock_benchmark) {
+ isc_thread_t *threads = isc_mem_get(mctx, sizeof(*threads) * workers);
+ isc_time_t ts1, ts2;
+ double t;
+ int dc;
+ size_t cont;
+
+ memset(threads, 0, sizeof(*threads) * workers);
+
+ expected_counter = ITERS * workers * loops *
+ ((CNT_MAX - CNT_MIN) / DC + 1);
+
+ /* PTHREAD SPINLOCK */
+
+#if HAD_PTHREAD_SPIN_INIT
+ int r = pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE);
+ assert_int_not_equal(r, -1);
+
+ ts1 = isc_time_now_hires();
+
+ shared_counter = 0;
+ dc = DC;
+ for (size_t l = 0; l < ITERS; l++) {
+ for (cont = (dc > 0) ? CNT_MIN : CNT_MAX;
+ cont <= CNT_MAX && cont >= CNT_MIN; cont += dc)
+ {
+ for (size_t i = 0; i < workers; i++) {
+ isc_thread_create(pthread_spin_thread, &cont,
+ &threads[i]);
+ }
+ for (size_t i = 0; i < workers; i++) {
+ isc_thread_join(threads[i], NULL);
+ }
+ }
+ dc = -dc;
+ }
+ assert_int_equal(shared_counter, expected_counter);
+
+ ts2 = isc_time_now_hires();
+
+ t = isc_time_microdiff(&ts2, &ts1);
+
+ printf("[ TIME ] isc_spinlock_benchmark: %zu pthread_spin "
+ "loops in "
+ "%u threads, %2.3f seconds, %2.3f calls/second\n",
+ shared_counter, workers, t / 1000000.0,
+ shared_counter / (t / 1000000.0));
+
+ r = pthread_spin_destroy(&spin);
+ assert_int_not_equal(r, -1);
+#endif
+
+ /* ISC SPINLOCK */
+
+ isc_spinlock_init(&lock);
+
+ ts1 = isc_time_now_hires();
+
+ dc = DC;
+ shared_counter = 0;
+ for (size_t l = 0; l < ITERS; l++) {
+ for (cont = (dc > 0) ? CNT_MIN : CNT_MAX;
+ cont <= CNT_MAX && cont >= CNT_MIN; cont += dc)
+ {
+ for (size_t i = 0; i < workers; i++) {
+ isc_thread_create(isc_spinlock_thread, &cont,
+ &threads[i]);
+ }
+ for (size_t i = 0; i < workers; i++) {
+ isc_thread_join(threads[i], NULL);
+ }
+ }
+ dc = -dc;
+ }
+ assert_int_equal(shared_counter, expected_counter);
+
+ ts2 = isc_time_now_hires();
+
+ t = isc_time_microdiff(&ts2, &ts1);
+
+ printf("[ TIME ] isc_spinlock_benchmark: %zu isc_spinlock loops "
+ "in %u "
+ "threads, %2.3f seconds, %2.3f calls/second\n",
+ shared_counter, workers, t / 1000000.0,
+ shared_counter / (t / 1000000.0));
+
+ isc_spinlock_destroy(&lock);
+
+ isc_mem_put(mctx, threads, sizeof(*threads) * workers);
+}
+
+ISC_TEST_LIST_START
+
+ISC_TEST_ENTRY(isc_spinlock)
+#if !defined(__SANITIZE_THREAD__)
+ISC_TEST_ENTRY(isc_spinlock_benchmark)
+#endif /* __SANITIZE_THREAD__ */
+
+ISC_TEST_LIST_END
+
+ISC_TEST_MAIN_CUSTOM(setup_env, NULL)
projects / thirdparty / bind9.git / commitdiff
