@@ -33,12 +33,9 @@ DOT_IMAGE_FORMAT = svg
PREDEFINED = __GNUC__ \
__attribute__(x)= \
ODP_ALIGNED(x)= \
- ODPDRV_ALIGNED(x)= \
__BIG_ENDIAN_BITFIELD \
__LITTLE_ENDIAN_BITFIELD \
__x86_64__ \
ODP_PACKED \
- ODPDRV_PACKED \
ODP_DEPRECATE(x)=x \
- "ODP_HANDLE_T(type)=odp_handle_t type" \
- "ODPDRV_HANDLE_T(type)=odpdrv_handle_t type"
+ "ODP_HANDLE_T(type)=odp_handle_t type"
@@ -1,7 +1,6 @@
include_HEADERS = \
odp.h \
- odp_api.h \
- odp_drv.h
+ odp_api.h
odpapispecincludedir= $(includedir)/odp/api/spec
odpapispecinclude_HEADERS = \
@@ -54,19 +53,6 @@ nodist_odpapispecinclude_HEADERS = \
odp/api/spec/deprecated.h \
odp/api/spec/version.h
-odpdrvspecincludedir= $(includedir)/odp/drv/spec
-odpdrvspecinclude_HEADERS = \
- odp/drv/spec/align.h \
- odp/drv/spec/atomic.h \
- odp/drv/spec/barrier.h \
- odp/drv/spec/byteorder.h \
- odp/drv/spec/compiler.h \
- odp/drv/spec/driver.h \
- odp/drv/spec/shm.h \
- odp/drv/spec/spinlock.h \
- odp/drv/spec/std_types.h \
- odp/drv/spec/sync.h
-
odpapiabidefaultincludedir= $(includedir)/odp/arch/default/api/abi
odpapiabidefaultinclude_HEADERS = \
odp/arch/default/api/abi/buffer.h \
deleted file mode 100644
@@ -1,78 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV alignments
- */
-
-#ifndef ODPDRV_API_ALIGN_H_
-#define ODPDRV_API_ALIGN_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @addtogroup odpdrv_compiler_optim
- * Macros that allow cache line size configuration, check that
- * alignment is a power of two etc.
- * @{
- */
-
-/* Checkpatch complains, but cannot use __aligned(size) for this purpose. */
-
-/**
- * @def ODPDRV_ALIGNED
- * Defines type/struct/variable alignment in bytes
- */
-
-/**
- * @def ODPDRV_PACKED
- * Defines type/struct to be packed
- */
-
-/**
- * @def ODPDRV_OFFSETOF
- * Returns offset of member in type
- */
-
-/**
- * @def ODPDRV_FIELD_SIZEOF
- * Returns sizeof member
- */
-
-/**
- * @def ODPDRV_CACHE_LINE_SIZE
- * Cache line size
- */
-
-/**
- * @def ODPDRV_PAGE_SIZE
- * Page size
- */
-
-/**
- * @def ODPDRV_ALIGNED_CACHE
- * Defines type/struct/variable to be cache line size aligned
- */
-
-/**
- * @def ODPDRV_ALIGNED_PAGE
- * Defines type/struct/variable to be page size aligned
- */
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,634 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV atomic operations
- */
-
-#ifndef ODPDRV_API_ATOMIC_H_
-#define ODPDRV_API_ATOMIC_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @defgroup odpdrv_atomic ODPDRV ATOMIC
- * @details
- * <b> Atomic integers using relaxed memory ordering </b>
- *
- * Atomic integer types (odpdrv_atomic_u32_t and odpdrv_atomic_u64_t) can be
- * used to implement e.g. shared counters. If not otherwise documented,
- * operations in this API are implemented using <b> RELAXED memory ordering </b>
- * (see memory order descriptions in the C11 specification). Relaxed operations
- * do not provide synchronization or ordering for other memory accesses
- * (initiated before or after the operation), only atomicity of the operation
- * itself is guaranteed.
- *
- * <b> Operations with non-relaxed memory ordering </b>
- *
- * <b> An operation with RELEASE </b> memory ordering
- * (odpdrv_atomic_xxx_rel_xxx()) ensures that other threads loading the same
- * atomic variable with ACQUIRE memory ordering see all stores (from the
- * calling thread) that happened before this releasing store.
- *
- * <b> An operation with ACQUIRE </b> memory ordering
- * (odpdrv_atomic_xxx_acq_xxx()) ensures that the calling thread sees all stores
- * (done by the releasing thread) that happened before a RELEASE memory ordered
- * store to the same atomic variable.
- *
- * <b> An operation with ACQUIRE-and-RELEASE </b> memory ordering
- * (odpdrv_atomic_xxx_acq_rel_xxx()) combines the effects of ACQUIRE and RELEASE
- * memory orders. A single operation acts as both an acquiring load and
- * a releasing store.
- *
- * @{
- */
-
-/**
- * @typedef odpdrv_atomic_u64_t
- * Atomic 64-bit unsigned integer
- *
- * @typedef odpdrv_atomic_u32_t
- * Atomic 32-bit unsigned integer
- */
-
-/*
- * 32-bit operations in RELAXED memory ordering
- * --------------------------------------------
- */
-
-/**
- * Initialize atomic uint32 variable
- *
- * Initializes the atomic variable with 'val'. This operation is not atomic.
- * Drivers must ensure that there's no race condition while initializing
- * the variable.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to initialize the variable with
- */
-void odpdrv_atomic_init_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Load value of atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable
- */
-uint32_t odpdrv_atomic_load_u32(odpdrv_atomic_u32_t *atom);
-
-/**
- * Store value to atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to store in the variable
- */
-void odpdrv_atomic_store_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Fetch and add to atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be added to the variable
- *
- * @return Value of the variable before the addition
- */
-uint32_t odpdrv_atomic_fetch_add_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Add to atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be added to the variable
- */
-void odpdrv_atomic_add_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Fetch and subtract from atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be subracted from the variable
- *
- * @return Value of the variable before the subtraction
- */
-uint32_t odpdrv_atomic_fetch_sub_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Subtract from atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be subtracted from the variable
- */
-void odpdrv_atomic_sub_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Fetch and increment atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable before the increment
- */
-uint32_t odpdrv_atomic_fetch_inc_u32(odpdrv_atomic_u32_t *atom);
-
-/**
- * Increment atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- */
-void odpdrv_atomic_inc_u32(odpdrv_atomic_u32_t *atom);
-
-/**
- * Fetch and decrement atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable before the subtraction
- */
-uint32_t odpdrv_atomic_fetch_dec_u32(odpdrv_atomic_u32_t *atom);
-
-/**
- * Decrement atomic uint32 variable
- *
- * @param atom Pointer to atomic variable
- */
-void odpdrv_atomic_dec_u32(odpdrv_atomic_u32_t *atom);
-
-/**
- * Update maximum value of atomic uint32 variable
- *
- * Compares value of atomic variable to the new maximum value. If the new value
- * is greater than the current value, writes the new value into the variable.
- *
- * @param atom Pointer to atomic variable
- * @param new_max New maximum value to be written into the atomic variable
- */
-void odpdrv_atomic_max_u32(odpdrv_atomic_u32_t *atom, uint32_t new_max);
-
-/**
- * Update minimum value of atomic uint32 variable
- *
- * Compares value of atomic variable to the new minimum value. If the new value
- * is less than the current value, writes the new value into the variable.
- *
- * @param atom Pointer to atomic variable
- * @param new_min New minimum value to be written into the atomic variable
- */
-void odpdrv_atomic_min_u32(odpdrv_atomic_u32_t *atom, uint32_t new_min);
-
-/**
- * Compare and swap atomic uint32 variable
- *
- * Compares value of atomic variable to the value pointed by 'old_val'.
- * If values are equal, the operation writes 'new_val' into the atomic variable
- * and returns success. If they are not equal, the operation writes current
- * value of atomic variable into 'old_val' and returns failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- *
- */
-int odpdrv_atomic_cas_u32(odpdrv_atomic_u32_t *atom, uint32_t *old_val,
- uint32_t new_val);
-
-/**
- * Exchange value of atomic uint32 variable
- *
- * Atomically replaces the value of atomic variable with the new value. Returns
- * the old value.
- *
- * @param atom Pointer to atomic variable
- * @param new_val New value of the atomic variable
- *
- * @return Value of the variable before the operation
- */
-uint32_t odpdrv_atomic_xchg_u32(odpdrv_atomic_u32_t *atom, uint32_t new_val);
-
-/*
- * 64-bit operations in RELAXED memory ordering
- * --------------------------------------------
- */
-
-/**
- * Initialize atomic uint64 variable
- *
- * Initializes the atomic variable with 'val'. This operation is not atomic.
- * Drivers must ensure that there's no race condition while initializing
- * the variable.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to initialize the variable with
- */
-void odpdrv_atomic_init_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Load value of atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable
- */
-uint64_t odpdrv_atomic_load_u64(odpdrv_atomic_u64_t *atom);
-
-/**
- * Store value to atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to store in the variable
- */
-void odpdrv_atomic_store_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Fetch and add to atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be added to the variable
- *
- * @return Value of the variable before the addition
- */
-uint64_t odpdrv_atomic_fetch_add_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Add to atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be added to the variable
- */
-void odpdrv_atomic_add_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Fetch and subtract from atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be subtracted from the variable
- *
- * @return Value of the variable before the subtraction
- */
-uint64_t odpdrv_atomic_fetch_sub_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Subtract from atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be subtracted from the variable
- */
-void odpdrv_atomic_sub_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Fetch and increment atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable before the increment
- */
-uint64_t odpdrv_atomic_fetch_inc_u64(odpdrv_atomic_u64_t *atom);
-
-/**
- * Increment atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- */
-void odpdrv_atomic_inc_u64(odpdrv_atomic_u64_t *atom);
-
-/**
- * Fetch and decrement atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable before the decrement
- */
-uint64_t odpdrv_atomic_fetch_dec_u64(odpdrv_atomic_u64_t *atom);
-
-/**
- * Decrement atomic uint64 variable
- *
- * @param atom Pointer to atomic variable
- */
-void odpdrv_atomic_dec_u64(odpdrv_atomic_u64_t *atom);
-
-/**
- * Update maximum value of atomic uint64 variable
- *
- * Compares value of atomic variable to the new maximum value. If the new value
- * is greater than the current value, writes the new value into the variable.
- *
- * @param atom Pointer to atomic variable
- * @param new_max New maximum value to be written into the atomic variable
- */
-void odpdrv_atomic_max_u64(odpdrv_atomic_u64_t *atom, uint64_t new_max);
-
-/**
- * Update minimum value of atomic uint64 variable
- *
- * Compares value of atomic variable to the new minimum value. If the new value
- * is less than the current value, writes the new value into the variable.
- *
- * @param atom Pointer to atomic variable
- * @param new_min New minimum value to be written into the atomic variable
- */
-void odpdrv_atomic_min_u64(odpdrv_atomic_u64_t *atom, uint64_t new_min);
-
-/**
- * Compare and swap atomic uint64 variable
- *
- * Compares value of atomic variable to the value pointed by 'old_val'.
- * If values are equal, the operation writes 'new_val' into the atomic variable
- * and returns success. If they are not equal, the operation writes current
- * value of atomic variable into 'old_val' and returns failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- */
-int odpdrv_atomic_cas_u64(odpdrv_atomic_u64_t *atom, uint64_t *old_val,
- uint64_t new_val);
-
-/**
- * Exchange value of atomic uint64 variable
- *
- * Atomically replaces the value of atomic variable with the new value. Returns
- * the old value.
- *
- * @param atom Pointer to atomic variable
- * @param new_val New value of the atomic variable
- *
- * @return Value of the variable before the operation
- */
-uint64_t odpdrv_atomic_xchg_u64(odpdrv_atomic_u64_t *atom, uint64_t new_val);
-
-/*
- * 32-bit operations in non-RELAXED memory ordering
- * ------------------------------------------------
- */
-
-/**
- * Load value of atomic uint32 variable using ACQUIRE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_load_u32() but ensures ACQUIRE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable
- */
-uint32_t odpdrv_atomic_load_acq_u32(odpdrv_atomic_u32_t *atom);
-
-/**
- * Store value to atomic uint32 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_store_u32() but ensures RELEASE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to store in the variable
- */
-void odpdrv_atomic_store_rel_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Add to atomic uint32 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_add_u32() but ensures RELEASE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be added to the variable
- */
-void odpdrv_atomic_add_rel_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Subtract from atomic uint32 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_sub_u32() but ensures RELEASE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be subtracted from the variable
- */
-void odpdrv_atomic_sub_rel_u32(odpdrv_atomic_u32_t *atom, uint32_t val);
-
-/**
- * Compare and swap atomic uint32 variable using ACQUIRE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_cas_u32() but ensures ACQUIRE memory
- * ordering on success. Memory ordering is RELAXED on failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- */
-int odpdrv_atomic_cas_acq_u32(odpdrv_atomic_u32_t *atom, uint32_t *old_val,
- uint32_t new_val);
-
-/**
- * Compare and swap atomic uint32 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_cas_u32() but ensures RELEASE memory
- * ordering on success. Memory ordering is RELAXED on failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- */
-int odpdrv_atomic_cas_rel_u32(odpdrv_atomic_u32_t *atom, uint32_t *old_val,
- uint32_t new_val);
-
-/**
- * Compare and swap atomic uint32 variable using ACQUIRE-and-RELEASE memory
- * ordering
- *
- * Otherwise identical to odpdrv_atomic_cas_u32() but ensures
- * ACQUIRE-and-RELEASE memory ordering on success.
- * Memory ordering is RELAXED on failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- */
-int odpdrv_atomic_cas_acq_rel_u32(odpdrv_atomic_u32_t *atom, uint32_t *old_val,
- uint32_t new_val);
-
-/*
- * 64-bit operations in non-RELAXED memory ordering
- * ------------------------------------------------
- */
-
-/**
- * Load value of atomic uint64 variable using ACQUIRE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_load_u64() but ensures ACQUIRE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- *
- * @return Value of the variable
- */
-uint64_t odpdrv_atomic_load_acq_u64(odpdrv_atomic_u64_t *atom);
-
-/**
- * Store value to atomic uint64 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_store_u64() but ensures RELEASE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to store in the variable
- */
-void odpdrv_atomic_store_rel_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Add to atomic uint64 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_add_u64() but ensures RELEASE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be added to the variable
- */
-void odpdrv_atomic_add_rel_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Subtract from atomic uint64 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_sub_u64() but ensures RELEASE memory
- * ordering.
- *
- * @param atom Pointer to atomic variable
- * @param val Value to be subtracted from the variable
- */
-void odpdrv_atomic_sub_rel_u64(odpdrv_atomic_u64_t *atom, uint64_t val);
-
-/**
- * Compare and swap atomic uint64 variable using ACQUIRE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_cas_u64() but ensures ACQUIRE memory
- * ordering on success. Memory ordering is RELAXED on failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- */
-int odpdrv_atomic_cas_acq_u64(odpdrv_atomic_u64_t *atom, uint64_t *old_val,
- uint64_t new_val);
-
-/**
- * Compare and swap atomic uint64 variable using RELEASE memory ordering
- *
- * Otherwise identical to odpdrv_atomic_cas_u64() but ensures RELEASE memory
- * ordering on success. Memory ordering is RELAXED on failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- */
-int odpdrv_atomic_cas_rel_u64(odpdrv_atomic_u64_t *atom, uint64_t *old_val,
- uint64_t new_val);
-
-/**
- * Compare and swap atomic uint64 variable using ACQUIRE-and-RELEASE memory
- * ordering
- *
- * Otherwise identical to odpdrv_atomic_cas_u64() but ensures
- * ACQUIRE-and-RELEASE memory ordering on success. Memory ordering is RELAXED
- * on failure.
- *
- * @param atom Pointer to atomic variable
- * @param[in,out] old_val Pointer to the old value of the atomic variable.
- * Operation updates this value on failure.
- * @param new_val New value to be written into the atomic variable
- *
- * @return 0 on failure, !0 on success
- */
-int odpdrv_atomic_cas_acq_rel_u64(odpdrv_atomic_u64_t *atom, uint64_t *old_val,
- uint64_t new_val);
-
-/**
- * Atomic operations
- *
- * Atomic operations listed in a bit field structure.
- */
-typedef union odpdrv_atomic_op_t {
- /** Operation flags */
- struct {
- uint32_t init : 1; /**< Init atomic variable */
- uint32_t load : 1; /**< Atomic load */
- uint32_t store : 1; /**< Atomic store */
- uint32_t fetch_add : 1; /**< Atomic fetch and add */
- uint32_t add : 1; /**< Atomic add */
- uint32_t fetch_sub : 1; /**< Atomic fetch and subtract */
- uint32_t sub : 1; /**< Atomic subtract */
- uint32_t fetch_inc : 1; /**< Atomic fetch and increment */
- uint32_t inc : 1; /**< Atomic increment */
- uint32_t fetch_dec : 1; /**< Atomic fetch and decrement */
- uint32_t dec : 1; /**< Atomic decrement */
- uint32_t min : 1; /**< Atomic minimum */
- uint32_t max : 1; /**< Atomic maximum */
- uint32_t cas : 1; /**< Atomic compare and swap */
- uint32_t xchg : 1; /**< Atomic exchange */
- } op;
-
- /** All bits of the bit field structure.
- * Operation flag mapping is architecture specific. This field can be
- * used to set/clear all flags, or bitwise operations over the entire
- * structure. */
- uint32_t all_bits;
-} odpdrv_atomic_op_t;
-
-/**
- * Query which atomic uint64 operations are lock-free
- *
- * Lock-free implementations have higher performance and scale better than
- * implementations using locks. User can decide to use e.g. uint32 atomic
- * variables instead of uint64 to optimize performance on platforms that
- * implement a performance critical operation using locks.
- *
- * Init operations (e.g. odpdrv_atomic_init_64()) are not atomic. This function
- * clears the op.init bit but will never set it to one.
- *
- * @param atomic_op Pointer to atomic operation structure for storing
- * operation flags. All bits are initialized to zero during
- * the operation. The parameter is ignored when NULL.
- * @retval 0 None of the operations are lock-free
- * @retval 1 Some of the operations are lock-free
- * @retval 2 All operations are lock-free
- */
-int odpdrv_atomic_lock_free_u64(odpdrv_atomic_op_t *atomic_op);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,66 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV execution barriers
- */
-
-#ifndef ODPDRV_API_BARRIER_H_
-#define ODPDRV_API_BARRIER_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @defgroup odpdrv_barrier ODPDRV BARRIER
- * Thread execution and memory ordering barriers.
- *
- * @details
- * <b> Thread execution barrier (odpdrv_barrier_t) </b>
- *
- * Thread execution barrier synchronizes a group of threads to wait on the
- * barrier until the entire group has reached the barrier.
- * @{
- */
-
-/**
- * @typedef odpdrv_barrier_t
- * ODPDRV thread synchronization barrier
- */
-
-/**
- * Initialize barrier with thread count.
- *
- * @param barr Pointer to a barrier variable
- * @param count Thread count
- */
-void odpdrv_barrier_init(odpdrv_barrier_t *barr, int count);
-
-/**
- * Synchronize thread execution on barrier.
- * Wait for all threads to arrive at the barrier until they are let loose again.
- * Threads will block (spin) until the last thread has arrived at the barrier.
- * All memory operations before the odpdrv_barrier_wait() call will be visible
- * to all threads when they leave the barrier.
- *
- * @param barr Pointer to a barrier variable
- */
-void odpdrv_barrier_wait(odpdrv_barrier_t *barr);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,181 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV byteorder
- */
-
-#ifndef ODPDRV_BYTEORDER_H_
-#define ODPDRV_BYTEORDER_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @addtogroup odpdrv_compiler_optim ODPDRV COMPILER / OPTIMIZATION
- * Macros that check byte order and operations for byte order conversion.
- * @{
- */
-
-/**
- * @def ODPDRV_BIG_ENDIAN
- * Big endian byte order
- *
- * @def ODPDRV_LITTLE_ENDIAN
- * Little endian byte order
- *
- * @def ODPDRV_BIG_ENDIAN_BITFIELD
- * Big endian bit field
- *
- * @def ODPDRV_LITTLE_ENDIAN_BITFIELD
- * Little endian bit field
- *
- * @def ODPDRV_BYTE_ORDER
- * Selected byte order
- *
- * @def ODPDRV_BITFIELD_ORDER
- * Selected bitfield order
- */
-
-/**
- * @typedef odpdrv_u16le_t
- * unsigned 16bit little endian
- *
- * @typedef odpdrv_u16be_t
- * unsigned 16bit big endian
- *
- * @typedef odpdrv_u32le_t
- * unsigned 32bit little endian
- *
- * @typedef odpdrv_u32be_t
- * unsigned 32bit big endian
- *
- * @typedef odpdrv_u64le_t
- * unsigned 64bit little endian
- *
- * @typedef odpdrv_u64be_t
- * unsigned 64bit big endian
- *
- * @typedef odpdrv_u16sum_t
- * unsigned 16bit bitwise
- *
- * @typedef odpdrv_u32sum_t
- * unsigned 32bit bitwise
- */
-
-/*
- * Big Endian -> CPU byte order:
- */
-
-/**
- * Convert 16bit big endian to cpu native uint16_t
- * @param be16 big endian 16bit
- * @return cpu native uint16_t
- */
-uint16_t odpdrv_be_to_cpu_16(odpdrv_u16be_t be16);
-
-/**
- * Convert 32bit big endian to cpu native uint32_t
- * @param be32 big endian 32bit
- * @return cpu native uint32_t
- */
-uint32_t odpdrv_be_to_cpu_32(odpdrv_u32be_t be32);
-
-/**
- * Convert 64bit big endian to cpu native uint64_t
- * @param be64 big endian 64bit
- * @return cpu native uint64_t
- */
-uint64_t odpdrv_be_to_cpu_64(odpdrv_u64be_t be64);
-
-/*
- * CPU byte order -> Big Endian:
- */
-
-/**
- * Convert cpu native uint16_t to 16bit big endian
- * @param cpu16 uint16_t in cpu native format
- * @return big endian 16bit
- */
-odpdrv_u16be_t odpdrv_cpu_to_be_16(uint16_t cpu16);
-
-/**
- * Convert cpu native uint32_t to 32bit big endian
- * @param cpu32 uint32_t in cpu native format
- * @return big endian 32bit
- */
-odpdrv_u32be_t odpdrv_cpu_to_be_32(uint32_t cpu32);
-
-/**
- * Convert cpu native uint64_t to 64bit big endian
- * @param cpu64 uint64_t in cpu native format
- * @return big endian 64bit
- */
-odpdrv_u64be_t odpdrv_cpu_to_be_64(uint64_t cpu64);
-
-/*
- * Little Endian -> CPU byte order:
- */
-
-/**
- * Convert 16bit little endian to cpu native uint16_t
- * @param le16 little endian 16bit
- * @return cpu native uint16_t
- */
-uint16_t odpdrv_le_to_cpu_16(odpdrv_u16le_t le16);
-
-/**
- * Convert 32bit little endian to cpu native uint32_t
- * @param le32 little endian 32bit
- * @return cpu native uint32_t
- */
-uint32_t odpdrv_le_to_cpu_32(odpdrv_u32le_t le32);
-
-/**
- * Convert 64bit little endian to cpu native uint64_t
- * @param le64 little endian 64bit
- * @return cpu native uint64_t
- */
-uint64_t odpdrv_le_to_cpu_64(odpdrv_u64le_t le64);
-
-/*
- * CPU byte order -> Little Endian:
- */
-
-/**
- * Convert cpu native uint16_t to 16bit little endian
- * @param cpu16 uint16_t in cpu native format
- * @return little endian 16bit
- */
-odpdrv_u16le_t odpdrv_cpu_to_le_16(uint16_t cpu16);
-
-/**
- * Convert cpu native uint32_t to 32bit little endian
- * @param cpu32 uint32_t in cpu native format
- * @return little endian 32bit
- */
-odpdrv_u32le_t odpdrv_cpu_to_le_32(uint32_t cpu32);
-
-/**
- * Convert cpu native uint64_t to 64bit little endian
- * @param cpu64 uint64_t in cpu native format
- * @return little endian 64bit
- */
-odpdrv_u64le_t odpdrv_cpu_to_le_64(uint64_t cpu64);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,389 +0,0 @@
-/* Copyright (c) 2017, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV driver
- */
-
-#ifndef ODPDRV_DRIVER_H_
-#define ODPDRV_DRIVER_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
-* @addtogroup odpdrv_driver
-* @details
-* enumerator and driver interface to ODP
-*
-* 1) ODP loads the different modules (i.e. it loads shared libraries, *.so).
-* In the context of drivers, shared libraries may contain enumerators,
-* drivers and devios. These register in step 2.
-*
-* 2)
-* @code
-* odpdrv_enumr_class_register(int (probe*)()...)
-* ----------------------------------------------------------->
-* odpdrv_driver_register(int (probe*)()...)
-* ----------------------------------------------------------->
-* odpdrv_devio_register()
-* ----------------------------------------------------------->
-* @endcode
-* A number of device_enumerator_classes are registered at the ODP startup.
-* Many classes are expected: static, ACPI, PCI, switchdev, virtual, DPAA2...
-* A number of drivers also register to ODP (passing their own probe function).
-* A number of device IO may also register to ODP (defining available devices
-* interfaces).
-*
-* 3) ODP calls the probe function of each enumerator class <BR>
-* @code
-* enumerator class probe()
-* <-----------------------------------------------------------
-* odpdrv_emum_register(int (probe*)()...)
-* ----------------------------------------------------------->
-* ----------------------------------------------------------->
-* ----------------------------------------------------------->
-* odpdrv_devio_register(...)
-* ----------------------------------------------------------->
-* ----------------------------------------------------------->
-* ----------------------------------------------------------->
-* @endcode
-* ODP calls the probe function of each registered enumerator_class.
-* This result in the enumerator_class registering some
-* enumerators (instances of the class) by calling
-* odpdrv_emumerator_register() for each instance.
-* A given enumerator_class may create many enumerators based on its platform:
-* For instance Linux defines a number of PCI domains that can be viewed as
-* multiple PCI enumerators. In addition, it could be considered that each PCI
-* root of each processor socket in a NUMA environment has its own PCI
-* enumerator.
-* For enumerator class PCI, there could be one instance for each PCI
-* domain.
-* The devios delivered with their enumerator may also register at this stage.
-*
-* 4)
-* @code
-* enumerator probe()
-* <-----------------------------------------------------------
-* odpdrv_device_create()
-* ----------------------------------------------------------->
-* odpdrv_device_create()
-* ----------------------------------------------------------->
-* odpdrv_device_create()
-* ----------------------------------------------------------->
-* @endcode
-* For each enumerator instance, odp calls the probe function.
-* This will trigger devices creation (Enumerators calls odpdrv
-* odpdrv_device_create() for each new device). Enumerators are allowed
-* to call odpdrv_device_create() at any time once they have been probed
-* (hotplug). They also may call odpdrv_device_destroy() if needed.
-*
-* 5) The driver framework calls the drivers probe(D,I) functions of the
-* drivers, with device D and devio I as parameter, assuming that:
-* -devio I was on the driver supported list of devio (and version matches)
-* -the devio I is registered and found its enumerator interface(E) api
-* (name and version)
-* -device D was enumerated by an enumerator providing interface E.
-* The return value of the driver probe function tells whether the driver
-* can handle the device or not.
-*
-* @{
-*/
-
-/* Forward declarations for a top down description of structures */
-/** Parameters for enumerator class registration */
-typedef struct odpdrv_enumr_class_param_t odpdrv_enumr_class_param_t;
-/** Parameters for enumerator registration */
-typedef struct odpdrv_enumr_param_t odpdrv_enumr_param_t;
-/** Parameters for new device creation */
-typedef struct odpdrv_device_param_t odpdrv_device_param_t;
-/** Parameters for devio registration*/
-typedef struct odpdrv_devio_param_t odpdrv_devio_param_t;
-/** Parameters for driver registration*/
-typedef struct odpdrv_driver_param_t odpdrv_driver_param_t;
-
-/**
- * @typedef odpdrv_enumr_class_t
- * ODPDRV enumerator class, such as PCI.
- */
-/**
- * @def ODPDRV_ENUMR_CLASS_INVALID
- * Invalid odpdrv enumerator class
- */
-
-/**
- * @typedef odpdrv_enumr_t
- * ODPDRV enumerator. Instance of odpdrv_enumr_class_t.
- */
-/**
- * @def ODPDRV_ENUMR_INVALID
- * Invalid odpdrv enumerator
- */
-
-/**
- * @typedef odpdrv_device_t
- * ODPDRV device. Created and destroyed by enumerators
- */
-/**
- * @def ODPDRV_DEVICE_INVALID
- * Invalid odpdrv device
- */
-
-/**
- * @typedef odpdrv_devio_t
- * ODPDRV device IO interface.
- */
-/**
- * @def ODPDRV_DEVIO_INVALID
- * Invalid odpdrv device IO
- */
-
-/**
- * @typedef odpdrv_driver_t
- * ODPDRV device driver.
- */
-/**
- * @def ODPDRV_DRIVER_INVALID
- * Invalid odpdrv driver
- */
-
-/** Maximum size for driver and enumerator names */
-#define ODPDRV_NAME_SIZE 32
-
-/** Maximum size for the enumerator dependent address */
-#define ODPDRV_NAME_ADDR_SZ 64
-
-/** The maximum number of interfaces a driver may support */
-#define ODPDRV_MAX_DEVIOS 3
-
-/**
-* Parameters to be given at enumerator class registration
-*/
-struct odpdrv_enumr_class_param_t {
- /** Enumerator name: mostly used for debug purpose.
- * Name must be unique (e.g. "PCI-DPAA2")
- */
- const char name[ODPDRV_NAME_SIZE];
-
- /** Probe function:
- * Called by ODP to get the enumerator class instances registered
- */
- int (*probe)(void);
-
- /** Remove function:
- * Free whatever resource the class may have allocated.
- */
- int (*remove)(void);
-};
-
-/**
-* Parameter to be given at enumerator (instance) registration
-*/
-struct odpdrv_enumr_param_t {
- /** Class
- * Identifies the class of the enumerator
- */
- odpdrv_enumr_class_t enumr_class;
-
- /** Enumerator api_name and version are used by the devio
- * to make sure the device can be accessed:
- * E.g. "PCI"
- * The format of the enum_dev part for the odpdrv_device_param_t
- * structure is identified by the api-name and version below
- */
- const char api_name[ODPDRV_NAME_SIZE];
- uint32_t api_version; /**<< the version of the provided API */
-
- /** Probe function:
- * Called by ODP when it is ready for device creation/deletion
- * returns an negative value on error or 0 on success.
- */
- int (*probe)(void);
-
- /** Remove function:
- * destroy all enumerated devices and release all resources
- */
- int (*remove)(void);
-
- /** Register event notifier function for hotplug events:
- * register_notifier(fcnt,event_mask) registers fcnt as a callback when
- * one of the event specified in event_mask occurs.
- */
- int (*register_notifier)(void (*event_handler) (uint64_t event),
- int64_t event_mask);
-};
-
-/* The following events are supported by enumerators */
-#define ODPDRV_ENUM_EV_REMOVED 0x0000000000000001 /**<< remove event */
-
-/** This structure defines a generic enumerated device, or actually the
-* common part between all devices, the enumerator specific part being pointed
-* by the enum_dev field below.
-*/
-struct odpdrv_device_param_t {
- /** enumerator
- * enumerator which enumerated the device: as returned by
- * odpdrv_enumr_register
- * devices with parents get destroyed when the parents dies.
- */
- odpdrv_enumr_t enumerator;
-
- /** Device address:
- * An enumerator dependent string giving the device address,
- * e.g. "0000.23.12.1" for PCI domain 0, bus 23, device 12, function 1.
- * This string identifies the device uniquely.
- */
- const char address[ODPDRV_NAME_ADDR_SZ];
-
- /** Enumerator dependent part
- * This part is allocated by the enumerator and is enumerator dependent
- * (i.e. different devices types will have different contents for
- * enum_dev).
- */
- void *enum_dev;
-};
-
-/**
- * Parameter to be given at devio registration
- */
-struct odpdrv_devio_param_t {
- /** Devio name
- * Identifies devio interface implemented by this devio
- * (i.e:many devios may have the same name, but none of those
- * with same provided interface should refer to a common enumerator
- * class)
- */
- const char api_name[ODPDRV_NAME_SIZE];
- uint32_t api_version; /**<< the version of the provided API */
-
- /** Enumerator interface name and version
- * The enumerator interface this devio needs.
- */
- const char enumr_api_name[ODPDRV_NAME_SIZE];
- uint32_t enumr_api_version; /**<< required enumerator API version */
-
- /** Ops
- * Pointer to a devio ops structure (specific to each devio)
- */
- void *ops;
-};
-
-/**
-* Parameter to be given at driver registration
-*/
-struct odpdrv_driver_param_t {
- /** Driver name
- * The driver name (the pair {driver-name, enum-api-name} must
- * be unique)
- */
- const char name[ODPDRV_NAME_SIZE];
-
- /** Supported devios:
- * The list of supported devio: one of the following devio
- * (with correct version) must be available for the driver to work:
- */
- struct {
- const char api_name[ODPDRV_NAME_SIZE]; /**<< devio API name */
- uint32_t api_version; /**<< devio API version */
- } devios[ODPDRV_MAX_DEVIOS];
-
- /** Probe function:
- * Called by ODP to see if the driver can drive a given device
- *
- */
- int (*probe)(odpdrv_device_t *dev);
-
- /** Remove function:
- * Only called with devices whose probe() returned true
- *
- */
- int (*remove)(odpdrv_device_param_t *dev);
-
-};
-
-/**
-* Register an enumerator class.
-* Each enumerator class calls this function at init time.
-* (probably using gcc/clang * __constructor__ attribute.)
-*
-* @param param Pointer to a enumerator class registration structure.
-* @return an enumerator class handle or ODPDRV_ENUMR_CLASS_INVALID on error.
-* On errors, enumerators classes should release allocated resources and return.
-*/
-odpdrv_enumr_class_t odpdrv_enumr_class_register(odpdrv_enumr_class_param_t
- *param);
-
-/**
-* Register an enumerator.
-* Each enumerator calls this function at init time.
-* (probably using gcc/clang * __constructor__ attribute.)
-*
-* @param param Pointer to a enumerator registration parameter structure.
-* @return an enumerator handle or ODPDRV_ENUMR_INVALID on error.
-* On errors, enumerators should release allocated resources and return.
-*/
-odpdrv_enumr_t odpdrv_enumr_register(odpdrv_enumr_param_t *param);
-
-/**
-* Create a device
-* Called by each enumerator at probe time, or anytime later, for each
-* new created device
-* @param param Pointer to a device parameter structure.
-* @return an odpdrv devuice handle or ODPDRV_DEVICE_INVALID on error.
-*/
-odpdrv_device_t odpdrv_device_create(odpdrv_device_param_t *param);
-
-/**
-* Destroy a device
-* Called by each enumerator at probe time, or anytime later, for each
-* destroyed created device
-* @param dev A odpdrv device handle as returned by odpdrv_device_create.
-* @return 0 on success or a negative value on error.
-*/
-void odpdrv_device_destroy(odpdrv_device_t dev);
-
-/**
-* Register an devio.
-* Each devio calls this function at init time.
-* (probably using gcc/clang * __constructor__ attribute.)
-*
-* @param param Pointer to a devio registration structure.
-* @return an odpdrv_devio_t handle or ODPDRV_DEVIO_INVALID on error.
-*/
-odpdrv_devio_t odpdrv_devio_register(odpdrv_devio_param_t *param);
-
-/**
-* Register a Driver.
-* Each driver calls this function at init time.
-* (probably using gcc/clang * __constructor__ attribute.)
-*
-* @param param Pointer to a driver registration structure.
-* @return an odpdrv_driver_t handle or ODPDRV_DRIVER_INVALID on error.
-* On errors, drivers should release allocated resources and return.
-*/
-odpdrv_driver_t odpdrv_driver_register(odpdrv_driver_param_t *param);
-
-/**
-* Print (ODP_DBG) the driver interface status (debug).
-*
-* @return 0 on success, less than zero on error (inconsistency detected)
-*/
-int odpdrv_print_all(void);
-
-/**
-* @}
-*/
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,330 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPRDV shared memory (shm)
- */
-
-#ifndef ODPDRV_SHM_H_
-#define ODPDRV_SHM_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @addtogroup odpdrv_shm ODPDRV SHARED MEMORY
- * Operations on driver shared memory.
- * @{
- */
-
-/**
- * @typedef odpdrv_shm_t
- * odpdrv shared memory block
- */
-
-/**
- * @def ODPDRV_SHM_INVALID
- * Invalid odpdrv shared memory block
- */
-
-/** Maximum shared memory block name length in chars */
-#define ODPDRV_SHM_NAME_LEN 32
-
-/*
- * Shared memory flags
- */
-#define ODPDRV_SHM_SINGLE_VA 0x01 /**< Memory shall be mapped at same VA */
-#define ODPDRV_SHM_LOCK 0x02 /**< Memory shall be locked (no swap) */
-
-/**
- * Shared memory block info
- */
-typedef struct odpdrv_shm_info_t {
- const char *name; /**< Block name */
- void *addr; /**< Block address */
- uint64_t size; /**< Block size in bytes */
- uint64_t page_size; /**< Memory page size */
- uint32_t flags; /**< ODPDRV_SHM_* flags */
-} odpdrv_shm_info_t;
-
-/**
- * Shared memory capabilities
- */
-typedef struct odpdrv_shm_capability_t {
- /** Maximum number of shared memory blocks
- *
- * This number of separate shared memory blocks can be
- * reserved concurrently. */
- unsigned max_blocks;
-
- /** Maximum memory block size in bytes
- *
- * The value of zero means that size is limited only by the available
- * memory size. */
- uint64_t max_size;
-
- /** Maximum memory block alignment in bytes
- *
- * The value of zero means that alignment is limited only by the
- * available memory size. */
- uint64_t max_align;
-
-} odpdrv_shm_capability_t;
-
-/**
- * Query shared memory capabilities
- *
- * Outputs shared memory capabilities on success.
- *
- * @param[out] capa Pointer to capability structure for output
- *
- * @retval 0 on success
- * @retval <0 on failure
- */
-int odpdrv_shm_capability(odpdrv_shm_capability_t *capa);
-
-/**
- * Reserve a contiguous block of shared memory
- *
- * @param[in] name Name of the block (maximum ODPDRV_SHM_NAME_LEN - 1 chars)
- * @param[in] size Block size in bytes
- * @param[in] align Block alignment in bytes
- * @param[in] flags Shared memory parameter flags (ODPDRV_SHM_*).
- * Default value is 0.
- *
- * @return Handle of the reserved block
- * @retval ODPDRV_SHM_INVALID on failure
- */
-odpdrv_shm_t odpdrv_shm_reserve(const char *name, uint64_t size, uint64_t align,
- uint32_t flags);
-
-/**
- * Free a contiguous block of shared memory
- *
- * Frees a previously reserved block of shared memory (found by its handle).
- * @note Freeing memory that is in use will result in UNDEFINED behavior
- *
- * @param[in] shm odpdrv_shm Block handle
- *
- * @retval 0 on success
- * @retval <0 on failure
- */
-int odpdrv_shm_free_by_handle(odpdrv_shm_t shm);
-
-/**
- * Free a contiguous block of shared memory (found from its name)
- *
- * Frees a previously reserved block of shared memory.
- * @note Freeing memory that is in use will result in UNDEFINED behavior
- *
- * @param[in] name odpdrv_shm Block name
- *
- * @retval 0 on success
- * @retval <0 on failure
- */
-int odpdrv_shm_free_by_name(const char *name);
-
-/**
- * Free a contiguous block of shared memory (found from its address)
- *
- * Frees a previously reserved block of shared memory.
- * @note Freeing memory that is in use will result in UNDEFINED behavior
- *
- * @param[in] address odpdrv_shm Block address
- *
- * @retval 0 on success
- * @retval <0 on failure
- */
-int odpdrv_shm_free_by_address(void *address);
-
-/**
- * Lookup and map a block of shared memory (identified by its handle)
- *
- * @param[in] shm odpdrv_shm Block handle
- *
- * @return The address of the newly mapped block.
- * @retval NULL on failure
- */
-void *odpdrv_shm_lookup_by_handle(odpdrv_shm_t shm);
-
-/**
- * Lookup and map a block of shared memory (identified by its name)
- *
- * @param[in] name odpdrv_shm Block name
- *
- * @return The handle of the newly mapped block.
- * @retval ODPDRV_SHM_INVALID on failure
- */
-odpdrv_shm_t odpdrv_shm_lookup_by_name(const char *name);
-
-/**
- * Lookup and map a block of shared memory (identified by its address)
- *
- * @note This only works when the flag ODPDRV_SHM_SINGLE_VA was set,
- * as otherwise addresses are odp-thread local and hence meaningless to
- * identify the block between odp-threads.
- *
- * @param[in] address odpdrv_shm Block address
- *
- * @return The handle of the newly mapped block.
- * @retval ODPDRV_SHM_INVALID on failure
- */
-odpdrv_shm_t odpdrv_shm_lookup_by_address(void *address);
-
-/**
- * Get a Shared memory block address
- *
- * @param[in] shm odpdrv_shm Block handle
- *
- * @return Memory block address
- * @retval NULL on failure
- */
-void *odpdrv_shm_addr(odpdrv_shm_t shm);
-
-/**
- * Shared memory block info
- *
- * @param[in] shm Odpdrv_shm block handle
- * @param[out] info Block info pointer for output
- *
- * @retval 0 on success
- * @retval <0 on failure
- */
-int odpdrv_shm_info(odpdrv_shm_t shm, odpdrv_shm_info_t *info);
-
-/**
- * Print all shared memory blocks and returns the number of allocated blocks.
- * This function is meant for debug.
- * @param title A string to be printed before the shared memory status
- * @return The total number of allocated blocks
- */
-int odpdrv_shm_print_all(const char *title);
-
-/**
- * Get printable value for an odpdrv_shm_t
- *
- * @param hdl odpdrv_shm_t handle to be printed
- * @return uint64_t value that can be used to print/display this
- * handle
- *
- * @note This routine is intended to be used for diagnostic purposes
- * to enable applications to generate a printable value that represents
- * an odpdrv_shm_t handle.
- */
-uint64_t odpdrv_shm_to_u64(odpdrv_shm_t hdl);
-
-/**
- * drv shm pool parameters
- * Used to communicate pool creation options.
- */
-typedef struct {
- /** Sum of all (simultaneous) allocs (bytes)*/
- uint64_t pool_size;
-
- /** Minimum alloc size user will request from pool (bytes)*/
- uint64_t min_alloc;
-
- /** Maximum alloc size user will request from pool (bytes)*/
- uint64_t max_alloc;
-} odpdrv_shm_pool_param_t;
-
-/**
- * @typedef odpdrv_shm_pool_t
- * odpdrv shared memory pool
- */
-
-/**
- * @def ODPDRV_SHM_POOL_INVALID
- * Invalid odpdrv shared memory pool
- */
-
-/**
- * Create a memory pool
- *
- * This routine is used to create a memory pool. The use of pool name is
- * optional.
- * Unique names are not required. However, odpdrv_shm_pool_lookup()
- * returns only a single matching pool.
- *
- * @param pool_name Name of the pool or NULL.
- * @param param Pool parameters.
- *
- * @return Handle of the created drv shm memory pool
- * @retval ODPDRV_SHM_POOL_INVALID Pool could not be created
- */
-odpdrv_shm_pool_t odpdrv_shm_pool_create(const char *pool_name,
- odpdrv_shm_pool_param_t *param);
-
-/**
- * Destroy a pool previously created by odpdrv_shm_pool_create()
- *
- * @param pool Handle of the pool to be destroyed
- *
- * @retval 0 Success
- * @retval <0 Failure
- *
- * @note This routine destroys a previously created pool, and will destroy any
- * internal shared memory objects associated with the pool. Results are
- * undefined if an attempt is made to destroy a pool that contains allocated
- * or otherwise active allocations.
- */
-int odpdrv_shm_pool_destroy(odpdrv_shm_pool_t pool);
-
-/**
- * Find a memory pool by name
- *
- * @param name Name of the pool
- *
- * @return Handle of the first matching pool
- * @retval ODPDRV_SHM_POOL_INVALID Pool could not be found
- */
-odpdrv_shm_pool_t odpdrv_shm_pool_lookup(const char *name);
-
-/**
- * Allocate memory from a memory pool
- *
- * @param pool Memory pool handle
- * @param size Number of bytes to allocate (bytes)
- *
- * @return A pointer to the allocated memory
- * @retval NULL on error.
- */
-void *odpdrv_shm_pool_alloc(odpdrv_shm_pool_t pool, uint64_t size);
-
-/**
- * Free memory back to a memory pool
- *
- * @param pool Memory pool handle
- * @param addr pointer to a previously allocated memory
- * (as returned by a previous call to odpdrv_shm_pool_alloc)
- */
-void odpdrv_shm_pool_free(odpdrv_shm_pool_t pool, void *addr);
-
-/**
- * Print memory pool info
- *
- * @param title A string to be printed as a title (e.g. location)
- * @param pool Memory pool handle
- *
- * @return 0 on success, negative value if pool inconsistency is detected.
- *
- * @note This routine writes implementation-defined information about the
- * specified pool to the ODP log. The intended use is for debugging.
- */
-int odpdrv_shm_pool_print(const char *title, odpdrv_shm_pool_t pool);
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,86 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV spinlock
- */
-
-#ifndef ODPDRV_API_SPINLOCK_H_
-#define ODPDRV_API_SPINLOCK_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @addtogroup odpdrv_locks
- * @details
- * <b> Spin lock (odpdrv_spinlock_t) </b>
- *
- * Spinlock simply re-tries to acquire the lock as long as takes to succeed.
- * Spinlock is not fair since some threads may succeed more often than others.
- * @{
- */
-
-/**
- * @typedef odpdrv_spinlock_t
- * ODPDRV spinlock
- */
-
-/**
- * Initialize spin lock.
- *
- * @param splock Pointer to a spin lock
- */
-void odpdrv_spinlock_init(odpdrv_spinlock_t *splock);
-
-/**
- * Acquire spin lock.
- *
- * @param splock Pointer to a spin lock
- */
-void odpdrv_spinlock_lock(odpdrv_spinlock_t *splock);
-
-/**
- * Try to acquire spin lock.
- *
- * @param splock Pointer to a spin lock
- *
- * @retval 0 lock not acquired
- * @retval !0 lock acquired
- */
-int odpdrv_spinlock_trylock(odpdrv_spinlock_t *splock);
-
-/**
- * Release spin lock.
- *
- * @param splock Pointer to a spin lock
- */
-void odpdrv_spinlock_unlock(odpdrv_spinlock_t *splock);
-
-/**
- * Check if spin lock is busy (locked).
- *
- * @param splock Pointer to a spin lock
- *
- * @retval 1 lock busy (locked)
- * @retval 0 lock not busy.
- */
-int odpdrv_spinlock_is_locked(odpdrv_spinlock_t *splock);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,91 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV memory barriers
- */
-
-#ifndef ODPDRV_API_SYNC_H_
-#define ODPDRV_API_SYNC_H_
-#include <odp/visibility_begin.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @addtogroup odpdrv_barrier
- * @details
- * <b> Memory barriers </b>
- *
- * Memory barriers enforce ordering of memory load and store operations
- * specified before and after the barrier. These barriers may affect both
- * compiler optimizations and CPU out-of-order execution. All ODPDRV
- * synchronization mechanisms (e.g. execution barriers, locks, queues, etc )
- * include all necessary memory barriers, so these calls are not needed when
- * using those. Also ODPDRV atomic operations have memory ordered versions.
- * These explicit barriers may be needed when thread synchronization is based on
- * a non-ODPDRV defined mechanism. Depending on the HW platform, heavy usage of
- * memory barriers may cause significant performance degradation.
- *
- * @{
- */
-
-/**
- * Memory barrier for release operations
- *
- * This memory barrier has release semantics. It synchronizes with a pairing
- * barrier for acquire operations. The releasing and acquiring threads
- * synchronize through shared memory. The releasing thread must call this
- * barrier before signaling the acquiring thread. After the acquiring thread
- * receives the signal, it must call odpdrv_mb_acquire() before it reads the
- * memory written by the releasing thread.
- *
- * This call is not needed when using ODPDRV defined synchronization mechanisms.
- *
- * @see odpdrv_mb_acquire()
- */
-void odpdrv_mb_release(void);
-
-/**
- * Memory barrier for acquire operations
- *
- * This memory barrier has acquire semantics. It synchronizes with a pairing
- * barrier for release operations. The releasing and acquiring threads
- * synchronize through shared memory. The releasing thread must call
- * odpdrv_mb_release() before signaling the acquiring thread. After the
- * acquiring thread receives the signal, it must call this barrier before it
- * read the memory written by the releasing thread.
- *
- * This call is not needed when using ODPDRV defined synchronization mechanisms.
- *
- * @see odpdrv_mb_release()
- */
-void odpdrv_mb_acquire(void);
-
-/**
- * Full memory barrier
- *
- * This is a full memory barrier. It guarantees that all load and store
- * operations specified before it are visible to other threads before
- * all load and store operations specified after it.
- *
- * This call is not needed when using ODPDRV defined synchronization mechanisms.
- */
-void odpdrv_mb_full(void);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#include <odp/visibility_end.h>
-#endif
deleted file mode 100644
@@ -1,35 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * The OpenDataPlane nic driver programming interface
- *
- */
-
-#ifndef ODP_DRV_H_
-#define ODP_DRV_H_
-
-#ifdef __cplusplus
-extern C {
-#endif
-
-#include <odp/drv/align.h>
-#include <odp/drv/atomic.h>
-#include <odp/drv/barrier.h>
-#include <odp/drv/byteorder.h>
-#include <odp/drv/compiler.h>
-#include <odp/drv/driver.h>
-#include <odp/drv/shm.h>
-#include <odp/drv/spinlock.h>
-#include <odp/drv/std_types.h>
-#include <odp/drv/sync.h>
-
-#ifdef __cplusplus
-}
-#endif
-#endif
@@ -54,7 +54,6 @@
#include <odp/api/align.h>
#include <odp/api/system_info.h>
#include <odp/api/debug.h>
-#include <odp/drv/shm.h>
#include <odp_shm_internal.h>
#include <odp_debug_internal.h>
#include <odp_align_internal.h>
@@ -86,7 +85,7 @@
* if some of the block ownwers never procsync() after free). This number
* should take that into account)
*/
-#define ISHM_MAX_NB_BLOCKS ODPDRV_CONFIG_SHM_BLOCKS
+#define ISHM_MAX_NB_BLOCKS 128
/*
* Maximum internal shared memory block name length in chars
@@ -48,7 +48,6 @@
#include <odp/api/spinlock.h>
#include <odp/api/align.h>
#include <odp/api/debug.h>
-#include <odp/drv/shm.h>
#include <odp_shm_internal.h>
#include <odp_debug_internal.h>
#include <odp_align_internal.h>
deleted file mode 100644
@@ -1,26 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <odp/drv/atomic.h>
-
-int odpdrv_atomic_lock_free_u64(odpdrv_atomic_op_t *atomic_op)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- /* All operations have locks */
- if (atomic_op)
- atomic_op->all_bits = 0;
-
- return 0;
-#else
- /* All operations are lock-free */
- if (atomic_op) {
- atomic_op->all_bits = ~((uint32_t)0);
- atomic_op->op.init = 0;
- }
-
- return 2;
-#endif
-}
deleted file mode 100644
@@ -1,50 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <odp/drv/barrier.h>
-#include <odp/drv/sync.h>
-#include <odp/api/cpu.h>
-#include <odp/drv/atomic.h>
-
-void odpdrv_barrier_init(odpdrv_barrier_t *barrier, int count)
-{
- barrier->count = (uint32_t)count;
- odpdrv_atomic_init_u32(&barrier->bar, 0);
-}
-
-/*
- * Efficient barrier_sync -
- *
- * Barriers are initialized with a count of the number of callers
- * that must sync on the barrier before any may proceed.
- *
- * To avoid race conditions and to permit the barrier to be fully
- * reusable, the barrier value cycles between 0..2*count-1. When
- * synchronizing the wasless variable simply tracks which half of
- * the cycle the barrier was in upon entry. Exit is when the
- * barrier crosses to the other half of the cycle.
- */
-void odpdrv_barrier_wait(odpdrv_barrier_t *barrier)
-{
- uint32_t count;
- int wasless;
-
- odpdrv_mb_full();
-
- count = odpdrv_atomic_fetch_inc_u32(&barrier->bar);
- wasless = count < barrier->count;
-
- if (count == 2 * barrier->count - 1) {
- /* Wrap around *atomically* */
- odpdrv_atomic_sub_u32(&barrier->bar, 2 * barrier->count);
- } else {
- while ((odpdrv_atomic_load_u32(&barrier->bar) < barrier->count)
- == wasless)
- odp_cpu_pause();
- }
-
- odpdrv_mb_full();
-}
deleted file mode 100644
@@ -1,64 +0,0 @@
-/* Copyright (c) 2017, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <odp_config_internal.h>
-
-#include <odp/api/std_types.h>
-#include <odp/api/debug.h>
-#include <odp/drv/driver.h>
-#include <odp_debug_internal.h>
-
-odpdrv_enumr_class_t odpdrv_enumr_class_register(odpdrv_enumr_class_param_t
- *param)
-{
- ODP_ERR("NOT Supported yet! Enumerator Class %s Registration!\n.",
- param->name);
-
- return ODPDRV_ENUMR_CLASS_INVALID;
-}
-
-odpdrv_enumr_t odpdrv_enumr_register(odpdrv_enumr_param_t *param)
-{
- ODP_ERR("NOT Supported yet! Enumerator API %s Registration!\n.",
- param->api_name);
-
- return ODPDRV_ENUMR_INVALID;
-}
-
-odpdrv_device_t odpdrv_device_create(odpdrv_device_param_t *param)
-{
- ODP_ERR("odpdrv_device_create not Supported yet! devaddress: %s\n.",
- param->address);
- return ODPDRV_DEVICE_INVALID;
-}
-
-void odpdrv_device_destroy(odpdrv_device_t dev)
-{
- if (dev == ODPDRV_DEVICE_INVALID)
- ODP_ERR("Invalid device\n");
-}
-
-odpdrv_devio_t odpdrv_devio_register(odpdrv_devio_param_t *param)
-{
- ODP_ERR("NOT Supported yet! Driver %s Registration!\n.",
- param->api_name);
-
- return ODPDRV_DEVIO_INVALID;
-}
-
-odpdrv_driver_t odpdrv_driver_register(odpdrv_driver_param_t *param)
-{
- ODP_ERR("NOT Supported yet! Driver %s Registration!\n.",
- param->name);
-
- return ODPDRV_DRIVER_INVALID;
-}
-
-int odpdrv_print_all(void)
-{
- ODP_ERR("odpdrv_print_all not Supported yet!\n.");
- return 0;
-}
deleted file mode 100644
@@ -1,146 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <odp_config_internal.h>
-#include <odp/api/std_types.h>
-#include <odp/drv/shm.h>
-#include <_ishm_internal.h>
-#include <_ishmpool_internal.h>
-
-static inline uint32_t from_handle(odpdrv_shm_t shm)
-{
- return _odpdrv_typeval(shm) - 1;
-}
-
-static inline odpdrv_shm_t to_handle(uint32_t index)
-{
- return _odpdrv_cast_scalar(odpdrv_shm_t, index + 1);
-}
-
-int odpdrv_shm_capability(odpdrv_shm_capability_t *capa)
-{
- capa->max_blocks = ODPDRV_CONFIG_SHM_BLOCKS;
- capa->max_size = 0;
- capa->max_align = 0;
-
- return 0;
-}
-
-odpdrv_shm_t odpdrv_shm_reserve(const char *name, uint64_t size, uint64_t align,
- uint32_t flags)
-{
- int block_index;
- int flgs = 0; /* internal ishm flags */
-
- /* set internal ishm flags according to API flags: */
- flgs |= (flags & ODPDRV_SHM_SINGLE_VA) ? _ODP_ISHM_SINGLE_VA : 0;
- flgs |= (flags & ODPDRV_SHM_LOCK) ? _ODP_ISHM_LOCK : 0;
-
- block_index = _odp_ishm_reserve(name, size, -1, align, flgs, flags);
- if (block_index >= 0)
- return to_handle(block_index);
- else
- return ODPDRV_SHM_INVALID;
-}
-
-int odpdrv_shm_free_by_handle(odpdrv_shm_t shm)
-{
- return _odp_ishm_free_by_index(from_handle(shm));
-}
-
-int odpdrv_shm_free_by_name(const char *name)
-{
- return _odp_ishm_free_by_name(name);
-}
-
-int odpdrv_shm_free_by_address(void *address)
-{
- return _odp_ishm_free_by_address(address);
-}
-
-void *odpdrv_shm_lookup_by_handle(odpdrv_shm_t shm)
-{
- return _odp_ishm_lookup_by_index(from_handle(shm));
-}
-
-odpdrv_shm_t odpdrv_shm_lookup_by_name(const char *name)
-{
- return to_handle(_odp_ishm_lookup_by_name(name));
-}
-
-odpdrv_shm_t odpdrv_shm_lookup_by_address(void *address)
-{
- return to_handle(_odp_ishm_lookup_by_address(address));
-}
-
-void *odpdrv_shm_addr(odpdrv_shm_t shm)
-{
- return _odp_ishm_address(from_handle(shm));
-}
-
-int odpdrv_shm_info(odpdrv_shm_t shm, odpdrv_shm_info_t *info)
-{
- _odp_ishm_info_t ishm_info;
-
- if (_odp_ishm_info(from_handle(shm), &ishm_info))
- return -1;
-
- info->name = ishm_info.name;
- info->addr = ishm_info.addr;
- info->size = ishm_info.size;
- info->page_size = ishm_info.page_size;
- info->flags = ishm_info.user_flags;
-
- return 0;
-}
-
-int odpdrv_shm_print_all(const char *title)
-{
- return _odp_ishm_status(title);
-}
-
-odpdrv_shm_pool_t odpdrv_shm_pool_create(const char *pool_name,
- odpdrv_shm_pool_param_t *param)
-{
- int flags;
-
- /* force unique address for all ODP threads */
- flags = _ODP_ISHM_SINGLE_VA;
- return (odpdrv_shm_pool_t)_odp_ishm_pool_create(pool_name,
- param->pool_size,
- param->min_alloc,
- param->max_alloc,
- flags);
-}
-
-int odpdrv_shm_pool_destroy(odpdrv_shm_pool_t pool)
-{
- return _odp_ishm_pool_destroy((_odp_ishm_pool_t *)(void*)pool);
-}
-
-odpdrv_shm_pool_t odpdrv_shm_pool_lookup(const char *name)
-{
- return (odpdrv_shm_pool_t)_odp_ishm_pool_lookup(name);
-}
-
-void *odpdrv_shm_pool_alloc(odpdrv_shm_pool_t pool, uint64_t size)
-{
- return _odp_ishm_pool_alloc((_odp_ishm_pool_t *)(void*)pool, size);
-}
-
-void odpdrv_shm_pool_free(odpdrv_shm_pool_t pool, void *addr)
-{
- (void)_odp_ishm_pool_free((_odp_ishm_pool_t *)(void*)pool, addr);
-}
-
-int odpdrv_shm_pool_print(const char *title, odpdrv_shm_pool_t pool)
-{
- return _odp_ishm_pool_status(title, (_odp_ishm_pool_t *)(void*)pool);
-}
-
-/**
- * @}
- */
deleted file mode 100644
@@ -1,39 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <odp/drv/spinlock.h>
-#include <odp_atomic_internal.h>
-
-void odpdrv_spinlock_init(odpdrv_spinlock_t *spinlock)
-{
- _odp_atomic_flag_init(&spinlock->lock, 0);
-}
-
-void odpdrv_spinlock_lock(odpdrv_spinlock_t *spinlock)
-{
- /* While the lock is already taken... */
- while (_odp_atomic_flag_tas(&spinlock->lock))
- /* ...spin reading the flag (relaxed MM),
- * the loop will exit when the lock becomes available
- * and we will retry the TAS operation above */
- while (_odp_atomic_flag_load(&spinlock->lock))
- odp_cpu_pause();
-}
-
-int odpdrv_spinlock_trylock(odpdrv_spinlock_t *spinlock)
-{
- return (_odp_atomic_flag_tas(&spinlock->lock) == 0);
-}
-
-void odpdrv_spinlock_unlock(odpdrv_spinlock_t *spinlock)
-{
- _odp_atomic_flag_clear(&spinlock->lock);
-}
-
-int odpdrv_spinlock_is_locked(odpdrv_spinlock_t *spinlock)
-{
- return _odp_atomic_flag_load(&spinlock->lock) != 0;
-}
deleted file mode 100644
@@ -1,58 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV alignments
- */
-
-#ifndef ODPDRV_PLAT_ALIGN_H_
-#define ODPDRV_PLAT_ALIGN_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/api/cpu_arch.h>
-
-/** @ingroup odpdrv_compiler_optim
- * @{
- */
-
-#ifdef __GNUC__
-
-#define ODPDRV_ALIGNED(x) __attribute__((__aligned__(x)))
-
-#define ODPDRV_PACKED __attribute__((__packed__))
-
-#define ODPDRV_OFFSETOF(type, member) __builtin_offsetof(type, member)
-
-#define ODPDRV_FIELD_SIZEOF(type, member) sizeof(((type *)0)->member)
-
-#else
-#error Non-gcc compatible compiler
-#endif
-
-#define ODPDRV_CACHE_LINE_SIZE _ODP_CACHE_LINE_SIZE
-
-#define ODPDRV_PAGE_SIZE 4096
-
-#define ODPDRV_ALIGNED_CACHE ODPDRV_ALIGNED(ODPDRV_CACHE_LINE_SIZE)
-
-#define ODPDRV_ALIGNED_PAGE ODPDRV_ALIGNED(ODPDRV_PAGE_SIZE)
-
-/**
- * @}
- */
-
-#include <odp/drv/spec/align.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,430 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV atomic operations
- */
-
-#ifndef ODPDRV_PLAT_ATOMIC_H_
-#define ODPDRV_PLAT_ATOMIC_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/align.h>
-#include <odp/drv/plat/atomic_types.h>
-
-/** @ingroup odpdrv_atomic
- * @{
- */
-
-static inline void odpdrv_atomic_init_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- __atomic_store_n(&atom->v, val, __ATOMIC_RELAXED);
-}
-
-static inline uint32_t odpdrv_atomic_load_u32(odpdrv_atomic_u32_t *atom)
-{
- return __atomic_load_n(&atom->v, __ATOMIC_RELAXED);
-}
-
-static inline void odpdrv_atomic_store_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- __atomic_store_n(&atom->v, val, __ATOMIC_RELAXED);
-}
-
-static inline uint32_t odpdrv_atomic_fetch_add_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- return __atomic_fetch_add(&atom->v, val, __ATOMIC_RELAXED);
-}
-
-static inline void odpdrv_atomic_add_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- (void)__atomic_fetch_add(&atom->v, val, __ATOMIC_RELAXED);
-}
-
-static inline uint32_t odpdrv_atomic_fetch_sub_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- return __atomic_fetch_sub(&atom->v, val, __ATOMIC_RELAXED);
-}
-
-static inline void odpdrv_atomic_sub_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- (void)__atomic_fetch_sub(&atom->v, val, __ATOMIC_RELAXED);
-}
-
-static inline uint32_t odpdrv_atomic_fetch_inc_u32(odpdrv_atomic_u32_t *atom)
-{
- return __atomic_fetch_add(&atom->v, 1, __ATOMIC_RELAXED);
-}
-
-static inline void odpdrv_atomic_inc_u32(odpdrv_atomic_u32_t *atom)
-{
- (void)__atomic_fetch_add(&atom->v, 1, __ATOMIC_RELAXED);
-}
-
-static inline uint32_t odpdrv_atomic_fetch_dec_u32(odpdrv_atomic_u32_t *atom)
-{
- return __atomic_fetch_sub(&atom->v, 1, __ATOMIC_RELAXED);
-}
-
-static inline void odpdrv_atomic_dec_u32(odpdrv_atomic_u32_t *atom)
-{
- (void)__atomic_fetch_sub(&atom->v, 1, __ATOMIC_RELAXED);
-}
-
-static inline int odpdrv_atomic_cas_u32(odpdrv_atomic_u32_t *atom,
- uint32_t *old_val, uint32_t new_val)
-{
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_RELAXED,
- __ATOMIC_RELAXED);
-}
-
-static inline uint32_t odpdrv_atomic_xchg_u32(odpdrv_atomic_u32_t *atom,
- uint32_t new_val)
-{
- return __atomic_exchange_n(&atom->v, new_val, __ATOMIC_RELAXED);
-}
-
-static inline void odpdrv_atomic_max_u32(odpdrv_atomic_u32_t *atom,
- uint32_t new_max)
-{
- uint32_t old_val;
-
- old_val = odpdrv_atomic_load_u32(atom);
-
- while (new_max > old_val) {
- if (odpdrv_atomic_cas_u32(atom, &old_val, new_max))
- break;
- }
-}
-
-static inline void odpdrv_atomic_min_u32(odpdrv_atomic_u32_t *atom,
- uint32_t new_min)
-{
- uint32_t old_val;
-
- old_val = odpdrv_atomic_load_u32(atom);
-
- while (new_min < old_val) {
- if (odpdrv_atomic_cas_u32(atom, &old_val, new_min))
- break;
- }
-}
-
-static inline void odpdrv_atomic_init_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
- atom->v = val;
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- __atomic_clear(&atom->lock, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline uint64_t odpdrv_atomic_load_u64(odpdrv_atomic_u64_t *atom)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- return ATOMIC_OP(atom, (void)0);
-#else
- return __atomic_load_n(&atom->v, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline void odpdrv_atomic_store_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v = val);
-#else
- __atomic_store_n(&atom->v, val, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline uint64_t odpdrv_atomic_fetch_add_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- return ATOMIC_OP(atom, atom->v += val);
-#else
- return __atomic_fetch_add(&atom->v, val, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline void odpdrv_atomic_add_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v += val);
-#else
- (void)__atomic_fetch_add(&atom->v, val, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline uint64_t odpdrv_atomic_fetch_sub_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- return ATOMIC_OP(atom, atom->v -= val);
-#else
- return __atomic_fetch_sub(&atom->v, val, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline void odpdrv_atomic_sub_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v -= val);
-#else
- (void)__atomic_fetch_sub(&atom->v, val, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline uint64_t odpdrv_atomic_fetch_inc_u64(odpdrv_atomic_u64_t *atom)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- return ATOMIC_OP(atom, atom->v++);
-#else
- return __atomic_fetch_add(&atom->v, 1, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline void odpdrv_atomic_inc_u64(odpdrv_atomic_u64_t *atom)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v++);
-#else
- (void)__atomic_fetch_add(&atom->v, 1, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline uint64_t odpdrv_atomic_fetch_dec_u64(odpdrv_atomic_u64_t *atom)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- return ATOMIC_OP(atom, atom->v--);
-#else
- return __atomic_fetch_sub(&atom->v, 1, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline void odpdrv_atomic_dec_u64(odpdrv_atomic_u64_t *atom)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v--);
-#else
- (void)__atomic_fetch_sub(&atom->v, 1, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline int odpdrv_atomic_cas_u64(odpdrv_atomic_u64_t *atom,
- uint64_t *old_val, uint64_t new_val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- int ret;
- *old_val = ATOMIC_OP(atom, ATOMIC_CAS_OP(&ret, *old_val, new_val));
- return ret;
-#else
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_RELAXED,
- __ATOMIC_RELAXED);
-#endif
-}
-
-static inline uint64_t odpdrv_atomic_xchg_u64(odpdrv_atomic_u64_t *atom,
- uint64_t new_val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- return ATOMIC_OP(atom, atom->v = new_val);
-#else
- return __atomic_exchange_n(&atom->v, new_val, __ATOMIC_RELAXED);
-#endif
-}
-
-static inline void odpdrv_atomic_max_u64(odpdrv_atomic_u64_t *atom,
- uint64_t new_max)
-{
- uint64_t old_val;
-
- old_val = odpdrv_atomic_load_u64(atom);
-
- while (new_max > old_val) {
- if (odpdrv_atomic_cas_u64(atom, &old_val, new_max))
- break;
- }
-}
-
-static inline void odpdrv_atomic_min_u64(odpdrv_atomic_u64_t *atom,
- uint64_t new_min)
-{
- uint64_t old_val;
-
- old_val = odpdrv_atomic_load_u64(atom);
-
- while (new_min < old_val) {
- if (odpdrv_atomic_cas_u64(atom, &old_val, new_min))
- break;
- }
-}
-
-static inline uint32_t odpdrv_atomic_load_acq_u32(odpdrv_atomic_u32_t *atom)
-{
- return __atomic_load_n(&atom->v, __ATOMIC_ACQUIRE);
-}
-
-static inline void odpdrv_atomic_store_rel_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- __atomic_store_n(&atom->v, val, __ATOMIC_RELEASE);
-}
-
-static inline void odpdrv_atomic_add_rel_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- (void)__atomic_fetch_add(&atom->v, val, __ATOMIC_RELEASE);
-}
-
-static inline void odpdrv_atomic_sub_rel_u32(odpdrv_atomic_u32_t *atom,
- uint32_t val)
-{
- (void)__atomic_fetch_sub(&atom->v, val, __ATOMIC_RELEASE);
-}
-
-static inline int odpdrv_atomic_cas_acq_u32(odpdrv_atomic_u32_t *atom,
- uint32_t *old_val, uint32_t new_val)
-{
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_ACQUIRE,
- __ATOMIC_RELAXED);
-}
-
-static inline int odpdrv_atomic_cas_rel_u32(odpdrv_atomic_u32_t *atom,
- uint32_t *old_val, uint32_t new_val)
-{
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_RELEASE,
- __ATOMIC_RELAXED);
-}
-
-static inline int odpdrv_atomic_cas_acq_rel_u32(odpdrv_atomic_u32_t *atom,
- uint32_t *old_val,
- uint32_t new_val)
-{
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_ACQ_REL,
- __ATOMIC_RELAXED);
-}
-
-static inline uint64_t odpdrv_atomic_load_acq_u64(odpdrv_atomic_u64_t *atom)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- return ATOMIC_OP(atom, (void)0);
-#else
- return __atomic_load_n(&atom->v, __ATOMIC_ACQUIRE);
-#endif
-}
-
-static inline void odpdrv_atomic_store_rel_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v = val);
-#else
- __atomic_store_n(&atom->v, val, __ATOMIC_RELEASE);
-#endif
-}
-
-static inline void odpdrv_atomic_add_rel_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v += val);
-#else
- (void)__atomic_fetch_add(&atom->v, val, __ATOMIC_RELEASE);
-#endif
-}
-
-static inline void odpdrv_atomic_sub_rel_u64(odpdrv_atomic_u64_t *atom,
- uint64_t val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- (void)ATOMIC_OP(atom, atom->v -= val);
-#else
- (void)__atomic_fetch_sub(&atom->v, val, __ATOMIC_RELEASE);
-#endif
-}
-
-static inline int odpdrv_atomic_cas_acq_u64(odpdrv_atomic_u64_t *atom,
- uint64_t *old_val, uint64_t new_val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- int ret;
- *old_val = ATOMIC_OP(atom, ATOMIC_CAS_OP(&ret, *old_val, new_val));
- return ret;
-#else
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_ACQUIRE,
- __ATOMIC_RELAXED);
-#endif
-}
-
-static inline int odpdrv_atomic_cas_rel_u64(odpdrv_atomic_u64_t *atom,
- uint64_t *old_val, uint64_t new_val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- int ret;
- *old_val = ATOMIC_OP(atom, ATOMIC_CAS_OP(&ret, *old_val, new_val));
- return ret;
-#else
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_RELEASE,
- __ATOMIC_RELAXED);
-#endif
-}
-
-static inline int odpdrv_atomic_cas_acq_rel_u64(odpdrv_atomic_u64_t *atom,
- uint64_t *old_val,
- uint64_t new_val)
-{
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- int ret;
- *old_val = ATOMIC_OP(atom, ATOMIC_CAS_OP(&ret, *old_val, new_val));
- return ret;
-#else
- return __atomic_compare_exchange_n(&atom->v, old_val, new_val,
- 0 /* strong */,
- __ATOMIC_ACQ_REL,
- __ATOMIC_RELAXED);
-#endif
-}
-
-/**
- * @}
- */
-
-#include <odp/drv/spec/atomic.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,30 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV execution barriers
- */
-
-#ifndef ODPDRV_PLAT_BARRIER_H_
-#define ODPDRV_PLAT_BARRIER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/std_types.h>
-#include <odp/drv/atomic.h>
-#include <odp/drv/plat/barrier_types.h>
-
-#include <odp/drv/spec/barrier.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,146 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV byteorder
- */
-
-#ifndef ODPDRV_PLAT_BYTEORDER_H_
-#define ODPDRV_PLAT_BYTEORDER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/plat/byteorder_types.h>
-#include <odp/drv/std_types.h>
-#include <odp/drv/compiler.h>
-
-/** @ingroup odpdrv_compiler_optim
- * @{
- */
-
-static inline uint16_t odpdrv_be_to_cpu_16(odpdrv_u16be_t be16)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return __odpdrv_builtin_bswap16((__odpdrv_force uint16_t)be16);
-#else
- return (__odpdrv_force uint16_t)be16;
-#endif
-}
-
-static inline uint32_t odpdrv_be_to_cpu_32(odpdrv_u32be_t be32)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return __builtin_bswap32((__odpdrv_force uint32_t)be32);
-#else
- return (__odpdrv_force uint32_t)be32;
-#endif
-}
-
-static inline uint64_t odpdrv_be_to_cpu_64(odpdrv_u64be_t be64)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return __builtin_bswap64((__odpdrv_force uint64_t)be64);
-#else
- return (__odpdrv_force uint64_t)be64;
-#endif
-}
-
-static inline odpdrv_u16be_t odpdrv_cpu_to_be_16(uint16_t cpu16)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force odpdrv_u16be_t)__odpdrv_builtin_bswap16(cpu16);
-#else
- return (__odpdrv_force odpdrv_u16be_t)cpu16;
-#endif
-}
-
-static inline odpdrv_u32be_t odpdrv_cpu_to_be_32(uint32_t cpu32)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force odpdrv_u32be_t)__builtin_bswap32(cpu32);
-#else
- return (__odpdrv_force odpdrv_u32be_t)cpu32;
-#endif
-}
-
-static inline odpdrv_u64be_t odpdrv_cpu_to_be_64(uint64_t cpu64)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force odpdrv_u64be_t)__builtin_bswap64(cpu64);
-#else
- return (__odpdrv_force odpdrv_u64be_t)cpu64;
-#endif
-}
-
-static inline uint16_t odpdrv_le_to_cpu_16(odpdrv_u16le_t le16)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force uint16_t)le16;
-#else
- return __odpdrv_builtin_bswap16((__odpdrv_force uint16_t)le16);
-#endif
-}
-
-static inline uint32_t odpdrv_le_to_cpu_32(odpdrv_u32le_t le32)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force uint32_t)le32;
-#else
- return __builtin_bswap32((__odpdrv_force uint32_t)le32);
-#endif
-}
-
-static inline uint64_t odpdrv_le_to_cpu_64(odpdrv_u64le_t le64)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force uint64_t)le64;
-#else
- return __builtin_bswap64((__odpdrv_force uint64_t)le64);
-#endif
-}
-
-static inline odpdrv_u16le_t odpdrv_cpu_to_le_16(uint16_t cpu16)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force odpdrv_u16le_t)cpu16;
-#else
- return (__odpdrv_force odpdrv_u16le_t)__odpdrv_builtin_bswap16(cpu16);
-#endif
-}
-
-static inline odpdrv_u32le_t odpdrv_cpu_to_le_32(uint32_t cpu32)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force odpdrv_u32le_t)cpu32;
-#else
- return (__odpdrv_force odpdrv_u32le_t)__builtin_bswap32(cpu32);
-#endif
-}
-
-static inline odpdrv_u64le_t odpdrv_cpu_to_le_64(uint64_t cpu64)
-{
-#if ODPDRV_BYTE_ORDER == ODPDRV_LITTLE_ENDIAN
- return (__odpdrv_force odpdrv_u64le_t)cpu64;
-#else
- return (__odpdrv_force odpdrv_u64le_t)__builtin_bswap64(cpu64);
-#endif
-}
-
-/**
- * @}
- */
-
-#include <odp/drv/spec/byteorder.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,37 +0,0 @@
-/* Copyright (c) 2017, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV drivers
- */
-
-#ifndef ODPDRV_PLAT_DRIVER_H_
-#define ODPDRV_PLAT_DRIVER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/plat/driver_types.h>
-
-/** @ingroup odpdrv_driver
- * @{
- */
-
-/**
- * @}
- */
-
-#include <odp/drv/std_types.h>
-#include <odp/drv/spec/driver.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,88 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV atomic operations
- */
-
-#ifndef ODPDRV_ATOMIC_TYPES_H_
-#define ODPDRV_ATOMIC_TYPES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/std_types.h>
-#include <odp/drv/align.h>
-
-/**
- * @internal
- * Atomic 64-bit unsigned integer
- */
-struct odpdrv_atomic_u64_s {
- uint64_t v; /**< Actual storage for the atomic variable */
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
- /* Some architectures do not support lock-free operations on 64-bit
- * data types. We use a spin lock to ensure atomicity. */
- char lock; /**< Spin lock (if needed) used to ensure atomic access */
-#endif
-} ODPDRV_ALIGNED(sizeof(uint64_t)); /* Enforce alignement! */;
-
-/**
- * @internal
- * Atomic 32-bit unsigned integer
- */
-struct odpdrv_atomic_u32_s {
- uint32_t v; /**< Actual storage for the atomic variable */
-} ODPDRV_ALIGNED(sizeof(uint32_t)); /* Enforce alignement! */;
-
-#if __GCC_ATOMIC_LLONG_LOCK_FREE < 2
-
-/**
- * @internal
- * CAS operation expression for the ATOMIC_OP macro
- */
-#define ATOMIC_CAS_OP(ret_ptr, old_val, new_val) \
-({ \
- if (atom->v == (old_val)) { \
- atom->v = (new_val); \
- *(ret_ptr) = 1; \
- } else { \
- *(ret_ptr) = 0; \
- } \
-})
-
-/**
- * @internal
- * Helper macro for lock-based atomic operations on 64-bit integers
- * @param[in,out] atom Pointer to the 64-bit atomic variable
- * @param expr Expression used update the variable.
- * @return The old value of the variable.
- */
-#define ATOMIC_OP(atom, expr) \
-({ \
- uint64_t _old_val; \
- /* Loop while lock is already taken, stop when lock becomes clear */ \
- while (__atomic_test_and_set(&(atom)->lock, __ATOMIC_ACQUIRE)) \
- (void)0; \
- _old_val = (atom)->v; \
- (expr); /* Perform whatever update is desired */ \
- __atomic_clear(&(atom)->lock, __ATOMIC_RELEASE); \
- _old_val; /* Return old value */ \
-})
-#endif
-
-typedef struct odpdrv_atomic_u64_s odpdrv_atomic_u64_t;
-
-typedef struct odpdrv_atomic_u32_s odpdrv_atomic_u32_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,38 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV barrier
- */
-
-#ifndef ODPDRV_BARRIER_TYPES_H_
-#define ODPDRV_BARRIER_TYPES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/std_types.h>
-#include <odp/drv/atomic.h>
-
-/**
- * @internal
- * ODPDRV thread synchronization barrier
- */
-struct odpdrv_barrier_s {
- uint32_t count; /**< Thread count */
- odpdrv_atomic_u32_t bar; /**< Barrier counter */
-};
-
-typedef struct odpdrv_barrier_s odpdrv_barrier_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,84 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV byteorder
- */
-
-#ifndef ODPDRV_BYTEORDER_TYPES_H_
-#define ODPDRV_BYTEORDER_TYPES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef __BYTE_ORDER__
-#error __BYTE_ORDER not defined!
-#endif
-
-#ifndef __ORDER_BIG_ENDIAN__
-#error __BIG_ENDIAN not defined!
-#endif
-
-#ifndef __ORDER_LITTLE_ENDIAN__
-#error __LITTLE_ENDIAN not defined!
-#endif
-
-/* for use with type checkers such as sparse */
-#ifdef __CHECKER__
-/** @internal bitwise attribute */
-#define __odpdrv_bitwise __attribute__((bitwise))
-/** @internal force attribute */
-#define __odpdrv_force __attribute__((force))
-#else
-/** @internal bitwise attribute */
-#define __odpdrv_bitwise
-/** @internal force attribute */
-#define __odpdrv_force
-#endif
-
-/** @addtogroup odpdrv_compiler_optim
- * @{
- */
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
- #define ODPDRV_LITTLE_ENDIAN 1
- #define ODPDRV_BIG_ENDIAN 0
- #define ODPDRV_BYTE_ORDER ODPDRV_LITTLE_ENDIAN
- #define ODPDRV_LITTLE_ENDIAN_BITFIELD 1
- #define ODPDRV_BIG_ENDIAN_BITFIELD 0
- #define ODPDRV_BITFIELD_ORDER ODPDRV_LITTLE_ENDIAN_BITFIELD
-#else
- #define ODPDRV_LITTLE_ENDIAN 0
- #define ODPDRV_BIG_ENDIAN 1
- #define ODPDRV_BYTE_ORDER ODPDRV_BIG_ENDIAN
- #define ODPDRV_LITTLE_ENDIAN_BITFIELD 0
- #define ODPDRV_BIG_ENDIAN_BITFIELD 1
- #define ODPDRV_BITFIELD_ORDER ODPDRV_BIG_ENDIAN_BITFIELD
-#endif
-
-typedef uint16_t __odpdrv_bitwise odpdrv_u16le_t;
-typedef uint16_t __odpdrv_bitwise odpdrv_u16be_t;
-
-typedef uint32_t __odpdrv_bitwise odpdrv_u32le_t;
-typedef uint32_t __odpdrv_bitwise odpdrv_u32be_t;
-
-typedef uint64_t __odpdrv_bitwise odpdrv_u64le_t;
-typedef uint64_t __odpdrv_bitwise odpdrv_u64be_t;
-
-typedef uint16_t __odpdrv_bitwise odpdrv_u16sum_t;
-typedef uint32_t __odpdrv_bitwise odpdrv_u32sum_t;
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,52 +0,0 @@
-/* Copyright (c) 2017, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODP shared memory
- */
-
-#ifndef ODPDRV_DRIVER_TYPES_H_
-#define ODPDRV_DRIVER_TYPES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/std_types.h>
-#include <odp/drv/plat/strong_types.h>
-
-/** @addtogroup odpdrv_driver ODPDRV DRIVER
- * Operations on driver related items (enumerator class, enumerators,
- * devios and drivers).
- * @{
- */
-
-typedef ODPDRV_HANDLE_T(odpdrv_enumr_class_t);
-#define ODPDRV_ENUMR_CLASS_INVALID _odpdrv_cast_scalar(odpdrv_enumr_class_t, 0)
-
-typedef ODPDRV_HANDLE_T(odpdrv_enumr_t);
-#define ODPDRV_ENUMR_INVALID _odpdrv_cast_scalar(odpdrv_enumr_t, 0)
-
-typedef ODPDRV_HANDLE_T(odpdrv_device_t);
-#define ODPDRV_DEVICE_INVALID _odpdrv_cast_scalar(odpdrv_device_t, 0)
-
-typedef ODPDRV_HANDLE_T(odpdrv_devio_t);
-#define ODPDRV_DEVIO_INVALID _odpdrv_cast_scalar(odpdrv_devio_t, 0)
-
-typedef ODPDRV_HANDLE_T(odpdrv_driver_t);
-#define ODPDRV_DRIVER_INVALID _odpdrv_cast_scalar(odpdrv_driver_t, 0)
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,49 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODP shared memory
- */
-
-#ifndef ODPDRV_SHM_TYPES_H_
-#define ODPDRV_SHM_TYPES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/std_types.h>
-#include <odp/drv/plat/strong_types.h>
-
-/** @addtogroup odpdrv_shm ODPDRV SHARED MEMORY
- * Operations on driver shared memory.
- * @{
- */
-
-typedef ODPDRV_HANDLE_T(odpdrv_shm_t);
-
-#define ODPDRV_SHM_INVALID _odpdrv_cast_scalar(odpdrv_shm_t, 0)
-
-/** Get printable format of odpdrv_shm_t */
-static inline uint64_t odpdrv_shm_to_u64(odpdrv_shm_t hdl)
-{
- return _odpdrv_pri(hdl);
-}
-
-typedef ODPDRV_HANDLE_T(odpdrv_shm_pool_t);
-
-#define ODPDRV_SHM_POOL_INVALID _odpdrv_cast_scalar(odpdrv_shm_pool_t, NULL)
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,33 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV spinlock
- */
-
-#ifndef ODPDRV_SPINLOCK_TYPES_H_
-#define ODPDRV_SPINLOCK_TYPES_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/std_types.h>
-
-/** @internal */
-struct odpdrv_spinlock_s {
- char lock; /**< lock flag, should match odpdrv_atomic_flag_t */
-};
-
-typedef struct odpdrv_spinlock_s odpdrv_spinlock_t;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,35 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV Strong Types. Common macros for implementing strong typing
- * for ODPDRV abstract data types
- */
-
-#ifndef ODPDRV_STRONG_TYPES_H_
-#define ODPDRV_STRONG_TYPES_H_
-
-/** Use strong typing for ODPDRV types */
-#ifdef __cplusplus
-#define ODPDRV_HANDLE_T(type) struct _##type { uint8_t unused_dummy_var; } *type
-#else
-#define odpdrv_handle_t struct { uint8_t unused_dummy_var; } *
-/** C/C++ helper macro for strong typing */
-#define ODPDRV_HANDLE_T(type) odpdrv_handle_t type
-#endif
-
-/** Internal macro to get value of an ODPDRV handle */
-#define _odpdrv_typeval(handle) ((uint32_t)(uintptr_t)(handle))
-
-/** Internal macro to get printable value of an ODPDRV handle */
-#define _odpdrv_pri(handle) ((uint64_t)_odpdrv_typeval(handle))
-
-/** Internal macro to convert a scalar to a typed handle */
-#define _odpdrv_cast_scalar(type, val) ((type)(uintptr_t)(val))
-
-#endif
deleted file mode 100644
@@ -1,36 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV shared memory
- */
-
-#ifndef ODPDRV_PLAT_SHM_H_
-#define ODPDRV_PLAT_SHM_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/plat/shm_types.h>
-
-/** @ingroup odpdrv_shm
- * @{
- */
-
-/**
- * @}
- */
-
-#include <odp/drv/spec/shm.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,28 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV spinlock
- */
-
-#ifndef ODPDRV_PLAT_SPINLOCK_H_
-#define ODPDRV_PLAT_SPINLOCK_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <odp/drv/plat/spinlock_types.h>
-
-#include <odp/drv/spec/spinlock.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
deleted file mode 100644
@@ -1,49 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-/**
- * @file
- *
- * ODPDRV synchronisation
- */
-
-#ifndef ODPDRV_PLAT_SYNC_H_
-#define ODPDRV_PLAT_SYNC_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** @ingroup odpdrv_barrier
- * @{
- */
-
-static inline void odpdrv_mb_release(void)
-{
- __atomic_thread_fence(__ATOMIC_RELEASE);
-}
-
-static inline void odpdrv_mb_acquire(void)
-{
- __atomic_thread_fence(__ATOMIC_ACQUIRE);
-}
-
-static inline void odpdrv_mb_full(void)
-{
- __atomic_thread_fence(__ATOMIC_SEQ_CST);
-}
-
-/**
- * @}
- */
-
-#include <odp/drv/spec/sync.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
@@ -134,12 +134,6 @@
*/
#define ODP_CONFIG_ISHM_VA_PREALLOC_SZ (536870912L)
-/* Maximum number of shared memory blocks available on the driver interface.
- *
- * This the the number of separate SHM areas that can be reserved concurrently
- */
-#define ODPDRV_CONFIG_SHM_BLOCKS 48
-
/* Maximum event burst size
*
* This controls the burst size on various enqueue, dequeue, etc calls. Large
@@ -32,7 +32,4 @@ AC_CONFIG_FILES([test/Makefile
test/validation/api/thread/Makefile
test/validation/api/time/Makefile
test/validation/api/timer/Makefile
- test/validation/api/traffic_mngr/Makefile
- test/validation/drv/Makefile
- test/validation/drv/drvatomic/Makefile
- test/validation/drv/drvshmem/Makefile])
+ test/validation/api/traffic_mngr/Makefile])
@@ -1,4 +1,3 @@
if test_vald
- SUBDIRS = api \
- drv
+ SUBDIRS = api
endif
deleted file mode 100644
@@ -1,2 +0,0 @@
-*.log
-*.trs
deleted file mode 100644
@@ -1,4 +0,0 @@
-ODPDRV_MODULES = drvatomic \
- drvshmem
-
-SUBDIRS = $(ODPDRV_MODULES)
deleted file mode 100644
@@ -1 +0,0 @@
-include $(top_srcdir)/test/validation/Makefile.inc
deleted file mode 100644
@@ -1,35 +0,0 @@
-Copyright (c) 2016, Linaro Limited
-All rights reserved.
-
-SPDX-License-Identifier: BSD-3-Clause
-
-
-To add tests in here, please observe the rules listed below. This list
-is a brief overview, for a more detailed explanation of the test
-framework refer to the ODP Implementers' Guide, which can built as
-follows:
-
- ./configure --enable-user-guides
- make
-
-Output will be in doc/output/. If this fails, check the documentation
-section of the DEPENDENCIES file.
-
-Rules for all tests under this tree:
-
-1. Tests must be placed in the directory of the module they belong to.
-
-2. Tests must be platform agnostic, i.e.
-
- - should be written in plain C only.
- - may only use C standard library functions, CUnit functions and of
- course ODP functions
- - should be expected to pass on all ODP implementations
-
- Tests that do not follow these rules should be placed in the platform
- specific test area (currently platform/<platform>/test/).
-
-3. If a new ODP DRV module is created, please update the Makefile.am.
-
-4. Symbols exported from test libraries must respect the naming
- convention detailed in the ODP Implementers' Guide.
deleted file mode 100644
@@ -1 +0,0 @@
-drvatomic_main
deleted file mode 100644
@@ -1,10 +0,0 @@
-include ../Makefile.inc
-
-noinst_LTLIBRARIES = libtestdrvatomic.la
-libtestdrvatomic_la_SOURCES = drvatomic.c
-
-test_PROGRAMS = drvatomic_main$(EXEEXT)
-dist_drvatomic_main_SOURCES = drvatomic_main.c
-drvatomic_main_LDADD = libtestdrvatomic.la $(LIBCUNIT_COMMON) $(LIBODP)
-
-EXTRA_DIST = drvatomic.h
deleted file mode 100644
@@ -1,892 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <malloc.h>
-#include <odp_api.h>
-#include <odp_drv.h>
-#include <CUnit/Basic.h>
-#include <odp_cunit_common.h>
-#include <unistd.h>
-#include "drvatomic.h"
-
-#define VERBOSE 0
-#define MAX_ITERATIONS 1000
-
-#define ADD_SUB_CNT 5
-
-#define CNT 10
-#define U32_INIT_VAL (1UL << 10)
-#define U64_INIT_VAL (1ULL << 33)
-#define U32_MAGIC 0xa23f65b2
-#define U64_MAGIC 0xf2e1c5430cb6a52e
-
-#define GLOBAL_SHM_NAME "GlobalLockTest"
-
-#define UNUSED __attribute__((__unused__))
-
-#define CHECK_MAX_MIN (1 << 0)
-#define CHECK_XCHG (1 << 2)
-
-static odpdrv_atomic_u32_t a32u;
-static odpdrv_atomic_u64_t a64u;
-static odpdrv_atomic_u32_t a32u_min;
-static odpdrv_atomic_u32_t a32u_max;
-static odpdrv_atomic_u64_t a64u_min;
-static odpdrv_atomic_u64_t a64u_max;
-static odpdrv_atomic_u32_t a32u_xchg;
-static odpdrv_atomic_u64_t a64u_xchg;
-
-typedef __volatile uint32_t volatile_u32_t;
-typedef __volatile uint64_t volatile_u64_t;
-
-typedef struct {
- /* Global variables */
- uint32_t g_num_threads;
- uint32_t g_iterations;
- uint32_t g_verbose;
- uint32_t g_max_num_cores;
-
- 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;
-
- volatile_u64_t delay_counter;
-} per_thread_mem_t;
-
-static odp_shm_t global_shm;
-static global_shared_mem_t *global_mem;
-
-/* 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_cpu_id();
-
- global_shm = odp_shm_lookup(GLOBAL_SHM_NAME);
- global_mem = odp_shm_addr(global_shm);
- CU_ASSERT_PTR_NOT_NULL(global_mem);
-
- 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 test_atomic_inc_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_inc_u32(&a32u);
-}
-
-static void test_atomic_inc_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_inc_u64(&a64u);
-}
-
-static void test_atomic_dec_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_dec_u32(&a32u);
-}
-
-static void test_atomic_dec_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_dec_u64(&a64u);
-}
-
-static void test_atomic_fetch_inc_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_inc_u32(&a32u);
-}
-
-static void test_atomic_fetch_inc_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_inc_u64(&a64u);
-}
-
-static void test_atomic_fetch_dec_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_dec_u32(&a32u);
-}
-
-static void test_atomic_fetch_dec_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_dec_u64(&a64u);
-}
-
-static void test_atomic_add_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_add_u32(&a32u, ADD_SUB_CNT);
-}
-
-static void test_atomic_add_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_add_u64(&a64u, ADD_SUB_CNT);
-}
-
-static void test_atomic_sub_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_sub_u32(&a32u, ADD_SUB_CNT);
-}
-
-static void test_atomic_sub_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_sub_u64(&a64u, ADD_SUB_CNT);
-}
-
-static void test_atomic_fetch_add_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_add_u32(&a32u, ADD_SUB_CNT);
-}
-
-static void test_atomic_fetch_add_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_add_u64(&a64u, ADD_SUB_CNT);
-}
-
-static void test_atomic_fetch_sub_32(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_sub_u32(&a32u, ADD_SUB_CNT);
-}
-
-static void test_atomic_fetch_sub_64(void)
-{
- int i;
-
- for (i = 0; i < CNT; i++)
- odpdrv_atomic_fetch_sub_u64(&a64u, ADD_SUB_CNT);
-}
-
-static void test_atomic_min_32(void)
-{
- int i;
- uint32_t tmp;
-
- for (i = 0; i < CNT; i++) {
- tmp = odpdrv_atomic_fetch_dec_u32(&a32u);
- odpdrv_atomic_min_u32(&a32u_min, tmp);
- }
-}
-
-static void test_atomic_min_64(void)
-{
- int i;
- uint64_t tmp;
-
- for (i = 0; i < CNT; i++) {
- tmp = odpdrv_atomic_fetch_dec_u64(&a64u);
- odpdrv_atomic_min_u64(&a64u_min, tmp);
- }
-}
-
-static void test_atomic_max_32(void)
-{
- int i;
- uint32_t tmp;
-
- for (i = 0; i < CNT; i++) {
- tmp = odpdrv_atomic_fetch_inc_u32(&a32u);
- odpdrv_atomic_max_u32(&a32u_max, tmp);
- }
-}
-
-static void test_atomic_max_64(void)
-{
- int i;
- uint64_t tmp;
-
- for (i = 0; i < CNT; i++) {
- tmp = odpdrv_atomic_fetch_inc_u64(&a64u);
- odpdrv_atomic_max_u64(&a64u_max, tmp);
- }
-}
-
-static void test_atomic_cas_inc_32(void)
-{
- int i;
- uint32_t old;
-
- for (i = 0; i < CNT; i++) {
- old = odpdrv_atomic_load_u32(&a32u);
-
- while (odpdrv_atomic_cas_u32(&a32u, &old, old + 1) == 0)
- ;
- }
-}
-
-static void test_atomic_cas_dec_32(void)
-{
- int i;
- uint32_t old;
-
- for (i = 0; i < CNT; i++) {
- old = odpdrv_atomic_load_u32(&a32u);
-
- while (odpdrv_atomic_cas_u32(&a32u, &old, old - 1) == 0)
- ;
- }
-}
-
-static void test_atomic_cas_inc_64(void)
-{
- int i;
- uint64_t old;
-
- for (i = 0; i < CNT; i++) {
- old = odpdrv_atomic_load_u64(&a64u);
-
- while (odpdrv_atomic_cas_u64(&a64u, &old, old + 1) == 0)
- ;
- }
-}
-
-static void test_atomic_cas_dec_64(void)
-{
- int i;
- uint64_t old;
-
- for (i = 0; i < CNT; i++) {
- old = odpdrv_atomic_load_u64(&a64u);
-
- while (odpdrv_atomic_cas_u64(&a64u, &old, old - 1) == 0)
- ;
- }
-}
-
-static void test_atomic_xchg_32(void)
-{
- uint32_t old, new;
- int i;
-
- for (i = 0; i < CNT; i++) {
- new = odpdrv_atomic_fetch_inc_u32(&a32u);
- old = odpdrv_atomic_xchg_u32(&a32u_xchg, new);
-
- if (old & 0x1)
- odpdrv_atomic_xchg_u32(&a32u_xchg, 0);
- else
- odpdrv_atomic_xchg_u32(&a32u_xchg, 1);
- }
-
- odpdrv_atomic_sub_u32(&a32u, CNT);
- odpdrv_atomic_xchg_u32(&a32u_xchg, U32_MAGIC);
-}
-
-static void test_atomic_xchg_64(void)
-{
- uint64_t old, new;
- int i;
-
- for (i = 0; i < CNT; i++) {
- new = odpdrv_atomic_fetch_inc_u64(&a64u);
- old = odpdrv_atomic_xchg_u64(&a64u_xchg, new);
-
- if (old & 0x1)
- odpdrv_atomic_xchg_u64(&a64u_xchg, 0);
- else
- odpdrv_atomic_xchg_u64(&a64u_xchg, 1);
- }
-
- odpdrv_atomic_sub_u64(&a64u, CNT);
- odpdrv_atomic_xchg_u64(&a64u_xchg, U64_MAGIC);
-}
-
-static void test_atomic_non_relaxed_32(void)
-{
- int i;
- uint32_t tmp;
-
- for (i = 0; i < CNT; i++) {
- tmp = odpdrv_atomic_load_acq_u32(&a32u);
- odpdrv_atomic_store_rel_u32(&a32u, tmp);
-
- tmp = odpdrv_atomic_load_acq_u32(&a32u_max);
- odpdrv_atomic_add_rel_u32(&a32u_max, 1);
-
- tmp = odpdrv_atomic_load_acq_u32(&a32u_min);
- odpdrv_atomic_sub_rel_u32(&a32u_min, 1);
-
- tmp = odpdrv_atomic_load_u32(&a32u_xchg);
- while (odpdrv_atomic_cas_acq_u32(&a32u_xchg, &tmp, tmp + 1)
- == 0)
- ;
-
- tmp = odpdrv_atomic_load_u32(&a32u_xchg);
- while (odpdrv_atomic_cas_rel_u32(&a32u_xchg, &tmp, tmp + 1)
- == 0)
- ;
-
- tmp = odpdrv_atomic_load_u32(&a32u_xchg);
- /* finally set value for validation */
- while (odpdrv_atomic_cas_acq_rel_u32(&a32u_xchg, &tmp,
- U32_MAGIC)
- == 0)
- ;
- }
-}
-
-static void test_atomic_non_relaxed_64(void)
-{
- int i;
- uint64_t tmp;
-
- for (i = 0; i < CNT; i++) {
- tmp = odpdrv_atomic_load_acq_u64(&a64u);
- odpdrv_atomic_store_rel_u64(&a64u, tmp);
-
- tmp = odpdrv_atomic_load_acq_u64(&a64u_max);
- odpdrv_atomic_add_rel_u64(&a64u_max, 1);
-
- tmp = odpdrv_atomic_load_acq_u64(&a64u_min);
- odpdrv_atomic_sub_rel_u64(&a64u_min, 1);
-
- tmp = odpdrv_atomic_load_u64(&a64u_xchg);
- while (odpdrv_atomic_cas_acq_u64(&a64u_xchg, &tmp, tmp + 1)
- == 0)
- ;
-
- tmp = odpdrv_atomic_load_u64(&a64u_xchg);
- while (odpdrv_atomic_cas_rel_u64(&a64u_xchg, &tmp, tmp + 1)
- == 0)
- ;
-
- tmp = odpdrv_atomic_load_u64(&a64u_xchg);
- /* finally set value for validation */
- while (odpdrv_atomic_cas_acq_rel_u64(&a64u_xchg, &tmp,
- U64_MAGIC)
- == 0)
- ;
- }
-}
-
-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_max_min_32(void)
-{
- test_atomic_max_32();
- test_atomic_min_32();
-}
-
-static void test_atomic_max_min_64(void)
-{
- test_atomic_max_64();
- test_atomic_min_64();
-}
-
-static void test_atomic_cas_inc_dec_32(void)
-{
- test_atomic_cas_inc_32();
- test_atomic_cas_dec_32();
-}
-
-static void test_atomic_cas_inc_dec_64(void)
-{
- test_atomic_cas_inc_64();
- test_atomic_cas_dec_64();
-}
-
-static void test_atomic_init(void)
-{
- odpdrv_atomic_init_u32(&a32u, 0);
- odpdrv_atomic_init_u64(&a64u, 0);
- odpdrv_atomic_init_u32(&a32u_min, 0);
- odpdrv_atomic_init_u32(&a32u_max, 0);
- odpdrv_atomic_init_u64(&a64u_min, 0);
- odpdrv_atomic_init_u64(&a64u_max, 0);
- odpdrv_atomic_init_u32(&a32u_xchg, 0);
- odpdrv_atomic_init_u64(&a64u_xchg, 0);
-}
-
-static void test_atomic_store(void)
-{
- odpdrv_atomic_store_u32(&a32u, U32_INIT_VAL);
- odpdrv_atomic_store_u64(&a64u, U64_INIT_VAL);
- odpdrv_atomic_store_u32(&a32u_min, U32_INIT_VAL);
- odpdrv_atomic_store_u32(&a32u_max, U32_INIT_VAL);
- odpdrv_atomic_store_u64(&a64u_min, U64_INIT_VAL);
- odpdrv_atomic_store_u64(&a64u_max, U64_INIT_VAL);
- odpdrv_atomic_store_u32(&a32u_xchg, U32_INIT_VAL);
- odpdrv_atomic_store_u64(&a64u_xchg, U64_INIT_VAL);
-}
-
-static void test_atomic_validate(int check)
-{
- CU_ASSERT(U32_INIT_VAL == odpdrv_atomic_load_u32(&a32u));
- CU_ASSERT(U64_INIT_VAL == odpdrv_atomic_load_u64(&a64u));
-
- if (check & CHECK_MAX_MIN) {
- CU_ASSERT(odpdrv_atomic_load_u32(&a32u_max) >
- odpdrv_atomic_load_u32(&a32u_min));
-
- CU_ASSERT(odpdrv_atomic_load_u64(&a64u_max) >
- odpdrv_atomic_load_u64(&a64u_min));
- }
-
- if (check & CHECK_XCHG) {
- CU_ASSERT(odpdrv_atomic_load_u32(&a32u_xchg) == U32_MAGIC);
- CU_ASSERT(odpdrv_atomic_load_u64(&a64u_xchg) == U64_MAGIC);
- }
-}
-
-int drvatomic_init(odp_instance_t *inst)
-{
- uint32_t workers_count, max_threads;
- int ret = 0;
- odp_cpumask_t mask;
-
- if (0 != odp_init_global(inst, NULL, NULL)) {
- fprintf(stderr, "error: odp_init_global() failed.\n");
- return -1;
- }
- if (0 != odp_init_local(*inst, ODP_THREAD_CONTROL)) {
- fprintf(stderr, "error: odp_init_local() failed.\n");
- return -1;
- }
-
- global_shm = odp_shm_reserve(GLOBAL_SHM_NAME,
- sizeof(global_shared_mem_t), 64,
- ODP_SHM_SW_ONLY);
- if (ODP_SHM_INVALID == global_shm) {
- fprintf(stderr, "Unable reserve memory for global_shm\n");
- return -1;
- }
-
- 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;
-
- workers_count = odp_cpumask_default_worker(&mask, 0);
-
- max_threads = (workers_count >= MAX_WORKERS) ?
- MAX_WORKERS : workers_count;
-
- if (max_threads < global_mem->g_num_threads) {
- printf("Requested num of threads is too large\n");
- printf("reducing from %" PRIu32 " to %" PRIu32 "\n",
- global_mem->g_num_threads,
- max_threads);
- global_mem->g_num_threads = max_threads;
- }
-
- printf("Num of threads used = %" PRIu32 "\n",
- global_mem->g_num_threads);
-
- return ret;
-}
-
-/* Atomic tests */
-static int 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 CU_get_number_of_failures();
-}
-
-static int 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 CU_get_number_of_failures();
-}
-
-static int 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 CU_get_number_of_failures();
-}
-
-static int 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 CU_get_number_of_failures();
-}
-
-static int test_atomic_max_min_thread(void *arg UNUSED)
-{
- per_thread_mem_t *per_thread_mem;
-
- per_thread_mem = thread_init();
- test_atomic_max_min_32();
- test_atomic_max_min_64();
-
- thread_finalize(per_thread_mem);
-
- return CU_get_number_of_failures();
-}
-
-static int test_atomic_cas_inc_dec_thread(void *arg UNUSED)
-{
- per_thread_mem_t *per_thread_mem;
-
- per_thread_mem = thread_init();
- test_atomic_cas_inc_dec_32();
- test_atomic_cas_inc_dec_64();
-
- thread_finalize(per_thread_mem);
-
- return CU_get_number_of_failures();
-}
-
-static int test_atomic_xchg_thread(void *arg UNUSED)
-{
- per_thread_mem_t *per_thread_mem;
-
- per_thread_mem = thread_init();
- test_atomic_xchg_32();
- test_atomic_xchg_64();
-
- thread_finalize(per_thread_mem);
-
- return CU_get_number_of_failures();
-}
-
-static int test_atomic_non_relaxed_thread(void *arg UNUSED)
-{
- per_thread_mem_t *per_thread_mem;
-
- per_thread_mem = thread_init();
- test_atomic_non_relaxed_32();
- test_atomic_non_relaxed_64();
-
- thread_finalize(per_thread_mem);
-
- return CU_get_number_of_failures();
-}
-
-static void test_atomic_functional(int func_ptr(void *), int check)
-{
- 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(check);
-}
-
-void drvatomic_test_atomic_inc_dec(void)
-{
- test_atomic_functional(test_atomic_inc_dec_thread, 0);
-}
-
-void drvatomic_test_atomic_add_sub(void)
-{
- test_atomic_functional(test_atomic_add_sub_thread, 0);
-}
-
-void drvatomic_test_atomic_fetch_inc_dec(void)
-{
- test_atomic_functional(test_atomic_fetch_inc_dec_thread, 0);
-}
-
-void drvatomic_test_atomic_fetch_add_sub(void)
-{
- test_atomic_functional(test_atomic_fetch_add_sub_thread, 0);
-}
-
-void drvatomic_test_atomic_max_min(void)
-{
- test_atomic_functional(test_atomic_max_min_thread, CHECK_MAX_MIN);
-}
-
-void drvatomic_test_atomic_cas_inc_dec(void)
-{
- test_atomic_functional(test_atomic_cas_inc_dec_thread, 0);
-}
-
-void drvatomic_test_atomic_xchg(void)
-{
- test_atomic_functional(test_atomic_xchg_thread, CHECK_XCHG);
-}
-
-void drvatomic_test_atomic_non_relaxed(void)
-{
- test_atomic_functional(test_atomic_non_relaxed_thread,
- CHECK_MAX_MIN | CHECK_XCHG);
-}
-
-void drvatomic_test_atomic_op_lock_free(void)
-{
- odpdrv_atomic_op_t atomic_op;
- int ret_null, ret;
-
- memset(&atomic_op, 0xff, sizeof(odpdrv_atomic_op_t));
- atomic_op.all_bits = 0;
-
- CU_ASSERT(atomic_op.all_bits == 0);
- CU_ASSERT(atomic_op.op.init == 0);
- CU_ASSERT(atomic_op.op.load == 0);
- CU_ASSERT(atomic_op.op.store == 0);
- CU_ASSERT(atomic_op.op.fetch_add == 0);
- CU_ASSERT(atomic_op.op.add == 0);
- CU_ASSERT(atomic_op.op.fetch_sub == 0);
- CU_ASSERT(atomic_op.op.sub == 0);
- CU_ASSERT(atomic_op.op.fetch_inc == 0);
- CU_ASSERT(atomic_op.op.inc == 0);
- CU_ASSERT(atomic_op.op.fetch_dec == 0);
- CU_ASSERT(atomic_op.op.dec == 0);
- CU_ASSERT(atomic_op.op.min == 0);
- CU_ASSERT(atomic_op.op.max == 0);
- CU_ASSERT(atomic_op.op.cas == 0);
- CU_ASSERT(atomic_op.op.xchg == 0);
-
- /* Test setting first, last and couple of other bits */
- atomic_op.op.init = 1;
- CU_ASSERT(atomic_op.op.init == 1);
- CU_ASSERT(atomic_op.all_bits != 0);
- atomic_op.op.init = 0;
- CU_ASSERT(atomic_op.all_bits == 0);
-
- atomic_op.op.xchg = 1;
- CU_ASSERT(atomic_op.op.xchg == 1);
- CU_ASSERT(atomic_op.all_bits != 0);
- atomic_op.op.xchg = 0;
- CU_ASSERT(atomic_op.all_bits == 0);
-
- atomic_op.op.add = 1;
- CU_ASSERT(atomic_op.op.add == 1);
- CU_ASSERT(atomic_op.all_bits != 0);
- atomic_op.op.add = 0;
- CU_ASSERT(atomic_op.all_bits == 0);
-
- atomic_op.op.dec = 1;
- CU_ASSERT(atomic_op.op.dec == 1);
- CU_ASSERT(atomic_op.all_bits != 0);
- atomic_op.op.dec = 0;
- CU_ASSERT(atomic_op.all_bits == 0);
-
- memset(&atomic_op, 0xff, sizeof(odpdrv_atomic_op_t));
- ret = odpdrv_atomic_lock_free_u64(&atomic_op);
- ret_null = odpdrv_atomic_lock_free_u64(NULL);
-
- CU_ASSERT(ret == ret_null);
-
- /* Init operation is not atomic by the spec. Call to
- * odpdrv_atomic_lock_free_u64() zeros it but never sets it. */
-
- if (ret == 0) {
- /* none are lock free */
- CU_ASSERT(atomic_op.all_bits == 0);
- CU_ASSERT(atomic_op.op.init == 0);
- CU_ASSERT(atomic_op.op.load == 0);
- CU_ASSERT(atomic_op.op.store == 0);
- CU_ASSERT(atomic_op.op.fetch_add == 0);
- CU_ASSERT(atomic_op.op.add == 0);
- CU_ASSERT(atomic_op.op.fetch_sub == 0);
- CU_ASSERT(atomic_op.op.sub == 0);
- CU_ASSERT(atomic_op.op.fetch_inc == 0);
- CU_ASSERT(atomic_op.op.inc == 0);
- CU_ASSERT(atomic_op.op.fetch_dec == 0);
- CU_ASSERT(atomic_op.op.dec == 0);
- CU_ASSERT(atomic_op.op.min == 0);
- CU_ASSERT(atomic_op.op.max == 0);
- CU_ASSERT(atomic_op.op.cas == 0);
- CU_ASSERT(atomic_op.op.xchg == 0);
- }
-
- if (ret == 1) {
- /* some are lock free */
- CU_ASSERT(atomic_op.all_bits != 0);
- CU_ASSERT(atomic_op.op.init == 0);
- }
-
- if (ret == 2) {
- /* all are lock free */
- CU_ASSERT(atomic_op.all_bits != 0);
- CU_ASSERT(atomic_op.op.init == 0);
- CU_ASSERT(atomic_op.op.load == 1);
- CU_ASSERT(atomic_op.op.store == 1);
- CU_ASSERT(atomic_op.op.fetch_add == 1);
- CU_ASSERT(atomic_op.op.add == 1);
- CU_ASSERT(atomic_op.op.fetch_sub == 1);
- CU_ASSERT(atomic_op.op.sub == 1);
- CU_ASSERT(atomic_op.op.fetch_inc == 1);
- CU_ASSERT(atomic_op.op.inc == 1);
- CU_ASSERT(atomic_op.op.fetch_dec == 1);
- CU_ASSERT(atomic_op.op.dec == 1);
- CU_ASSERT(atomic_op.op.min == 1);
- CU_ASSERT(atomic_op.op.max == 1);
- CU_ASSERT(atomic_op.op.cas == 1);
- CU_ASSERT(atomic_op.op.xchg == 1);
- }
-}
-
-odp_testinfo_t drvatomic_suite_atomic[] = {
- ODP_TEST_INFO(drvatomic_test_atomic_inc_dec),
- ODP_TEST_INFO(drvatomic_test_atomic_add_sub),
- ODP_TEST_INFO(drvatomic_test_atomic_fetch_inc_dec),
- ODP_TEST_INFO(drvatomic_test_atomic_fetch_add_sub),
- ODP_TEST_INFO(drvatomic_test_atomic_max_min),
- ODP_TEST_INFO(drvatomic_test_atomic_cas_inc_dec),
- ODP_TEST_INFO(drvatomic_test_atomic_xchg),
- ODP_TEST_INFO(drvatomic_test_atomic_non_relaxed),
- ODP_TEST_INFO(drvatomic_test_atomic_op_lock_free),
- ODP_TEST_INFO_NULL,
-};
-
-odp_suiteinfo_t drvatomic_suites[] = {
- {"drvatomic", NULL, NULL,
- drvatomic_suite_atomic},
- ODP_SUITE_INFO_NULL
-};
-
-int drvatomic_main(int argc, char *argv[])
-{
- int ret;
-
- /* parse common options: */
- if (odp_cunit_parse_options(argc, argv))
- return -1;
-
- odp_cunit_register_global_init(drvatomic_init);
-
- ret = odp_cunit_register(drvatomic_suites);
-
- if (ret == 0)
- ret = odp_cunit_run();
-
- return ret;
-}
deleted file mode 100644
@@ -1,35 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#ifndef _ODP_TEST_DRVATOMIC_H_
-#define _ODP_TEST_DRVATOMIC_H_
-
-#include <odp_cunit_common.h>
-
-/* test functions: */
-void drvatomic_test_atomic_inc_dec(void);
-void drvatomic_test_atomic_add_sub(void);
-void drvatomic_test_atomic_fetch_inc_dec(void);
-void drvatomic_test_atomic_fetch_add_sub(void);
-void drvatomic_test_atomic_max_min(void);
-void drvatomic_test_atomic_cas_inc_dec(void);
-void drvatomic_test_atomic_xchg(void);
-void drvatomic_test_atomic_non_relaxed(void);
-void drvatomic_test_atomic_op_lock_free(void);
-
-/* test arrays: */
-extern odp_testinfo_t drvatomic_suite_atomic[];
-
-/* test registry: */
-extern odp_suiteinfo_t drvatomic_suites[];
-
-/* executable init/term functions: */
-int drvatomic_init(odp_instance_t *inst);
-
-/* main test program: */
-int drvatomic_main(int argc, char *argv[]);
-
-#endif
deleted file mode 100644
@@ -1,12 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include "drvatomic.h"
-
-int main(int argc, char *argv[])
-{
- return drvatomic_main(argc, argv);
-}
deleted file mode 100644
@@ -1 +0,0 @@
-drvshmem_main
deleted file mode 100644
@@ -1,10 +0,0 @@
-include ../Makefile.inc
-
-noinst_LTLIBRARIES = libtestdrvshmem.la
-libtestdrvshmem_la_SOURCES = drvshmem.c
-
-test_PROGRAMS = drvshmem_main$(EXEEXT)
-dist_drvshmem_main_SOURCES = drvshmem_main.c
-drvshmem_main_LDADD = libtestdrvshmem.la $(LIBCUNIT_COMMON) $(LIBODP)
-
-EXTRA_DIST = drvshmem.h
deleted file mode 100644
@@ -1,1147 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include <odp_drv.h>
-#include <odp_api.h>
-#include <odp_cunit_common.h>
-#include "drvshmem.h"
-#include <stdlib.h>
-
-#define ALIGN_SIZE (128)
-#define MEM_NAME "test_shmem"
-#define TEST_SHARE_FOO (0xf0f0f0f0)
-#define TEST_SHARE_BAR (0xf0f0f0f)
-#define SMALL_MEM 10
-#define MEDIUM_MEM 4096
-#define BIG_MEM 65536
-#define STRESS_SIZE 32 /* power of 2 and <=256 */
-#define STRESS_RANDOM_SZ 5
-#define STRESS_ITERATION 5000
-
-#define POOL_NAME "test_pool"
-#define POOL_SZ (1UL << 20) /* 1 MBytes */
-#define TEST_SZ 1000
-#define SZ_1K 1024
-#define BUFF_PATTERN 0xA3
-
-typedef enum {
- STRESS_FREE, /* entry is free and can be allocated */
- STRESS_BUSY, /* entry is being processed: don't touch */
- STRESS_ALLOC /* entry is allocated and can be freed */
-} stress_state_t;
-
-typedef struct {
- stress_state_t state;
- odpdrv_shm_t shm;
- void *address;
- uint32_t flags;
- uint32_t size;
- uint64_t align;
- uint8_t data_val;
-} stress_data_t;
-
-typedef struct {
- odpdrv_barrier_t test_barrier1;
- odpdrv_barrier_t test_barrier2;
- odpdrv_barrier_t test_barrier3;
- odpdrv_barrier_t test_barrier4;
- uint32_t foo;
- uint32_t bar;
- odpdrv_atomic_u32_t index;
- uint32_t nb_threads;
- odpdrv_shm_t shm[MAX_WORKERS];
- void *address[MAX_WORKERS];
- odp_spinlock_t stress_lock;
- stress_data_t stress[STRESS_SIZE];
-} shared_test_data_t;
-
-/* memory stuff expected to fit in a single page */
-typedef struct {
- int data[SMALL_MEM];
-} shared_test_data_small_t;
-
-/* memory stuff expected to fit in a huge page */
-typedef struct {
- int data[MEDIUM_MEM];
-} shared_test_data_medium_t;
-
-/* memory stuff expected to fit in many huge pages */
-typedef struct {
- int data[BIG_MEM];
-} shared_test_data_big_t;
-
-/*
- * thread part for the drvshmem_test_basic test
- */
-static int run_test_basic_thread(void *arg ODP_UNUSED)
-{
- odpdrv_shm_info_t info;
- odpdrv_shm_t shm;
- shared_test_data_t *shared_test_data;
- int thr;
-
- thr = odp_thread_id();
- printf("Thread %i starts\n", thr);
-
- shm = odpdrv_shm_lookup_by_name(MEM_NAME);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- shared_test_data = odpdrv_shm_addr(shm);
- CU_ASSERT(NULL != shared_test_data);
-
- odpdrv_barrier_wait(&shared_test_data->test_barrier1);
- odpdrv_shm_print_all("(from thread) After lookup for the global shmem");
- CU_ASSERT(TEST_SHARE_FOO == shared_test_data->foo);
- CU_ASSERT(TEST_SHARE_BAR == shared_test_data->bar);
- CU_ASSERT(0 == odpdrv_shm_info(shm, &info));
- CU_ASSERT(0 == strcmp(MEM_NAME, info.name));
- CU_ASSERT(0 == info.flags);
- CU_ASSERT(shared_test_data == info.addr);
- CU_ASSERT(sizeof(shared_test_data_t) <= info.size);
-#ifdef MAP_HUGETLB
- CU_ASSERT(odp_sys_huge_page_size() == info.page_size);
-#else
- CU_ASSERT(odp_sys_page_size() == info.page_size);
-#endif
- odpdrv_shm_print_all("(from thread) About to end");
-
- fflush(stdout);
- return CU_get_number_of_failures();
-}
-
-/*
- * test basic things: shmem creation, info, share, and free
- */
-void drvshmem_test_basic(void)
-{
- int base; /* memory usage when test starts */
- pthrd_arg thrdarg;
- odpdrv_shm_t shm;
- shared_test_data_t *shared_test_data;
- odp_cpumask_t unused;
-
- base = odpdrv_shm_print_all("Before drvshmem_test_basic");
- shm = odpdrv_shm_reserve(MEM_NAME,
- sizeof(shared_test_data_t), ALIGN_SIZE, 0);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- CU_ASSERT(odpdrv_shm_to_u64(shm) !=
- odpdrv_shm_to_u64(ODPDRV_SHM_INVALID));
-
- CU_ASSERT(0 == odpdrv_shm_free_by_handle(shm));
- CU_ASSERT(ODPDRV_SHM_INVALID == odpdrv_shm_lookup_by_name(MEM_NAME));
-
- shm = odpdrv_shm_reserve(MEM_NAME,
- sizeof(shared_test_data_t), ALIGN_SIZE, 0);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
-
- shared_test_data = odpdrv_shm_addr(shm);
- CU_ASSERT_FATAL(NULL != shared_test_data);
- shared_test_data->foo = TEST_SHARE_FOO;
- shared_test_data->bar = TEST_SHARE_BAR;
-
- thrdarg.numthrds = odp_cpumask_default_worker(&unused, 0);
-
- if (thrdarg.numthrds > MAX_WORKERS)
- thrdarg.numthrds = MAX_WORKERS;
-
- odpdrv_barrier_init(&shared_test_data->test_barrier1, thrdarg.numthrds);
- odp_cunit_thread_create(run_test_basic_thread, &thrdarg);
- CU_ASSERT(odp_cunit_thread_exit(&thrdarg) >= 0);
-
- CU_ASSERT(0 == odpdrv_shm_free_by_handle(shm));
- CU_ASSERT(odpdrv_shm_print_all("Test completion") == base);
-}
-
-/*
- * thread part for the drvshmem_test_reserve_after_fork
- */
-static int run_test_reserve_after_fork(void *arg ODP_UNUSED)
-{
- odpdrv_shm_t shm;
- shared_test_data_t *glob_data;
- int thr;
- int thr_index;
- char *name;
- int name_len;
- int size;
- shared_test_data_small_t *pattern_small;
- shared_test_data_medium_t *pattern_medium;
- shared_test_data_big_t *pattern_big;
- int i;
-
- thr = odp_thread_id();
- printf("Thread %i starts\n", thr);
-
- shm = odpdrv_shm_lookup_by_name(MEM_NAME);
- glob_data = odpdrv_shm_addr(shm);
-
- /*
- * odp_thread_id are not guaranteed to be consecutive, so we create
- * a consecutive ID
- */
- thr_index = odpdrv_atomic_fetch_inc_u32(&glob_data->index);
-
- /* allocate some memory (of different sizes) and fill with pattern */
- name_len = strlen(MEM_NAME) + 20;
- name = malloc(name_len);
- snprintf(name, name_len, "%s-%09d", MEM_NAME, thr_index);
- switch (thr_index % 3) {
- case 0:
- size = sizeof(shared_test_data_small_t);
- shm = odpdrv_shm_reserve(name, size, 0, 0);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data->shm[thr_index] = shm;
- pattern_small = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(pattern_small);
- for (i = 0; i < SMALL_MEM; i++)
- pattern_small->data[i] = i;
- break;
- case 1:
- size = sizeof(shared_test_data_medium_t);
- shm = odpdrv_shm_reserve(name, size, 0, 0);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data->shm[thr_index] = shm;
- pattern_medium = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(pattern_medium);
- for (i = 0; i < MEDIUM_MEM; i++)
- pattern_medium->data[i] = (i << 2);
- break;
- case 2:
- size = sizeof(shared_test_data_big_t);
- shm = odpdrv_shm_reserve(name, size, 0, 0);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data->shm[thr_index] = shm;
- pattern_big = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(pattern_big);
- for (i = 0; i < BIG_MEM; i++)
- pattern_big->data[i] = (i >> 2);
- break;
- }
- free(name);
-
- /* print block address */
- printf("In thread: Block index: %d mapped at %lx\n",
- thr_index, (long int)odpdrv_shm_addr(shm));
-
- odpdrv_barrier_wait(&glob_data->test_barrier1);
- odpdrv_barrier_wait(&glob_data->test_barrier2);
-
- fflush(stdout);
- return CU_get_number_of_failures();
-}
-
-/*
- * test sharing memory reserved after odp_thread creation (e.g. fork()):
- */
-void drvshmem_test_reserve_after_fork(void)
-{
- int base; /* memory usage when test starts */
- pthrd_arg thrdarg;
- odpdrv_shm_t shm;
- odpdrv_shm_t thr_shm;
- shared_test_data_t *glob_data;
- odp_cpumask_t unused;
- char *name;
- int name_len;
- int thr_index;
- int i;
- void *address;
- shared_test_data_small_t *pattern_small;
- shared_test_data_medium_t *pattern_medium;
- shared_test_data_big_t *pattern_big;
-
- base = odpdrv_shm_print_all("Before drvshmem_test_reserve_after_fork");
- shm = odpdrv_shm_reserve(MEM_NAME, sizeof(shared_test_data_t), 0, 0);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(glob_data);
-
- thrdarg.numthrds = odp_cpumask_default_worker(&unused, 0);
- if (thrdarg.numthrds > MAX_WORKERS)
- thrdarg.numthrds = MAX_WORKERS;
-
- odpdrv_barrier_init(&glob_data->test_barrier1, thrdarg.numthrds + 1);
- odpdrv_barrier_init(&glob_data->test_barrier2, thrdarg.numthrds + 1);
- odpdrv_atomic_store_u32(&glob_data->index, 0);
-
- odp_cunit_thread_create(run_test_reserve_after_fork, &thrdarg);
-
- /* wait until all threads have made their shm_reserve: */
- odpdrv_barrier_wait(&glob_data->test_barrier1);
- CU_ASSERT(odpdrv_shm_print_all("After all thread reserve")
- == base + thrdarg.numthrds + 1);
-
- /* perform a lookup of all memories, by handle or name: */
- name_len = strlen(MEM_NAME) + 20;
- name = malloc(name_len);
- for (thr_index = 0; thr_index < thrdarg.numthrds; thr_index++) {
- if (thr_index % 2) {
- snprintf(name, name_len, "%s-%09d",
- MEM_NAME, thr_index);
- thr_shm = odpdrv_shm_lookup_by_name(name);
- CU_ASSERT(thr_shm == glob_data->shm[thr_index]);
- } else {
- odpdrv_shm_lookup_by_handle(glob_data->shm[thr_index]);
- }
- }
-
- /* check that the patterns are correct: */
- for (thr_index = 0; thr_index < thrdarg.numthrds; thr_index++) {
- switch (thr_index % 3) {
- case 0:
- pattern_small =
- odpdrv_shm_addr(glob_data->shm[thr_index]);
- CU_ASSERT_PTR_NOT_NULL(pattern_small);
- for (i = 0; i < SMALL_MEM; i++)
- CU_ASSERT(pattern_small->data[i] == i);
- break;
- case 1:
- pattern_medium =
- odpdrv_shm_addr(glob_data->shm[thr_index]);
- CU_ASSERT_PTR_NOT_NULL(pattern_medium);
- for (i = 0; i < MEDIUM_MEM; i++)
- CU_ASSERT(pattern_medium->data[i] == (i << 2));
- break;
- case 2:
- pattern_big =
- odpdrv_shm_addr(glob_data->shm[thr_index]);
- CU_ASSERT_PTR_NOT_NULL(pattern_big);
- for (i = 0; i < BIG_MEM; i++)
- CU_ASSERT(pattern_big->data[i] == (i >> 2));
- break;
- }
- }
-
- /*
- * print the mapping address of the blocks
- */
- for (thr_index = 0; thr_index < thrdarg.numthrds; thr_index++) {
- address = odpdrv_shm_addr(glob_data->shm[thr_index]);
- printf("In main Block index: %d mapped at %lx\n",
- thr_index, (long int)address);
- }
-
- CU_ASSERT(odpdrv_shm_print_all("After main lookup of thread shmem")
- == base + thrdarg.numthrds + 1);
-
- /* unblock the threads and let them terminate (no free is done): */
- odpdrv_barrier_wait(&glob_data->test_barrier2);
-
- /* at the same time, (race),free of all memories, by handle or name: */
- for (thr_index = 0; thr_index < thrdarg.numthrds; thr_index++) {
- if (thr_index % 2) {
- thr_shm = glob_data->shm[thr_index];
- CU_ASSERT(odpdrv_shm_free_by_handle(thr_shm) == 0);
- } else {
- snprintf(name, name_len, "%s-%09d",
- MEM_NAME, thr_index);
- CU_ASSERT(odpdrv_shm_free_by_name(name) == 0);
- }
- }
- free(name);
-
- /* wait for all thread endings: */
- CU_ASSERT(odp_cunit_thread_exit(&thrdarg) >= 0);
-
- /* just glob_data should remain: */
- CU_ASSERT(odpdrv_shm_print_all("After all threads end") == base + 1);
-
- CU_ASSERT(0 == odpdrv_shm_free_by_handle(shm));
- CU_ASSERT(odpdrv_shm_print_all("Test completion") == base);
-}
-
-/*
- * thread part for the drvshmem_test_singleva_after_fork
- */
-static int run_test_singleva_after_fork(void *arg ODP_UNUSED)
-{
- odpdrv_shm_t shm;
- shared_test_data_t *glob_data;
- int thr;
- int thr_index;
- char *name;
- int name_len;
- int size;
- shared_test_data_small_t *pattern_small;
- shared_test_data_medium_t *pattern_medium;
- shared_test_data_big_t *pattern_big;
- uint32_t i;
- int ret;
-
- thr = odp_thread_id();
- printf("Thread %i starts\n", thr);
-
- shm = odpdrv_shm_lookup_by_name(MEM_NAME);
- glob_data = odpdrv_shm_addr(shm);
-
- /*
- * odp_thread_id are not guaranteed to be consecutive, so we create
- * a consecutive ID
- */
- thr_index = odpdrv_atomic_fetch_inc_u32(&glob_data->index);
-
- /* allocate some memory (of different sizes) and fill with pattern */
- name_len = strlen(MEM_NAME) + 20;
- name = malloc(name_len);
- snprintf(name, name_len, "%s-%09d", MEM_NAME, thr_index);
- switch (thr_index % 3) {
- case 0:
- size = sizeof(shared_test_data_small_t);
- shm = odpdrv_shm_reserve(name, size, 0, ODPDRV_SHM_SINGLE_VA);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data->shm[thr_index] = shm;
- pattern_small = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(pattern_small);
- glob_data->address[thr_index] = (void *)pattern_small;
- for (i = 0; i < SMALL_MEM; i++)
- pattern_small->data[i] = i;
- break;
- case 1:
- size = sizeof(shared_test_data_medium_t);
- shm = odpdrv_shm_reserve(name, size, 0, ODPDRV_SHM_SINGLE_VA);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data->shm[thr_index] = shm;
- pattern_medium = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(pattern_medium);
- glob_data->address[thr_index] = (void *)pattern_medium;
- for (i = 0; i < MEDIUM_MEM; i++)
- pattern_medium->data[i] = (i << 2);
- break;
- case 2:
- size = sizeof(shared_test_data_big_t);
- shm = odpdrv_shm_reserve(name, size, 0, ODPDRV_SHM_SINGLE_VA);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data->shm[thr_index] = shm;
- pattern_big = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(pattern_big);
- glob_data->address[thr_index] = (void *)pattern_big;
- for (i = 0; i < BIG_MEM; i++)
- pattern_big->data[i] = (i >> 2);
- break;
- }
- free(name);
-
- /* print block address */
- printf("In thread: Block index: %d mapped at %lx\n",
- thr_index, (long int)odpdrv_shm_addr(shm));
-
- odpdrv_barrier_wait(&glob_data->test_barrier1);
- odpdrv_barrier_wait(&glob_data->test_barrier2);
-
- /* map each-other block, checking common address: */
- for (i = 0; i < glob_data->nb_threads; i++) {
- shm = odpdrv_shm_lookup_by_address(glob_data->address[i]);
- CU_ASSERT(shm == glob_data->shm[i]);
- CU_ASSERT(odpdrv_shm_addr(shm) == glob_data->address[i]);
- }
-
- /* wait for main control task and free the allocated block */
- odpdrv_barrier_wait(&glob_data->test_barrier3);
- odpdrv_barrier_wait(&glob_data->test_barrier4);
- ret = odpdrv_shm_free_by_address(glob_data->address[thr_index]);
- CU_ASSERT(ret == 0);
-
- fflush(stdout);
- return CU_get_number_of_failures();
-}
-
-/*
- * test sharing memory reserved after odp_thread creation (e.g. fork()):
- * with single VA flag.
- */
-void drvshmem_test_singleva_after_fork(void)
-{
- int base; /* memory usage when test starts */
- pthrd_arg thrdarg;
- odpdrv_shm_t shm;
- odpdrv_shm_t thr_shm;
- shared_test_data_t *glob_data;
- odp_cpumask_t unused;
- char *name;
- int name_len;
- int thr_index;
- int i;
- void *address;
- shared_test_data_small_t *pattern_small;
- shared_test_data_medium_t *pattern_medium;
- shared_test_data_big_t *pattern_big;
-
- base = odpdrv_shm_print_all("Before drvshmem_test_singleva_after_fork");
-
- shm = odpdrv_shm_reserve(MEM_NAME, sizeof(shared_test_data_t),
- 0, ODPDRV_SHM_LOCK);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(glob_data);
-
- thrdarg.numthrds = odp_cpumask_default_worker(&unused, 0);
- if (thrdarg.numthrds > MAX_WORKERS)
- thrdarg.numthrds = MAX_WORKERS;
-
- glob_data->nb_threads = thrdarg.numthrds;
- odpdrv_barrier_init(&glob_data->test_barrier1, thrdarg.numthrds + 1);
- odpdrv_barrier_init(&glob_data->test_barrier2, thrdarg.numthrds + 1);
- odpdrv_barrier_init(&glob_data->test_barrier3, thrdarg.numthrds + 1);
- odpdrv_barrier_init(&glob_data->test_barrier4, thrdarg.numthrds + 1);
- odpdrv_atomic_store_u32(&glob_data->index, 0);
-
- odp_cunit_thread_create(run_test_singleva_after_fork, &thrdarg);
-
- /* wait until all threads have made their shm_reserve: */
- odpdrv_barrier_wait(&glob_data->test_barrier1);
- CU_ASSERT(odpdrv_shm_print_all("After thread reserve")
- == base + thrdarg.numthrds + 1);
-
- /* perform a lookup of all memories, by handle or name: */
- name_len = strlen(MEM_NAME) + 20;
- name = malloc(name_len);
- for (thr_index = 0; thr_index < thrdarg.numthrds; thr_index++) {
- if (thr_index % 2) {
- snprintf(name, name_len, "%s-%09d",
- MEM_NAME, thr_index);
- thr_shm = odpdrv_shm_lookup_by_name(name);
- CU_ASSERT(thr_shm == glob_data->shm[thr_index]);
- } else {
- odpdrv_shm_lookup_by_handle(glob_data->shm[thr_index]);
- }
- }
- free(name);
-
- /* check that the patterns are correct: */
- for (thr_index = 0; thr_index < thrdarg.numthrds; thr_index++) {
- switch (thr_index % 3) {
- case 0:
- pattern_small =
- odpdrv_shm_addr(glob_data->shm[thr_index]);
- CU_ASSERT_PTR_NOT_NULL(pattern_small);
- for (i = 0; i < SMALL_MEM; i++)
- CU_ASSERT(pattern_small->data[i] == i);
- break;
- case 1:
- pattern_medium =
- odpdrv_shm_addr(glob_data->shm[thr_index]);
- CU_ASSERT_PTR_NOT_NULL(pattern_medium);
- for (i = 0; i < MEDIUM_MEM; i++)
- CU_ASSERT(pattern_medium->data[i] == (i << 2));
- break;
- case 2:
- pattern_big =
- odpdrv_shm_addr(glob_data->shm[thr_index]);
- CU_ASSERT_PTR_NOT_NULL(pattern_big);
- for (i = 0; i < BIG_MEM; i++)
- CU_ASSERT(pattern_big->data[i] == (i >> 2));
- break;
- }
- }
-
- /*
- * check that the mapping address is common to all (SINGLE_VA):
- */
- for (thr_index = 0; thr_index < thrdarg.numthrds; thr_index++) {
- address = odpdrv_shm_addr(glob_data->shm[thr_index]);
- CU_ASSERT(glob_data->address[thr_index] == address);
- }
-
- CU_ASSERT(odpdrv_shm_print_all("After local lookup")
- == base + thrdarg.numthrds + 1);
-
- /* unblock the threads and let them map each-other blocks: */
- odpdrv_barrier_wait(&glob_data->test_barrier2);
-
- /* then check mem status */
- odpdrv_barrier_wait(&glob_data->test_barrier3);
- CU_ASSERT(odpdrv_shm_print_all("After mutual lookup")
- == base + thrdarg.numthrds + 1);
-
- /* unblock the threads and let them free all thread blocks: */
- odpdrv_barrier_wait(&glob_data->test_barrier4);
-
- /* wait for all thread endings: */
- CU_ASSERT(odp_cunit_thread_exit(&thrdarg) >= 0);
-
- /* just glob_data should remain: */
- CU_ASSERT(odpdrv_shm_print_all("After threads free") == base + 1);
-
- CU_ASSERT(0 == odpdrv_shm_free_by_name(MEM_NAME));
- CU_ASSERT(odpdrv_shm_print_all("Test completion") == base);
-}
-
-/*
- * thread part for the drvshmem_test_stress
- */
-static int run_test_stress(void *arg ODP_UNUSED)
-{
- odpdrv_shm_t shm;
- uint8_t *address;
- shared_test_data_t *glob_data;
- uint8_t random_bytes[STRESS_RANDOM_SZ];
- uint32_t index;
- uint32_t size;
- uint64_t align;
- uint32_t flags;
- uint8_t data;
- uint32_t iter;
- uint32_t i;
-
- shm = odpdrv_shm_lookup_by_name(MEM_NAME);
- glob_data = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(glob_data);
-
- /* wait for general GO! */
- odpdrv_barrier_wait(&glob_data->test_barrier1);
- /*
-
- * at each iteration: pick up a random index for
- * glob_data->stress[index]: If the entry is free, allocated mem
- * randomly. If it is already allocated, make checks and free it:
- * Note that different tread cann allocate or free a given block
- */
- for (iter = 0; iter < STRESS_ITERATION; iter++) {
- /* get 4 random bytes from which index, size ,align, flags
- * and data will be derived:
- */
- odp_random_data(random_bytes, STRESS_RANDOM_SZ, 0);
- index = random_bytes[0] & (STRESS_SIZE - 1);
-
- odp_spinlock_lock(&glob_data->stress_lock);
-
- switch (glob_data->stress[index].state) {
- case STRESS_FREE:
- /* allocated a new block for this entry */
-
- glob_data->stress[index].state = STRESS_BUSY;
- odp_spinlock_unlock(&glob_data->stress_lock);
-
- size = (random_bytes[1] + 1) << 6; /* up to 16Kb */
- /* we just play with the VA flag. randomly setting
- * the mlock flag may exceed user ulimit -l
- */
- flags = random_bytes[2] & ODPDRV_SHM_SINGLE_VA;
- align = (random_bytes[3] + 1) << 6;/* up to 16Kb */
- data = random_bytes[4];
-
- shm = odpdrv_shm_reserve(NULL, size, align, flags);
- glob_data->stress[index].shm = shm;
- if (shm == ODPDRV_SHM_INVALID) { /* out of mem ? */
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_ALLOC;
- odp_spinlock_unlock(&glob_data->stress_lock);
- continue;
- }
-
- address = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(address);
- glob_data->stress[index].address = address;
- glob_data->stress[index].flags = flags;
- glob_data->stress[index].size = size;
- glob_data->stress[index].align = align;
- glob_data->stress[index].data_val = data;
-
- /* write some data: writing each byte would be a
- * waste of time: just make sure each page is reached */
- for (i = 0; i < size; i += 256)
- address[i] = (data++) & 0xFF;
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_ALLOC;
- odp_spinlock_unlock(&glob_data->stress_lock);
-
- break;
-
- case STRESS_ALLOC:
- /* free the block for this entry */
-
- glob_data->stress[index].state = STRESS_BUSY;
- odp_spinlock_unlock(&glob_data->stress_lock);
- shm = glob_data->stress[index].shm;
-
- if (shm == ODPDRV_SHM_INVALID) { /* out of mem ? */
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_FREE;
- odp_spinlock_unlock(&glob_data->stress_lock);
- continue;
- }
-
- CU_ASSERT(odpdrv_shm_lookup_by_handle(shm) != 0);
-
- address = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(address);
-
- align = glob_data->stress[index].align;
- if (align) {
- align = glob_data->stress[index].align;
- CU_ASSERT(((uintptr_t)address & (align - 1))
- == 0)
- }
-
- flags = glob_data->stress[index].flags;
- if (flags & ODPDRV_SHM_SINGLE_VA)
- CU_ASSERT(glob_data->stress[index].address ==
- address)
-
- /* check that data is reachable and correct: */
- data = glob_data->stress[index].data_val;
- size = glob_data->stress[index].size;
- for (i = 0; i < size; i += 256) {
- CU_ASSERT(address[i] == (data & 0xFF));
- data++;
- }
-
- if (flags & ODPDRV_SHM_SINGLE_VA) {
- CU_ASSERT(!odpdrv_shm_free_by_address(address));
- } else {
- CU_ASSERT(!odpdrv_shm_free_by_handle(shm));
- }
-
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_FREE;
- odp_spinlock_unlock(&glob_data->stress_lock);
-
- break;
-
- case STRESS_BUSY:
- default:
- odp_spinlock_unlock(&glob_data->stress_lock);
- break;
- }
- }
-
- fflush(stdout);
- return CU_get_number_of_failures();
-}
-
-/*
- * stress tests
- */
-void drvshmem_test_stress(void)
-{
- pthrd_arg thrdarg;
- odpdrv_shm_t shm;
- shared_test_data_t *glob_data;
- odp_cpumask_t unused;
- int base; /* number of blocks already allocated at start of test */
- uint32_t i;
-
- base = odpdrv_shm_print_all("Before thread tests");
-
- shm = odpdrv_shm_reserve(MEM_NAME, sizeof(shared_test_data_t),
- 0, ODPDRV_SHM_LOCK);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(glob_data);
-
- thrdarg.numthrds = odp_cpumask_default_worker(&unused, 0);
- if (thrdarg.numthrds > MAX_WORKERS)
- thrdarg.numthrds = MAX_WORKERS;
-
- glob_data->nb_threads = thrdarg.numthrds;
- odpdrv_barrier_init(&glob_data->test_barrier1, thrdarg.numthrds);
- odp_spinlock_init(&glob_data->stress_lock);
-
- /* before starting the threads, mark all entries as free: */
- for (i = 0; i < STRESS_SIZE; i++)
- glob_data->stress[i].state = STRESS_FREE;
-
- /* create threads */
- odp_cunit_thread_create(run_test_stress, &thrdarg);
-
- /* wait for all thread endings: */
- CU_ASSERT(odp_cunit_thread_exit(&thrdarg) >= 0);
-
- odpdrv_shm_print_all("Middle");
-
- /* release left overs: */
- for (i = 0; i < STRESS_SIZE; i++) {
- shm = glob_data->stress[i].shm;
- if ((glob_data->stress[i].state == STRESS_ALLOC) &&
- (glob_data->stress[i].shm != ODPDRV_SHM_INVALID)) {
- CU_ASSERT(odpdrv_shm_lookup_by_handle(shm) !=
- NULL);
- CU_ASSERT(!odpdrv_shm_free_by_handle(shm));
- }
- }
-
- CU_ASSERT(0 == odpdrv_shm_free_by_name(MEM_NAME));
-
- /* check that no memory is left over: */
- CU_ASSERT(odpdrv_shm_print_all("After stress tests") == base);
-}
-
-void drvshmem_test_buddy_basic(void)
-{
- odpdrv_shm_pool_param_t pool_params;
- odpdrv_shm_pool_t pool, found_pool;
- uint8_t *buff;
- uint8_t *addrs[TEST_SZ];
- uint8_t length;
- int i, j;
-
- /* create a pool and check that it can be looked up */
- pool_params.pool_size = POOL_SZ;
- pool_params.min_alloc = 1;
- pool_params.max_alloc = POOL_SZ;
- pool = odpdrv_shm_pool_create(POOL_NAME, &pool_params);
- found_pool = odpdrv_shm_pool_lookup(POOL_NAME);
- CU_ASSERT(found_pool == pool);
-
- /* alloc a 1k buffer, filling its contents: */
- buff = odpdrv_shm_pool_alloc(pool, SZ_1K);
- CU_ASSERT_PTR_NOT_NULL(buff);
- for (i = 0; i < SZ_1K; i++)
- buff[i] = BUFF_PATTERN;
- odpdrv_shm_pool_print("buddy test: 1K reserved", pool);
-
- /* alloc as many buffer a possible on increseasing sz */
- for (i = 0; i < TEST_SZ; i++) {
- length = i * 16;
- addrs[i] = odpdrv_shm_pool_alloc(pool, length);
- /* if alloc was success, fill buffer for later check */
- if (addrs[i]) {
- for (j = 0; j < length; j++)
- addrs[i][j] = (uint8_t)(length & 0xFF);
- }
- }
- odpdrv_shm_pool_print("buddy test: after many mallocs", pool);
-
- /* release every 3rth buffer, checking contents: */
- for (i = 0; i < TEST_SZ; i += 3) {
- /* if buffer was allocated, check the pattern in it */
- if (addrs[i]) {
- length = i * 16;
- for (j = 0; j < length; j++)
- CU_ASSERT(addrs[i][j] ==
- (uint8_t)(length & 0xFF));
- }
- odpdrv_shm_pool_free(pool, addrs[i]);
- }
- odpdrv_shm_pool_print("buddy test: after 1/3 free:", pool);
-
- /* realloc them:*/
- for (i = 0; i < TEST_SZ; i += 3) {
- length = i * 16;
- addrs[i] = odpdrv_shm_pool_alloc(pool, length);
- /* if alloc was success, fill buffer for later check */
- if (addrs[i]) {
- for (j = 0; j < length; j++)
- addrs[i][j] = (uint8_t)(length & 0xFF);
- }
- }
- odpdrv_shm_pool_print("buddy test: after realloc:", pool);
-
- /* free all (except buff), checking contents: */
- for (i = 0; i < TEST_SZ; i++) {
- /* if buffer was allocated, check the pattern in it */
- if (addrs[i]) {
- length = i * 16;
- for (j = 0; j < length; j++)
- CU_ASSERT(addrs[i][j] ==
- (uint8_t)(length & 0xFF))
- }
- odpdrv_shm_pool_free(pool, addrs[i]);
- }
- odpdrv_shm_pool_print("buddy test: after all but 1K free:", pool);
-
- /* check contents of our initial 1K buffer: */
- for (i = 0; i < SZ_1K; i++)
- CU_ASSERT((buff[i] == BUFF_PATTERN))
- odpdrv_shm_pool_free(pool, buff);
-
- odpdrv_shm_pool_print("buddy test: after all free", pool);
-
- /* destroy pool: */
- odpdrv_shm_pool_destroy(pool);
-}
-
-void drvshmem_test_slab_basic(void)
-{
- odpdrv_shm_pool_param_t pool_params;
- odpdrv_shm_pool_t pool, found_pool;
- uint8_t *buff;
- uint8_t *addrs[TEST_SZ];
- uint16_t length;
- int i, j;
-
- /* create a pool and check that it can be looked up */
- pool_params.pool_size = POOL_SZ;
- pool_params.min_alloc = SZ_1K; /* constant size will give slab */
- pool_params.max_alloc = SZ_1K;
- pool = odpdrv_shm_pool_create(POOL_NAME, &pool_params);
- found_pool = odpdrv_shm_pool_lookup(POOL_NAME);
- CU_ASSERT(found_pool == pool);
-
- /* alloc a 1k buffer, filling its contents: */
- buff = odpdrv_shm_pool_alloc(pool, SZ_1K);
- CU_ASSERT_PTR_NOT_NULL(buff);
- for (i = 0; i < SZ_1K; i++)
- buff[i] = BUFF_PATTERN;
- odpdrv_shm_pool_print("buddy test: 1K reserved", pool);
-
- /* alloc as many 1K buffer a possible */
- for (i = 0; i < TEST_SZ; i++) {
- length = SZ_1K;
- addrs[i] = odpdrv_shm_pool_alloc(pool, length);
- /* if alloc was success, fill buffer for later check */
- if (addrs[i]) {
- for (j = 0; j < length; j++)
- addrs[i][j] = (uint8_t)(length & 0xFF);
- }
- }
- odpdrv_shm_pool_print("slab test: after many mallocs", pool);
-
- /* release every 3rth buffer, checking contents: */
- for (i = 0; i < TEST_SZ; i += 3) {
- /* if buffer was allocated, check the pattern in it */
- if (addrs[i]) {
- length = SZ_1K;
- for (j = 0; j < length; j++)
- CU_ASSERT(addrs[i][j] ==
- (uint8_t)(length & 0xFF));
- }
- odpdrv_shm_pool_free(pool, addrs[i]);
- }
- odpdrv_shm_pool_print("slab test: after 1/3 free:", pool);
-
- /* realloc them:*/
- for (i = 0; i < TEST_SZ; i += 3) {
- length = SZ_1K;
- addrs[i] = odpdrv_shm_pool_alloc(pool, length);
- /* if alloc was success, fill buffer for later check */
- if (addrs[i]) {
- for (j = 0; j < length; j++)
- addrs[i][j] = (uint8_t)(length & 0xFF);
- }
- }
- odpdrv_shm_pool_print("slab test: after realloc:", pool);
-
- /* free all (except buff), checking contents: */
- for (i = 0; i < TEST_SZ; i++) {
- /* if buffer was allocated, check the pattern in it */
- if (addrs[i]) {
- length = SZ_1K;
- for (j = 0; j < length; j++)
- CU_ASSERT(addrs[i][j] ==
- (uint8_t)(length & 0xFF))
- }
- odpdrv_shm_pool_free(pool, addrs[i]);
- }
- odpdrv_shm_pool_print("slab test: after all but 1K free:", pool);
-
- /* check contents of our initial 1K buffer: */
- for (i = 0; i < SZ_1K; i++)
- CU_ASSERT((buff[i] == BUFF_PATTERN))
- odpdrv_shm_pool_free(pool, buff);
-
- odpdrv_shm_pool_print("slab test: after all free", pool);
-
- /* destroy pool: */
- odpdrv_shm_pool_destroy(pool);
-}
-
-/*
- * thread part for the drvshmem_test_buddy_stress
- */
-static int run_test_buddy_stress(void *arg ODP_UNUSED)
-{
- odpdrv_shm_t shm;
- odpdrv_shm_pool_t pool;
- uint8_t *address;
- shared_test_data_t *glob_data;
- uint8_t random_bytes[STRESS_RANDOM_SZ];
- uint32_t index;
- uint32_t size;
- uint8_t data;
- uint32_t iter;
- uint32_t i;
-
- shm = odpdrv_shm_lookup_by_name(MEM_NAME);
- glob_data = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(glob_data);
-
- /* get the pool to test */
- pool = odpdrv_shm_pool_lookup(POOL_NAME);
-
- /* wait for general GO! */
- odpdrv_barrier_wait(&glob_data->test_barrier1);
- /*
-
- * at each iteration: pick up a random index for
- * glob_data->stress[index]: If the entry is free, allocated small mem
- * randomly. If it is already allocated, make checks and free it:
- * Note that different tread can allocate or free a given block
- */
- for (iter = 0; iter < STRESS_ITERATION; iter++) {
- /* get 4 random bytes from which index, size ,align, flags
- * and data will be derived:
- */
- odp_random_data(random_bytes, STRESS_RANDOM_SZ, 0);
- index = random_bytes[0] & (STRESS_SIZE - 1);
-
- odp_spinlock_lock(&glob_data->stress_lock);
-
- switch (glob_data->stress[index].state) {
- case STRESS_FREE:
- /* allocated a new block for this entry */
-
- glob_data->stress[index].state = STRESS_BUSY;
- odp_spinlock_unlock(&glob_data->stress_lock);
-
- size = (random_bytes[1] + 1) << 4; /* up to 4Kb */
- data = random_bytes[2];
-
- address = odpdrv_shm_pool_alloc(pool, size);
- glob_data->stress[index].address = address;
- if (address == NULL) { /* out of mem ? */
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_ALLOC;
- odp_spinlock_unlock(&glob_data->stress_lock);
- continue;
- }
-
- glob_data->stress[index].size = size;
- glob_data->stress[index].data_val = data;
-
- /* write some data: */
- for (i = 0; i < size; i++)
- address[i] = (data++) & 0xFF;
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_ALLOC;
- odp_spinlock_unlock(&glob_data->stress_lock);
-
- break;
-
- case STRESS_ALLOC:
- /* free the block for this entry */
-
- glob_data->stress[index].state = STRESS_BUSY;
- odp_spinlock_unlock(&glob_data->stress_lock);
- address = glob_data->stress[index].address;
-
- if (shm == NULL) { /* out of mem ? */
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_FREE;
- odp_spinlock_unlock(&glob_data->stress_lock);
- continue;
- }
-
- /* check that data is reachable and correct: */
- data = glob_data->stress[index].data_val;
- size = glob_data->stress[index].size;
- for (i = 0; i < size; i++) {
- CU_ASSERT(address[i] == (data & 0xFF));
- data++;
- }
-
- odpdrv_shm_pool_free(pool, address);
-
- odp_spinlock_lock(&glob_data->stress_lock);
- glob_data->stress[index].state = STRESS_FREE;
- odp_spinlock_unlock(&glob_data->stress_lock);
-
- break;
-
- case STRESS_BUSY:
- default:
- odp_spinlock_unlock(&glob_data->stress_lock);
- break;
- }
- }
-
- fflush(stdout);
- return CU_get_number_of_failures();
-}
-
-/*
- * stress tests
- */
-void drvshmem_test_buddy_stress(void)
-{
- odpdrv_shm_pool_param_t pool_params;
- odpdrv_shm_pool_t pool;
- pthrd_arg thrdarg;
- odpdrv_shm_t shm;
- shared_test_data_t *glob_data;
- odp_cpumask_t unused;
- uint32_t i;
- uint8_t *address;
-
- /* create a pool and check that it can be looked up */
- pool_params.pool_size = POOL_SZ;
- pool_params.min_alloc = 0;
- pool_params.max_alloc = POOL_SZ;
- pool = odpdrv_shm_pool_create(POOL_NAME, &pool_params);
- odpdrv_shm_pool_print("Stress test start", pool);
-
- shm = odpdrv_shm_reserve(MEM_NAME, sizeof(shared_test_data_t),
- 0, ODPDRV_SHM_LOCK);
- CU_ASSERT(ODPDRV_SHM_INVALID != shm);
- glob_data = odpdrv_shm_addr(shm);
- CU_ASSERT_PTR_NOT_NULL(glob_data);
-
- thrdarg.numthrds = odp_cpumask_default_worker(&unused, 0);
- if (thrdarg.numthrds > MAX_WORKERS)
- thrdarg.numthrds = MAX_WORKERS;
-
- glob_data->nb_threads = thrdarg.numthrds;
- odpdrv_barrier_init(&glob_data->test_barrier1, thrdarg.numthrds);
- odp_spinlock_init(&glob_data->stress_lock);
-
- /* before starting the threads, mark all entries as free: */
- for (i = 0; i < STRESS_SIZE; i++)
- glob_data->stress[i].state = STRESS_FREE;
-
- /* create threads */
- odp_cunit_thread_create(run_test_buddy_stress, &thrdarg);
-
- /* wait for all thread endings: */
- CU_ASSERT(odp_cunit_thread_exit(&thrdarg) >= 0);
-
- odpdrv_shm_pool_print("Stress test all thread finished", pool);
-
- /* release left overs: */
- for (i = 0; i < STRESS_SIZE; i++) {
- address = glob_data->stress[i].address;
- if (glob_data->stress[i].state == STRESS_ALLOC)
- odpdrv_shm_pool_free(pool, address);
- }
-
- CU_ASSERT(0 == odpdrv_shm_free_by_name(MEM_NAME));
-
- /* check that no memory is left over: */
- odpdrv_shm_pool_print("Stress test all released", pool);
-
- /* destroy pool: */
- odpdrv_shm_pool_destroy(pool);
-}
-
-odp_testinfo_t drvshmem_suite[] = {
- ODP_TEST_INFO(drvshmem_test_basic),
- ODP_TEST_INFO(drvshmem_test_reserve_after_fork),
- ODP_TEST_INFO(drvshmem_test_singleva_after_fork),
- ODP_TEST_INFO(drvshmem_test_stress),
- ODP_TEST_INFO(drvshmem_test_buddy_basic),
- ODP_TEST_INFO(drvshmem_test_slab_basic),
- ODP_TEST_INFO(drvshmem_test_buddy_stress),
- ODP_TEST_INFO_NULL,
-};
-
-odp_suiteinfo_t drvshmem_suites[] = {
- {"Shared Memory", NULL, NULL, drvshmem_suite},
- ODP_SUITE_INFO_NULL,
-};
-
-int drvshmem_main(int argc, char *argv[])
-{
- int ret;
-
- /* parse common options: */
- if (odp_cunit_parse_options(argc, argv))
- return -1;
-
- ret = odp_cunit_register(drvshmem_suites);
-
- if (ret == 0)
- ret = odp_cunit_run();
-
- return ret;
-}
deleted file mode 100644
@@ -1,30 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#ifndef _ODP_TEST_DRVSHMEM_H_
-#define _ODP_TEST_DRVSHMEM_H_
-
-#include <odp_cunit_common.h>
-
-/* test functions: */
-void drvshmem_test_basic(void);
-void drvshmem_test_reserve_after_fork(void);
-void drvshmem_test_singleva_after_fork(void);
-void drvshmem_test_stress(void);
-void drvshmem_test_buddy_basic(void);
-void drvshmem_test_slab_basic(void);
-void drvshmem_test_buddy_stress(void);
-
-/* test arrays: */
-extern odp_testinfo_t drvshmem_suite[];
-
-/* test registry: */
-extern odp_suiteinfo_t drvshmem_suites[];
-
-/* main test program: */
-int drvshmem_main(int argc, char *argv[]);
-
-#endif
deleted file mode 100644
@@ -1,12 +0,0 @@
-/* Copyright (c) 2016, Linaro Limited
- * All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#include "drvshmem.h"
-
-int main(int argc, char *argv[])
-{
- return drvshmem_main(argc, argv);
-}