I think this may have to come out again - can anyone confirm this behaviour Regression started running this multiple times and it is hanging with high load maybe 5% of the time.
Tasks: 333 total, 1 running, 332 sleeping, 0 stopped, 0 zombie %Cpu(s): 99.6 us, 0.2 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.2 si, 0.0 st KiB Mem: 12255088 total, 8953084 used, 3302004 free, 852512 buffers KiB Swap: 9765884 total, 541220 used, 9224664 free. 2098512 cached Mem PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 16722 mike 20 0 615248 11192 10840 S 776.6 0.1 2:04.82 odp_synchronize On 9 January 2015 at 09:59, Mike Holmes <[email protected]> wrote: > 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 > -- *Mike Holmes* Linaro Sr Technical Manager LNG - ODP
_______________________________________________ lng-odp mailing list [email protected] http://lists.linaro.org/mailman/listinfo/lng-odp
