Applied On 8 January 2015 at 14:39, Mike Holmes <[email protected]> wrote:
> > > On 8 January 2015 at 06:48, Mario Torrecillas Rodriguez < > [email protected]> wrote: > >> First set of synchronizer tests. This patch includes >> tests for locks, barriers and atomics. >> >> Signed-off-by: Mario Torrecillas Rodriguez < >> [email protected]> >> > > Reviewed-by: Mike Holmes <[email protected]> > > >> --- >> (This code contribution is provided under the terms of agreement >> LES-LTM-21309) >> >> Changes from previous version: >> Addressed issues after review >> Added new tests for atomics >> >> test/validation/.gitignore | 1 + >> test/validation/Makefile.am | 6 +- >> test/validation/odp_synchronizers.c | 1180 >> +++++++++++++++++++++++++++++++++++ >> 3 files changed, 1185 insertions(+), 2 deletions(-) >> create mode 100644 test/validation/odp_synchronizers.c >> >> diff --git a/test/validation/.gitignore b/test/validation/.gitignore >> index d08db73..c1c2aa2 100644 >> --- a/test/validation/.gitignore >> +++ b/test/validation/.gitignore >> @@ -8,3 +8,4 @@ odp_shm >> odp_system >> odp_pktio >> odp_buffer >> +odp_synchronizers >> diff --git a/test/validation/Makefile.am b/test/validation/Makefile.am >> index c0545b7..34af772 100644 >> --- a/test/validation/Makefile.am >> +++ b/test/validation/Makefile.am >> @@ -6,9 +6,9 @@ AM_LDFLAGS += -static >> TESTS_ENVIRONMENT = ODP_PLATFORM=${with_platform} >> >> if ODP_CUNIT_ENABLED >> -TESTS = odp_init odp_queue odp_crypto odp_shm odp_schedule odp_pktio_run >> odp_buffer odp_system >> +TESTS = odp_init odp_queue odp_crypto odp_shm odp_schedule odp_pktio_run >> odp_buffer odp_system odp_synchronizers >> check_PROGRAMS = ${bin_PROGRAMS} >> -bin_PROGRAMS = odp_init odp_queue odp_crypto odp_shm odp_schedule >> odp_pktio odp_buffer odp_system >> +bin_PROGRAMS = odp_init odp_queue odp_crypto odp_shm odp_schedule >> odp_pktio odp_buffer odp_system odp_synchronizers >> odp_crypto_CFLAGS = $(AM_CFLAGS) -I$(srcdir)/crypto >> odp_buffer_CFLAGS = $(AM_CFLAGS) -I$(srcdir)/buffer >> endif >> @@ -27,3 +27,5 @@ dist_odp_buffer_SOURCES = buffer/odp_buffer_pool_test.c >> \ >> buffer/odp_packet_test.c \ >> odp_buffer.c common/odp_cunit_common.c >> dist_odp_system_SOURCES = odp_system.c common/odp_cunit_common.c >> +dist_odp_synchronizers_SOURCES = odp_synchronizers.c \ >> + common/odp_cunit_common.c >> diff --git a/test/validation/odp_synchronizers.c >> b/test/validation/odp_synchronizers.c >> new file mode 100644 >> index 0000000..8d6c596 >> --- /dev/null >> +++ b/test/validation/odp_synchronizers.c >> @@ -0,0 +1,1180 @@ >> +/* Copyright (c) 2014, Linaro Limited >> > > The copyright date is incorrect but that can be changed when applied > > >> + * All rights reserved. >> + * >> + * SPDX-License-Identifier: BSD-3-Clause >> + */ >> + >> +#include <malloc.h> >> +#include <odp.h> >> +#include <CUnit/Basic.h> >> +#include <odp_cunit_common.h> >> + >> +#define VERBOSE 0 >> +#define MAX_ITERATIONS 1000 >> +#define BARRIER_ITERATIONS 64 >> + >> +#define SLOW_BARRIER_DELAY 400 >> +#define BASE_DELAY 6 >> +#define MIN_DELAY 1 >> + >> +#define NUM_TEST_BARRIERS BARRIER_ITERATIONS >> +#define NUM_RESYNC_BARRIERS 100 >> + >> +#define ADD_SUB_CNT 5 >> + >> +#define CNT 10 >> +#define BARRIER_DELAY 10 >> +#define U32_INIT_VAL (1UL << 10) >> +#define U64_INIT_VAL (1ULL << 33) >> + >> +#define GLOBAL_SHM_NAME "GlobalLockTest" >> + >> +#define UNUSED __attribute__((__unused__)) >> + >> +static odp_atomic_u32_t a32u; >> +static odp_atomic_u64_t a64u; >> + >> +typedef __volatile uint32_t volatile_u32_t; >> +typedef __volatile uint64_t volatile_u64_t; >> + >> +typedef struct { >> + odp_atomic_u32_t wait_cnt; >> +} custom_barrier_t; >> + >> +typedef struct { >> + /* Global variables */ >> + uint32_t g_num_threads; >> + uint32_t g_iterations; >> + uint32_t g_verbose; >> + uint32_t g_max_num_cores; >> + >> + odp_barrier_t test_barriers[NUM_TEST_BARRIERS]; >> + custom_barrier_t custom_barrier1; >> + custom_barrier_t custom_barrier2; >> + volatile_u32_t slow_thread_num; >> + volatile_u32_t barrier_cnt1; >> + volatile_u32_t barrier_cnt2; >> + odp_barrier_t global_barrier; >> + >> + /* Used to periodically resync within the lock functional tests */ >> + odp_barrier_t barrier_array[NUM_RESYNC_BARRIERS]; >> + >> + /* Locks */ >> + odp_spinlock_t global_spinlock; >> + odp_ticketlock_t global_ticketlock; >> + odp_rwlock_t global_rwlock; >> + >> + volatile_u32_t global_lock_owner; >> +} global_shared_mem_t; >> + >> +/* Per-thread memory */ >> +typedef struct { >> + global_shared_mem_t *global_mem; >> + >> + int thread_id; >> + int thread_core; >> + >> + odp_spinlock_t per_thread_spinlock; >> + odp_ticketlock_t per_thread_ticketlock; >> + odp_rwlock_t per_thread_rwlock; >> + >> + volatile_u64_t delay_counter; >> +} per_thread_mem_t; >> + >> +static odp_shm_t global_shm; >> +static global_shared_mem_t *global_mem; >> + >> +/* >> +* Delay a consistent amount of time. Ideally the amount of CPU time >> taken >> +* is linearly proportional to "iterations". The goal is to try to do >> some >> +* work that the compiler optimizer won't optimize away, and also to >> +* minimize loads and stores (at least to different memory addresses) >> +* so as to not affect or be affected by caching issues. This does NOT >> have to >> +* correlate to a specific number of cpu cycles or be consistent across >> +* CPU architectures. >> +*/ >> +static void thread_delay(per_thread_mem_t *per_thread_mem, uint32_t >> iterations) >> +{ >> + volatile_u64_t *counter_ptr; >> + uint32_t cnt; >> + >> + counter_ptr = &per_thread_mem->delay_counter; >> + >> + for (cnt = 1; cnt <= iterations; cnt++) >> + (*counter_ptr)++; >> +} >> + >> +/* Initialise per-thread memory */ >> +static per_thread_mem_t *thread_init(void) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + odp_shm_t global_shm; >> + uint32_t per_thread_mem_len; >> + >> + per_thread_mem_len = sizeof(per_thread_mem_t); >> + per_thread_mem = malloc(per_thread_mem_len); >> + memset(per_thread_mem, 0, per_thread_mem_len); >> + >> + per_thread_mem->delay_counter = 1; >> + >> + per_thread_mem->thread_id = odp_thread_id(); >> + per_thread_mem->thread_core = odp_thread_cpu(); >> + >> + global_shm = odp_shm_lookup(GLOBAL_SHM_NAME); >> + global_mem = odp_shm_addr(global_shm); >> + CU_ASSERT(global_mem != NULL); >> + >> + per_thread_mem->global_mem = global_mem; >> + >> + return per_thread_mem; >> +} >> + >> +static void thread_finalize(per_thread_mem_t *per_thread_mem) >> +{ >> + free(per_thread_mem); >> +} >> + >> +static void custom_barrier_init(custom_barrier_t *custom_barrier, >> + uint32_t num_threads) >> +{ >> + odp_atomic_store_u32(&custom_barrier->wait_cnt, num_threads); >> +} >> + >> +static void custom_barrier_wait(custom_barrier_t *custom_barrier) >> +{ >> + volatile_u64_t counter = 1; >> + uint32_t delay_cnt, wait_cnt; >> + >> + odp_atomic_sub_u32(&custom_barrier->wait_cnt, 1); >> + >> + wait_cnt = 1; >> + while (wait_cnt != 0) { >> + for (delay_cnt = 1; delay_cnt <= BARRIER_DELAY; >> delay_cnt++) >> + counter++; >> + >> + wait_cnt = odp_atomic_load_u32(&custom_barrier->wait_cnt); >> + } >> +} >> + >> +static uint32_t barrier_test(per_thread_mem_t *per_thread_mem, >> + odp_bool_t no_barrier_test) >> +{ >> + global_shared_mem_t *global_mem; >> + uint32_t barrier_errs, iterations, cnt, i_am_slow_thread; >> + uint32_t thread_num, slow_thread_num, next_slow_thread, >> num_threads; >> + uint32_t lock_owner_delay, barrier_cnt1, barrier_cnt2; >> + >> + thread_num = odp_thread_cpu() + 1; >> + global_mem = per_thread_mem->global_mem; >> + num_threads = global_mem->g_num_threads; >> + iterations = BARRIER_ITERATIONS; >> + >> + barrier_errs = 0; >> + lock_owner_delay = SLOW_BARRIER_DELAY; >> + >> + for (cnt = 1; cnt < iterations; cnt++) { >> + /* Wait here until all of the threads reach this point */ >> + custom_barrier_wait(&global_mem->custom_barrier1); >> + >> + barrier_cnt1 = global_mem->barrier_cnt1; >> + barrier_cnt2 = global_mem->barrier_cnt2; >> + >> + if ((barrier_cnt1 != cnt) || (barrier_cnt2 != cnt)) { >> + printf("thread_num=%u barrier_cnts of %u %u >> cnt=%u\n", >> + thread_num, barrier_cnt1, barrier_cnt2, >> cnt); >> + barrier_errs++; >> + } >> + >> + /* Wait here until all of the threads reach this point */ >> + custom_barrier_wait(&global_mem->custom_barrier2); >> + >> + slow_thread_num = global_mem->slow_thread_num; >> + i_am_slow_thread = thread_num == slow_thread_num; >> + next_slow_thread = slow_thread_num + 1; >> + if (num_threads < next_slow_thread) >> + next_slow_thread = 1; >> + >> + /* >> + * Now run the test, which involves having all but one >> thread >> + * immediately calling odp_barrier_wait(), and one thread >> wait a >> + * moderate amount of time and then calling >> odp_barrier_wait(). >> + * The test fails if any of the first group of threads >> + * has not waited for the "slow" thread. The "slow" thread >> is >> + * responsible for re-initializing the barrier for next >> trial. >> + */ >> + if (i_am_slow_thread) { >> + thread_delay(per_thread_mem, lock_owner_delay); >> + lock_owner_delay += BASE_DELAY; >> + if ((global_mem->barrier_cnt1 != cnt) || >> + (global_mem->barrier_cnt2 != cnt) || >> + (global_mem->slow_thread_num >> + != slow_thread_num)) >> + barrier_errs++; >> + } >> + >> + if (no_barrier_test == 0) >> + odp_barrier_wait(&global_mem->test_barriers[cnt]); >> + >> + global_mem->barrier_cnt1 = cnt + 1; >> + odp_sync_stores(); >> + >> + if (i_am_slow_thread) { >> + custom_barrier_init(&global_mem->custom_barrier1, >> + num_threads); >> + custom_barrier_init(&global_mem->custom_barrier2, >> + num_threads); >> + global_mem->slow_thread_num = next_slow_thread; >> + global_mem->barrier_cnt2 = cnt + 1; >> + odp_sync_stores(); >> + } else { >> + while (global_mem->barrier_cnt2 != (cnt + 1)) >> + thread_delay(per_thread_mem, BASE_DELAY); >> + } >> + } >> + >> + if ((global_mem->g_verbose) && (barrier_errs != 0)) >> + printf("\nThread %u (id=%d core=%d) had %u barrier_errs" >> + " in %u iterations\n", thread_num, >> + per_thread_mem->thread_id, >> + per_thread_mem->thread_core, barrier_errs, >> iterations); >> + >> + return barrier_errs; >> +} >> + >> +static void *no_barrier_functional_test(void *arg UNUSED) >> +{ >> + per_thread_mem_t *per_thread_mem; >> + uint32_t barrier_errs; >> + >> + per_thread_mem = thread_init(); >> + barrier_errs = barrier_test(per_thread_mem, 1); >> + >> + /* >> + * Note that the following CU_ASSERT MAY appear incorrect, but for >> the >> + * no_barrier test it should see barrier_errs or else there is >> something >> + * wrong with the test methodology or the ODP thread >> implementation. >> + * So this test PASSES only if it sees barrier_errs! >> + */ >> + CU_ASSERT(barrier_errs != 0); >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *barrier_functional_test(void *arg UNUSED) >> +{ >> + per_thread_mem_t *per_thread_mem; >> + uint32_t barrier_errs; >> + >> + per_thread_mem = thread_init(); >> + barrier_errs = barrier_test(per_thread_mem, 0); >> + >> + CU_ASSERT(barrier_errs == 0); >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void spinlock_api_test(odp_spinlock_t *spinlock) >> +{ >> + odp_spinlock_init(spinlock); >> + CU_ASSERT(odp_spinlock_is_locked(spinlock) == 0); >> + >> + odp_spinlock_lock(spinlock); >> + CU_ASSERT(odp_spinlock_is_locked(spinlock) == 1); >> + >> + odp_spinlock_unlock(spinlock); >> + CU_ASSERT(odp_spinlock_is_locked(spinlock) == 0); >> + >> + CU_ASSERT(odp_spinlock_trylock(spinlock) == 1); >> + >> + CU_ASSERT(odp_spinlock_is_locked(spinlock) == 1); >> + >> + odp_spinlock_unlock(spinlock); >> + CU_ASSERT(odp_spinlock_is_locked(spinlock) == 0); >> +} >> + >> +static void *spinlock_api_tests(void *arg UNUSED) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + odp_spinlock_t local_spin_lock; >> + >> + per_thread_mem = thread_init(); >> + global_mem = per_thread_mem->global_mem; >> + >> + odp_barrier_wait(&global_mem->global_barrier); >> + >> + spinlock_api_test(&local_spin_lock); >> + spinlock_api_test(&per_thread_mem->per_thread_spinlock); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void ticketlock_api_test(odp_ticketlock_t *ticketlock) >> +{ >> + odp_ticketlock_init(ticketlock); >> + CU_ASSERT(odp_ticketlock_is_locked(ticketlock) == 0); >> + >> + odp_ticketlock_lock(ticketlock); >> + CU_ASSERT(odp_ticketlock_is_locked(ticketlock) == 1); >> + >> + odp_ticketlock_unlock(ticketlock); >> + CU_ASSERT(odp_ticketlock_is_locked(ticketlock) == 0); >> + >> + CU_ASSERT(odp_ticketlock_trylock(ticketlock) == 1); >> + CU_ASSERT(odp_ticketlock_trylock(ticketlock) == 0); >> + CU_ASSERT(odp_ticketlock_is_locked(ticketlock) == 1); >> + >> + odp_ticketlock_unlock(ticketlock); >> + CU_ASSERT(odp_ticketlock_is_locked(ticketlock) == 0); >> +} >> + >> +static void *ticketlock_api_tests(void *arg UNUSED) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + odp_ticketlock_t local_ticket_lock; >> + >> + per_thread_mem = thread_init(); >> + global_mem = per_thread_mem->global_mem; >> + >> + odp_barrier_wait(&global_mem->global_barrier); >> + >> + ticketlock_api_test(&local_ticket_lock); >> + ticketlock_api_test(&per_thread_mem->per_thread_ticketlock); >> + >> + return NULL; >> +} >> + >> +static void rwlock_api_test(odp_rwlock_t *rw_lock) >> +{ >> + odp_rwlock_init(rw_lock); >> + /* CU_ASSERT(odp_rwlock_is_locked(rw_lock) == 0); */ >> + >> + odp_rwlock_read_lock(rw_lock); >> + odp_rwlock_read_unlock(rw_lock); >> + >> + odp_rwlock_write_lock(rw_lock); >> + /* CU_ASSERT(odp_rwlock_is_locked(rw_lock) == 1); */ >> + >> + odp_rwlock_write_unlock(rw_lock); >> + /* CU_ASSERT(odp_rwlock_is_locked(rw_lock) == 0); */ >> +} >> + >> +static void *rwlock_api_tests(void *arg UNUSED) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + odp_rwlock_t local_rwlock; >> + >> + per_thread_mem = thread_init(); >> + global_mem = per_thread_mem->global_mem; >> + >> + odp_barrier_wait(&global_mem->global_barrier); >> + >> + rwlock_api_test(&local_rwlock); >> + rwlock_api_test(&per_thread_mem->per_thread_rwlock); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *no_lock_functional_test(void *arg UNUSED) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + uint32_t thread_num, resync_cnt, rs_idx, iterations, cnt; >> + uint32_t sync_failures, current_errs, lock_owner_delay; >> + >> + thread_num = odp_thread_cpu() + 1; >> + per_thread_mem = thread_init(); >> + global_mem = per_thread_mem->global_mem; >> + iterations = global_mem->g_iterations; >> + >> + odp_barrier_wait(&global_mem->global_barrier); >> + >> + sync_failures = 0; >> + current_errs = 0; >> + rs_idx = 0; >> + resync_cnt = iterations / NUM_RESYNC_BARRIERS; >> + lock_owner_delay = BASE_DELAY; >> + >> + for (cnt = 1; cnt <= iterations; cnt++) { >> + global_mem->global_lock_owner = thread_num; >> + odp_sync_stores(); >> + thread_delay(per_thread_mem, lock_owner_delay); >> + >> + if (global_mem->global_lock_owner != thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + global_mem->global_lock_owner = 0; >> + odp_sync_stores(); >> + thread_delay(per_thread_mem, MIN_DELAY); >> + >> + if (global_mem->global_lock_owner == thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + if (current_errs == 0) >> + lock_owner_delay++; >> + >> + /* Wait a small amount of time and rerun the test */ >> + thread_delay(per_thread_mem, BASE_DELAY); >> + >> + /* Try to resync all of the threads to increase >> contention */ >> + if ((rs_idx < NUM_RESYNC_BARRIERS) && >> + ((cnt % resync_cnt) == (resync_cnt - 1))) >> + >> odp_barrier_wait(&global_mem->barrier_array[rs_idx++]); >> + } >> + >> + if (global_mem->g_verbose) >> + printf("\nThread %u (id=%d core=%d) had %u sync_failures" >> + " in %u iterations\n", thread_num, >> + per_thread_mem->thread_id, >> + per_thread_mem->thread_core, >> + sync_failures, iterations); >> + >> + /* Note that the following CU_ASSERT MAY appear incorrect, but >> for the >> + * no_lock test it should see sync_failures or else there is >> something >> + * wrong with the test methodology or the ODP thread >> implementation. >> + * So this test PASSES only if it sees sync_failures >> + */ >> + CU_ASSERT(sync_failures != 0); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *spinlock_functional_test(void *arg UNUSED) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + uint32_t thread_num, resync_cnt, rs_idx, iterations, cnt; >> + uint32_t sync_failures, is_locked_errs, current_errs; >> + uint32_t lock_owner_delay; >> + >> + thread_num = odp_thread_cpu() + 1; >> + per_thread_mem = thread_init(); >> + global_mem = per_thread_mem->global_mem; >> + iterations = global_mem->g_iterations; >> + >> + odp_barrier_wait(&global_mem->global_barrier); >> + >> + sync_failures = 0; >> + is_locked_errs = 0; >> + current_errs = 0; >> + rs_idx = 0; >> + resync_cnt = iterations / NUM_RESYNC_BARRIERS; >> + lock_owner_delay = BASE_DELAY; >> + >> + for (cnt = 1; cnt <= iterations; cnt++) { >> + /* Acquire the shared global lock */ >> + odp_spinlock_lock(&global_mem->global_spinlock); >> + >> + /* Make sure we have the lock AND didn't previously own >> it */ >> + if (odp_spinlock_is_locked(&global_mem->global_spinlock) >> != 1) >> + is_locked_errs++; >> + >> + if (global_mem->global_lock_owner != 0) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + /* Now set the global_lock_owner to be us, wait a while, >> and >> + * then we see if anyone else has snuck in and changed the >> + * global_lock_owner to be themselves >> + */ >> + global_mem->global_lock_owner = thread_num; >> + odp_sync_stores(); >> + thread_delay(per_thread_mem, lock_owner_delay); >> + if (global_mem->global_lock_owner != thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + /* Release shared lock, and make sure we no longer have >> it */ >> + global_mem->global_lock_owner = 0; >> + odp_sync_stores(); >> + odp_spinlock_unlock(&global_mem->global_spinlock); >> + if (global_mem->global_lock_owner == thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + if (current_errs == 0) >> + lock_owner_delay++; >> + >> + /* Wait a small amount of time and rerun the test */ >> + thread_delay(per_thread_mem, BASE_DELAY); >> + >> + /* Try to resync all of the threads to increase >> contention */ >> + if ((rs_idx < NUM_RESYNC_BARRIERS) && >> + ((cnt % resync_cnt) == (resync_cnt - 1))) >> + >> odp_barrier_wait(&global_mem->barrier_array[rs_idx++]); >> + } >> + >> + if ((global_mem->g_verbose) && >> + ((sync_failures != 0) || (is_locked_errs != 0))) >> + printf("\nThread %u (id=%d core=%d) had %u sync_failures" >> + " and %u is_locked_errs in %u iterations\n", >> thread_num, >> + per_thread_mem->thread_id, >> per_thread_mem->thread_core, >> + sync_failures, is_locked_errs, iterations); >> + >> + CU_ASSERT(sync_failures == 0); >> + CU_ASSERT(is_locked_errs == 0); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *ticketlock_functional_test(void *arg UNUSED) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + uint32_t thread_num, resync_cnt, rs_idx, iterations, cnt; >> + uint32_t sync_failures, is_locked_errs, current_errs; >> + uint32_t lock_owner_delay; >> + >> + thread_num = odp_thread_cpu() + 1; >> + per_thread_mem = thread_init(); >> + global_mem = per_thread_mem->global_mem; >> + iterations = global_mem->g_iterations; >> + >> + /* Wait here until all of the threads have also reached this >> point */ >> + odp_barrier_wait(&global_mem->global_barrier); >> + >> + sync_failures = 0; >> + is_locked_errs = 0; >> + current_errs = 0; >> + rs_idx = 0; >> + resync_cnt = iterations / NUM_RESYNC_BARRIERS; >> + lock_owner_delay = BASE_DELAY; >> + >> + for (cnt = 1; cnt <= iterations; cnt++) { >> + /* Acquire the shared global lock */ >> + odp_ticketlock_lock(&global_mem->global_ticketlock); >> + >> + /* Make sure we have the lock AND didn't previously own >> it */ >> + if >> (odp_ticketlock_is_locked(&global_mem->global_ticketlock) >> + != 1) >> + is_locked_errs++; >> + >> + if (global_mem->global_lock_owner != 0) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + /* Now set the global_lock_owner to be us, wait a while, >> and >> + * then we see if anyone else has snuck in and changed the >> + * global_lock_owner to be themselves >> + */ >> + global_mem->global_lock_owner = thread_num; >> + odp_sync_stores(); >> + thread_delay(per_thread_mem, lock_owner_delay); >> + if (global_mem->global_lock_owner != thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + /* Release shared lock, and make sure we no longer have >> it */ >> + global_mem->global_lock_owner = 0; >> + odp_sync_stores(); >> + odp_ticketlock_unlock(&global_mem->global_ticketlock); >> + if (global_mem->global_lock_owner == thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + if (current_errs == 0) >> + lock_owner_delay++; >> + >> + /* Wait a small amount of time and then rerun the test */ >> + thread_delay(per_thread_mem, BASE_DELAY); >> + >> + /* Try to resync all of the threads to increase >> contention */ >> + if ((rs_idx < NUM_RESYNC_BARRIERS) && >> + ((cnt % resync_cnt) == (resync_cnt - 1))) >> + >> odp_barrier_wait(&global_mem->barrier_array[rs_idx++]); >> + } >> + >> + if ((global_mem->g_verbose) && >> + ((sync_failures != 0) || (is_locked_errs != 0))) >> + printf("\nThread %u (id=%d core=%d) had %u sync_failures" >> + " and %u is_locked_errs in %u iterations\n", >> thread_num, >> + per_thread_mem->thread_id, >> per_thread_mem->thread_core, >> + sync_failures, is_locked_errs, iterations); >> + >> + CU_ASSERT(sync_failures == 0); >> + CU_ASSERT(is_locked_errs == 0); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *rwlock_functional_test(void *arg UNUSED) >> +{ >> + global_shared_mem_t *global_mem; >> + per_thread_mem_t *per_thread_mem; >> + uint32_t thread_num, resync_cnt, rs_idx, iterations, cnt; >> + uint32_t sync_failures, current_errs, lock_owner_delay; >> + >> + thread_num = odp_thread_cpu() + 1; >> + per_thread_mem = thread_init(); >> + global_mem = per_thread_mem->global_mem; >> + iterations = global_mem->g_iterations; >> + >> + /* Wait here until all of the threads have also reached this >> point */ >> + odp_barrier_wait(&global_mem->global_barrier); >> + >> + sync_failures = 0; >> + current_errs = 0; >> + rs_idx = 0; >> + resync_cnt = iterations / NUM_RESYNC_BARRIERS; >> + lock_owner_delay = BASE_DELAY; >> + >> + for (cnt = 1; cnt <= iterations; cnt++) { >> + /* Acquire the shared global lock */ >> + odp_rwlock_write_lock(&global_mem->global_rwlock); >> + >> + /* Make sure we have lock now AND didn't previously own >> it */ >> + if (global_mem->global_lock_owner != 0) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + /* Now set the global_lock_owner to be us, wait a while, >> and >> + * then we see if anyone else has snuck in and changed the >> + * global_lock_owner to be themselves >> + */ >> + global_mem->global_lock_owner = thread_num; >> + odp_sync_stores(); >> + thread_delay(per_thread_mem, lock_owner_delay); >> + if (global_mem->global_lock_owner != thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + /* Release shared lock, and make sure we no longer have >> it */ >> + global_mem->global_lock_owner = 0; >> + odp_sync_stores(); >> + odp_rwlock_write_unlock(&global_mem->global_rwlock); >> + if (global_mem->global_lock_owner == thread_num) { >> + current_errs++; >> + sync_failures++; >> + } >> + >> + if (current_errs == 0) >> + lock_owner_delay++; >> + >> + /* Wait a small amount of time and then rerun the test */ >> + thread_delay(per_thread_mem, BASE_DELAY); >> + >> + /* Try to resync all of the threads to increase >> contention */ >> + if ((rs_idx < NUM_RESYNC_BARRIERS) && >> + ((cnt % resync_cnt) == (resync_cnt - 1))) >> + >> odp_barrier_wait(&global_mem->barrier_array[rs_idx++]); >> + } >> + >> + if ((global_mem->g_verbose) && (sync_failures != 0)) >> + printf("\nThread %u (id=%d core=%d) had %u sync_failures" >> + " in %u iterations\n", thread_num, >> + per_thread_mem->thread_id, >> + per_thread_mem->thread_core, >> + sync_failures, iterations); >> + >> + CU_ASSERT(sync_failures == 0); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void barrier_test_init(void) >> +{ >> + uint32_t num_threads, idx; >> + >> + num_threads = global_mem->g_num_threads; >> + >> + for (idx = 0; idx < NUM_TEST_BARRIERS; idx++) >> + odp_barrier_init(&global_mem->test_barriers[idx], >> num_threads); >> + >> + custom_barrier_init(&global_mem->custom_barrier1, num_threads); >> + custom_barrier_init(&global_mem->custom_barrier2, num_threads); >> + >> + global_mem->slow_thread_num = 1; >> + global_mem->barrier_cnt1 = 1; >> + global_mem->barrier_cnt2 = 1; >> +} >> + >> +static void test_atomic_inc_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_inc_u32(&a32u); >> +} >> + >> +static void test_atomic_inc_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_inc_u64(&a64u); >> +} >> + >> +static void test_atomic_dec_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_dec_u32(&a32u); >> +} >> + >> +static void test_atomic_dec_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_dec_u64(&a64u); >> +} >> + >> +static void test_atomic_fetch_inc_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_inc_u32(&a32u); >> +} >> + >> +static void test_atomic_fetch_inc_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_inc_u64(&a64u); >> +} >> + >> +static void test_atomic_fetch_dec_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_dec_u32(&a32u); >> +} >> + >> +static void test_atomic_fetch_dec_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_dec_u64(&a64u); >> +} >> + >> +static void test_atomic_add_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_add_u32(&a32u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_add_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_add_u64(&a64u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_sub_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_sub_u32(&a32u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_sub_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_sub_u64(&a64u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_fetch_add_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_add_u32(&a32u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_fetch_add_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_add_u64(&a64u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_fetch_sub_32(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_sub_u32(&a32u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_fetch_sub_64(void) >> +{ >> + int i; >> + >> + for (i = 0; i < CNT; i++) >> + odp_atomic_fetch_sub_u64(&a64u, ADD_SUB_CNT); >> +} >> + >> +static void test_atomic_inc_dec_32(void) >> +{ >> + test_atomic_inc_32(); >> + test_atomic_dec_32(); >> +} >> + >> +static void test_atomic_inc_dec_64(void) >> +{ >> + test_atomic_inc_64(); >> + test_atomic_dec_64(); >> +} >> + >> +static void test_atomic_fetch_inc_dec_32(void) >> +{ >> + test_atomic_fetch_inc_32(); >> + test_atomic_fetch_dec_32(); >> +} >> + >> +static void test_atomic_fetch_inc_dec_64(void) >> +{ >> + test_atomic_fetch_inc_64(); >> + test_atomic_fetch_dec_64(); >> +} >> + >> +static void test_atomic_add_sub_32(void) >> +{ >> + test_atomic_add_32(); >> + test_atomic_sub_32(); >> +} >> + >> + >> +static void test_atomic_add_sub_64(void) >> +{ >> + test_atomic_add_64(); >> + test_atomic_sub_64(); >> +} >> + >> +static void test_atomic_fetch_add_sub_32(void) >> +{ >> + test_atomic_fetch_add_32(); >> + test_atomic_fetch_sub_32(); >> +} >> + >> +static void test_atomic_fetch_add_sub_64(void) >> +{ >> + test_atomic_fetch_add_64(); >> + test_atomic_fetch_sub_64(); >> +} >> + >> +static void test_atomic_init(void) >> +{ >> + odp_atomic_init_u32(&a32u, 0); >> + odp_atomic_init_u64(&a64u, 0); >> +} >> + >> +static void test_atomic_store(void) >> +{ >> + odp_atomic_store_u32(&a32u, U32_INIT_VAL); >> + odp_atomic_store_u64(&a64u, U64_INIT_VAL); >> +} >> + >> +static void test_atomic_validate(void) >> +{ >> + CU_ASSERT(U32_INIT_VAL == odp_atomic_load_u32(&a32u)); >> + CU_ASSERT(U64_INIT_VAL == odp_atomic_load_u64(&a64u)); >> +} >> + >> +/* Barrier tests */ >> +static void test_no_barrier_functional(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + barrier_test_init(); >> + odp_cunit_thread_create(no_barrier_functional_test, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static void test_barrier_functional(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + barrier_test_init(); >> + odp_cunit_thread_create(barrier_functional_test, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static CU_TestInfo test_odp_barrier[] = { >> + {"no_barrier_functional", test_no_barrier_functional}, >> + {"barrier_functional", test_barrier_functional}, >> + CU_TEST_INFO_NULL >> +}; >> + >> +/* Thread-unsafe tests */ >> +static void test_no_lock_functional(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + odp_cunit_thread_create(no_lock_functional_test, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static CU_TestInfo test_no_locking[] = { >> + {"no_lock_functional", test_no_lock_functional}, >> + CU_TEST_INFO_NULL >> +}; >> + >> +/* Spin lock tests */ >> +static void test_spinlock_api(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + odp_cunit_thread_create(spinlock_api_tests, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static void test_spinlock_functional(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + odp_spinlock_init(&global_mem->global_spinlock); >> + odp_cunit_thread_create(spinlock_functional_test, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static CU_TestInfo test_odp_spinlock[] = { >> + {"spinlock_api", test_spinlock_api}, >> + {"spinlock_functional", test_spinlock_functional}, >> + CU_TEST_INFO_NULL >> +}; >> + >> +/* Ticket lock tests */ >> +static void test_ticketlock_api(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + odp_cunit_thread_create(ticketlock_api_tests, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static void test_ticketlock_functional(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + odp_ticketlock_init(&global_mem->global_ticketlock); >> + >> + odp_cunit_thread_create(ticketlock_functional_test, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static CU_TestInfo test_odp_ticketlock[] = { >> + {"ticketlock_api", test_ticketlock_api}, >> + {"ticketlock_functional", test_ticketlock_functional}, >> + CU_TEST_INFO_NULL >> +}; >> + >> +/* RW lock tests */ >> +static void test_rwlock_api(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + odp_cunit_thread_create(rwlock_api_tests, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static void test_rwlock_functional(void) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + odp_rwlock_init(&global_mem->global_rwlock); >> + odp_cunit_thread_create(rwlock_functional_test, &arg); >> + odp_cunit_thread_exit(&arg); >> +} >> + >> +static CU_TestInfo test_odp_rwlock[] = { >> + {"rwlock_api", test_rwlock_api}, >> + {"rwlock_functional", test_rwlock_functional}, >> + CU_TEST_INFO_NULL >> +}; >> + >> + >> +static int init_locks(void) >> +{ >> + uint32_t num_threads, idx; >> + >> + num_threads = global_mem->g_num_threads; >> + odp_barrier_init(&global_mem->global_barrier, num_threads); >> + for (idx = 0; idx < NUM_RESYNC_BARRIERS; idx++) >> + odp_barrier_init(&global_mem->barrier_array[idx], >> num_threads); >> + >> + return 0; >> +} >> + >> +int tests_global_init(void) >> +{ >> + uint32_t core_count, max_threads; >> + int ret = 0; >> + >> + global_shm = odp_shm_reserve(GLOBAL_SHM_NAME, >> + sizeof(global_shared_mem_t), 64, >> + ODP_SHM_SW_ONLY | ODP_SHM_PROC); >> + global_mem = odp_shm_addr(global_shm); >> + memset(global_mem, 0, sizeof(global_shared_mem_t)); >> + >> + global_mem->g_num_threads = MAX_WORKERS; >> + global_mem->g_iterations = MAX_ITERATIONS; >> + global_mem->g_verbose = VERBOSE; >> + >> + core_count = odp_sys_cpu_count(); >> + >> + max_threads = (core_count >= MAX_WORKERS) ? MAX_WORKERS : >> core_count; >> + >> + if (max_threads < global_mem->g_num_threads) { >> + printf("Requested num of threads is too large\n"); >> + printf("reducing from %u to %u\n", >> global_mem->g_num_threads, >> + max_threads); >> + global_mem->g_num_threads = max_threads; >> + } >> + >> + printf("Num of threads used = %u\n", global_mem->g_num_threads); >> + >> + return ret; >> +} >> + >> +/* Atomic tests */ >> +static void *test_atomic_inc_dec_thread(void *arg UNUSED) >> +{ >> + per_thread_mem_t *per_thread_mem; >> + >> + per_thread_mem = thread_init(); >> + test_atomic_inc_dec_32(); >> + test_atomic_inc_dec_64(); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *test_atomic_add_sub_thread(void *arg UNUSED) >> +{ >> + per_thread_mem_t *per_thread_mem; >> + >> + per_thread_mem = thread_init(); >> + test_atomic_add_sub_32(); >> + test_atomic_add_sub_64(); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *test_atomic_fetch_inc_dec_thread(void *arg UNUSED) >> +{ >> + per_thread_mem_t *per_thread_mem; >> + >> + per_thread_mem = thread_init(); >> + test_atomic_fetch_inc_dec_32(); >> + test_atomic_fetch_inc_dec_64(); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void *test_atomic_fetch_add_sub_thread(void *arg UNUSED) >> +{ >> + per_thread_mem_t *per_thread_mem; >> + >> + per_thread_mem = thread_init(); >> + test_atomic_fetch_add_sub_32(); >> + test_atomic_fetch_add_sub_64(); >> + >> + thread_finalize(per_thread_mem); >> + >> + return NULL; >> +} >> + >> +static void test_atomic_functional(void *func_ptr(void *)) >> +{ >> + pthrd_arg arg; >> + arg.numthrds = global_mem->g_num_threads; >> + >> + test_atomic_init(); >> + test_atomic_store(); >> + odp_cunit_thread_create(func_ptr, &arg); >> + odp_cunit_thread_exit(&arg); >> + test_atomic_validate(); >> +} >> + >> +static void test_atomic_inc_dec(void) >> +{ >> + test_atomic_functional(test_atomic_inc_dec_thread); >> +} >> + >> +static void test_atomic_add_sub(void) >> +{ >> + test_atomic_functional(test_atomic_add_sub_thread); >> +} >> + >> +static void test_atomic_fetch_inc_dec(void) >> +{ >> + test_atomic_functional(test_atomic_fetch_inc_dec_thread); >> +} >> + >> +static void test_atomic_fetch_add_sub(void) >> +{ >> + test_atomic_functional(test_atomic_fetch_add_sub_thread); >> +} >> + >> +CU_TestInfo test_odp_atomic[] = { >> + {"atomic_inc_dec", test_atomic_inc_dec}, >> + {"atomic_add_sub", test_atomic_add_sub}, >> + {"atomic_fetch_inc_dec", test_atomic_fetch_inc_dec}, >> + {"atomic_fetch_add_sub", test_atomic_fetch_add_sub}, >> + CU_TEST_INFO_NULL, >> +}; >> + >> +CU_SuiteInfo odp_testsuites[] = { >> + {"barrier", NULL, NULL, NULL, NULL, test_odp_barrier}, >> + {"nolocking", init_locks, NULL, NULL, NULL, test_no_locking}, >> + {"spinlock", init_locks, NULL, NULL, NULL, test_odp_spinlock}, >> + {"ticketlock", init_locks, NULL, NULL, NULL, test_odp_ticketlock}, >> + {"rwlock", init_locks, NULL, NULL, NULL, test_odp_rwlock}, >> + {"atomic", NULL, NULL, NULL, NULL, test_odp_atomic}, >> + CU_SUITE_INFO_NULL >> +}; >> -- >> 1.9.1 >> >> >> >> _______________________________________________ >> lng-odp mailing list >> [email protected] >> http://lists.linaro.org/mailman/listinfo/lng-odp >> > > > > -- > *Mike Holmes* > Linaro Sr Technical Manager > LNG - ODP > -- *Mike Holmes* Linaro Sr Technical Manager LNG - ODP
_______________________________________________ lng-odp mailing list [email protected] http://lists.linaro.org/mailman/listinfo/lng-odp
