From 29f7d31782dc7b03da119aba3fa09085500e1b0c Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Mon, 2 Sep 2013 15:08:05 +0200 Subject: score: Use unsigned long for atomic integers Use unsigned long instead of uint_fast32_t since C11 provides only a ATOMIC_LONG_LOCK_FREE macro constant. This makes it also possible to use properly typed integer literals like 123UL. It is now clear which compatible type should be used for the atomic integer. --- cpukit/score/include/rtems/score/atomic.h | 74 ++++++++++----------- cpukit/score/include/rtems/score/cpustdatomic.h | 58 ++++++++--------- testsuites/smptests/smpatomic01/tasks.c | 4 +- testsuites/smptests/smpatomic02/tasks.c | 4 +- testsuites/smptests/smpatomic03/tasks.c | 6 +- testsuites/smptests/smpatomic04/tasks.c | 6 +- testsuites/smptests/smpatomic05/tasks.c | 6 +- testsuites/smptests/smpatomic06/tasks.c | 6 +- testsuites/smptests/smpatomic07/tasks.c | 6 +- testsuites/smptests/smpatomic08/init.c | 86 ++++++++++++------------- 10 files changed, 128 insertions(+), 128 deletions(-) diff --git a/cpukit/score/include/rtems/score/atomic.h b/cpukit/score/include/rtems/score/atomic.h index e085dea4a0..459b55a455 100644 --- a/cpukit/score/include/rtems/score/atomic.h +++ b/cpukit/score/include/rtems/score/atomic.h @@ -34,7 +34,7 @@ extern "C" { /** * @brief atomic data initializer for static initialization. */ -#define ATOMIC_INITIALIZER_UINT(value) CPU_ATOMIC_INITIALIZER_UINT(value) +#define ATOMIC_INITIALIZER_ULONG(value) CPU_ATOMIC_INITIALIZER_ULONG(value) #define ATOMIC_INITIALIZER_PTR(value) CPU_ATOMIC_INITIALIZER_PTR(value) /** @@ -48,12 +48,12 @@ extern "C" { * @param object an atomic type pointer of object. * @param value a value to be stored into object. */ -static inline void _Atomic_Init_uint( - volatile Atomic_Uint *object, - uint_fast32_t value +static inline void _Atomic_Init_ulong( + volatile Atomic_Ulong *object, + unsigned long value ) { - _CPU_atomic_Init_uint(object, value); + _CPU_atomic_Init_ulong(object, value); } static inline void _Atomic_Init_ptr( @@ -72,12 +72,12 @@ static inline void _Atomic_Init_ptr( * * The order shall not be ATOMIC_ORDER_RELEASE. */ -static inline uint_fast32_t _Atomic_Load_uint( - volatile Atomic_Uint *object, +static inline unsigned long _Atomic_Load_ulong( + volatile Atomic_Ulong *object, Atomic_Order order ) { - return _CPU_atomic_Load_uint( object, order ); + return _CPU_atomic_Load_ulong( object, order ); } static inline uintptr_t _Atomic_Load_ptr( @@ -97,13 +97,13 @@ static inline uintptr_t _Atomic_Load_ptr( * * The order shall not be ATOMIC_ORDER_ACQUIRE. */ -static inline void _Atomic_Store_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline void _Atomic_Store_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { - _CPU_atomic_Store_uint( object, value, order ); + _CPU_atomic_Store_ulong( object, value, order ); } static inline void _Atomic_Store_ptr( @@ -124,13 +124,13 @@ static inline void _Atomic_Store_ptr( * * @retval a result value before add ops. */ -static inline uint_fast32_t _Atomic_Fetch_add_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _Atomic_Fetch_add_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { - return _CPU_atomic_Fetch_add_uint( object, value, order ); + return _CPU_atomic_Fetch_add_ulong( object, value, order ); } static inline uintptr_t _Atomic_Fetch_add_ptr( @@ -151,13 +151,13 @@ static inline uintptr_t _Atomic_Fetch_add_ptr( * * @retval a result value before sub ops. */ -static inline uint_fast32_t _Atomic_Fetch_sub_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _Atomic_Fetch_sub_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { - return _CPU_atomic_Fetch_sub_uint( object, value, order ); + return _CPU_atomic_Fetch_sub_ulong( object, value, order ); } static inline uintptr_t _Atomic_Fetch_sub_ptr( @@ -178,13 +178,13 @@ static inline uintptr_t _Atomic_Fetch_sub_ptr( * * @retval a result value before or ops. */ -static inline uint_fast32_t _Atomic_Fetch_or_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _Atomic_Fetch_or_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { - return _CPU_atomic_Fetch_or_uint( object, value, order ); + return _CPU_atomic_Fetch_or_ulong( object, value, order ); } static inline uintptr_t _Atomic_Fetch_or_ptr( @@ -205,13 +205,13 @@ static inline uintptr_t _Atomic_Fetch_or_ptr( * * @retval a result value before and ops. */ -static inline uint_fast32_t _Atomic_Fetch_and_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _Atomic_Fetch_and_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { - return _CPU_atomic_Fetch_and_uint( object, value, order ); + return _CPU_atomic_Fetch_and_ulong( object, value, order ); } static inline uintptr_t _Atomic_Fetch_and_ptr( @@ -232,13 +232,13 @@ static inline uintptr_t _Atomic_Fetch_and_ptr( * * @retval a result value before exchange ops. */ -static inline uint_fast32_t _Atomic_Exchange_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _Atomic_Exchange_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { - return _CPU_atomic_Exchange_uint( object, value, order ); + return _CPU_atomic_Exchange_ulong( object, value, order ); } static inline uintptr_t _Atomic_Exchange_ptr( @@ -264,15 +264,15 @@ static inline uintptr_t _Atomic_Exchange_ptr( * @retval true if the compare exchange successully. * @retval false if the compare exchange failed. */ -static inline bool _Atomic_Compare_exchange_uint( - volatile Atomic_Uint *object, - uint_fast32_t *old_value, - uint_fast32_t new_value, +static inline bool _Atomic_Compare_exchange_ulong( + volatile Atomic_Ulong *object, + unsigned long *old_value, + unsigned long new_value, Atomic_Order order_succ, Atomic_Order order_fail ) { - return _CPU_atomic_Compare_exchange_uint( object, old_value, new_value, + return _CPU_atomic_Compare_exchange_ulong( object, old_value, new_value, order_succ, order_fail ); } diff --git a/cpukit/score/include/rtems/score/cpustdatomic.h b/cpukit/score/include/rtems/score/cpustdatomic.h index 6ec5828d1d..546745ea86 100644 --- a/cpukit/score/include/rtems/score/cpustdatomic.h +++ b/cpukit/score/include/rtems/score/cpustdatomic.h @@ -35,7 +35,7 @@ extern "C" { /** * @brief atomic operation unsigned integer type */ -typedef atomic_uint_fast32_t Atomic_Uint; +typedef atomic_ulong Atomic_Ulong; /** * @brief atomic operation unsigned integer the size of a pointer type @@ -71,7 +71,7 @@ typedef enum { /** * @brief atomic data initializer for static initialization. */ -#define CPU_ATOMIC_INITIALIZER_UINT(value) ATOMIC_VAR_INIT(value) +#define CPU_ATOMIC_INITIALIZER_ULONG(value) ATOMIC_VAR_INIT(value) #define CPU_ATOMIC_INITIALIZER_PTR(value) ATOMIC_VAR_INIT(value) #define CPU_ATOMIC_INITIALIZER_FLAG ATOMIC_FLAG_INIT @@ -82,9 +82,9 @@ typedef enum { * @param object an atomic type pointer of object. * @param value a value to be stored into object. */ -static inline void _CPU_atomic_Init_uint( - volatile Atomic_Uint *object, - uint_fast32_t value +static inline void _CPU_atomic_Init_ulong( + volatile Atomic_Ulong *object, + unsigned long value ) { atomic_init(object, value); @@ -106,8 +106,8 @@ static inline void _CPU_atomic_Init_ptr( * * The order shall not be ATOMIC_ORDER_RELEASE. */ -static inline uint_fast32_t _CPU_atomic_Load_uint( - volatile Atomic_Uint *object, +static inline unsigned long _CPU_atomic_Load_ulong( + volatile Atomic_Ulong *object, Atomic_Order order ) { @@ -131,9 +131,9 @@ static inline uintptr_t _CPU_atomic_Load_ptr( * * The order shall not be ATOMIC_ORDER_ACQUIRE. */ -static inline void _CPU_atomic_Store_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline void _CPU_atomic_Store_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { @@ -158,9 +158,9 @@ static inline void _CPU_atomic_Store_ptr( * * @retval a result value before add ops. */ -static inline uint_fast32_t _CPU_atomic_Fetch_add_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _CPU_atomic_Fetch_add_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { @@ -185,9 +185,9 @@ static inline uintptr_t _CPU_atomic_Fetch_add_ptr( * * @retval a result value before sub ops. */ -static inline uint_fast32_t _CPU_atomic_Fetch_sub_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _CPU_atomic_Fetch_sub_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { @@ -212,9 +212,9 @@ static inline uintptr_t _CPU_atomic_Fetch_sub_ptr( * * @retval a result value before or ops. */ -static inline uint_fast32_t _CPU_atomic_Fetch_or_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _CPU_atomic_Fetch_or_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { @@ -239,9 +239,9 @@ static inline uintptr_t _CPU_atomic_Fetch_or_ptr( * * @retval a result value before and ops. */ -static inline uint_fast32_t _CPU_atomic_Fetch_and_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _CPU_atomic_Fetch_and_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { @@ -266,9 +266,9 @@ static inline uintptr_t _CPU_atomic_Fetch_and_ptr( * * @retval a result value before exchange ops. */ -static inline uint_fast32_t _CPU_atomic_Exchange_uint( - volatile Atomic_Uint *object, - uint_fast32_t value, +static inline unsigned long _CPU_atomic_Exchange_ulong( + volatile Atomic_Ulong *object, + unsigned long value, Atomic_Order order ) { @@ -298,10 +298,10 @@ static inline uintptr_t _CPU_atomic_Exchange_ptr( * @retval true if the compare exchange successully. * @retval false if the compare exchange failed. */ -static inline bool _CPU_atomic_Compare_exchange_uint( - volatile Atomic_Uint *object, - uint_fast32_t *old_value, - uint_fast32_t new_value, +static inline bool _CPU_atomic_Compare_exchange_ulong( + volatile Atomic_Ulong *object, + unsigned long *old_value, + unsigned long new_value, Atomic_Order order_succ, Atomic_Order order_fail ) diff --git a/testsuites/smptests/smpatomic01/tasks.c b/testsuites/smptests/smpatomic01/tasks.c index 65ad81b0b9..4dd2ff68d3 100644 --- a/testsuites/smptests/smpatomic01/tasks.c +++ b/testsuites/smptests/smpatomic01/tasks.c @@ -52,12 +52,12 @@ rtems_task Test_task( /* Print that the task is up and running. */ /* test relaxed barrier */ - ATOMIC_LOAD_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELAXED); + ATOMIC_LOAD_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELAXED); ATOMIC_LOAD_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELAXED); /* test acquire barrier */ - ATOMIC_LOAD_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_ACQUIRE); + ATOMIC_LOAD_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_ACQUIRE); ATOMIC_LOAD_NO_BARRIER(ptr, Pointer, unsigned long, cpu_num, ATOMIC_ORDER_ACQUIRE); diff --git a/testsuites/smptests/smpatomic02/tasks.c b/testsuites/smptests/smpatomic02/tasks.c index 22de08cd62..c5c9ba5f5c 100644 --- a/testsuites/smptests/smpatomic02/tasks.c +++ b/testsuites/smptests/smpatomic02/tasks.c @@ -52,12 +52,12 @@ rtems_task Test_task( /* Print that the task is up and running. */ /* test relaxed barrier */ - ATOMIC_STORE_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELAXED); + ATOMIC_STORE_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELAXED); ATOMIC_STORE_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELAXED); /* test release barrier */ - ATOMIC_STORE_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELEASE); + ATOMIC_STORE_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELEASE); ATOMIC_STORE_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELEASE); diff --git a/testsuites/smptests/smpatomic03/tasks.c b/testsuites/smptests/smpatomic03/tasks.c index 2c45a00e24..50105497d2 100644 --- a/testsuites/smptests/smpatomic03/tasks.c +++ b/testsuites/smptests/smpatomic03/tasks.c @@ -55,17 +55,17 @@ rtems_task Test_task( /* Print that the task is up and running. */ /* test relaxed barrier */ - ATOMIC_FETCH_ADD_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELAXED); + ATOMIC_FETCH_ADD_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELAXED); ATOMIC_FETCH_ADD_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELAXED); /* test acquire barrier */ - ATOMIC_FETCH_ADD_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_ACQUIRE); + ATOMIC_FETCH_ADD_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_ACQUIRE); ATOMIC_FETCH_ADD_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_ACQUIRE); /* test release barrier */ - ATOMIC_FETCH_ADD_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELEASE); + ATOMIC_FETCH_ADD_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELEASE); ATOMIC_FETCH_ADD_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELEASE); diff --git a/testsuites/smptests/smpatomic04/tasks.c b/testsuites/smptests/smpatomic04/tasks.c index 3630eb28cb..18632cd35f 100644 --- a/testsuites/smptests/smpatomic04/tasks.c +++ b/testsuites/smptests/smpatomic04/tasks.c @@ -55,17 +55,17 @@ rtems_task Test_task( /* Print that the task is up and running. */ /* test relaxed barrier */ - ATOMIC_FETCH_SUB_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELAXED); + ATOMIC_FETCH_SUB_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELAXED); ATOMIC_FETCH_SUB_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELAXED); /* test acquire barrier */ - ATOMIC_FETCH_SUB_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_ACQUIRE); + ATOMIC_FETCH_SUB_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_ACQUIRE); ATOMIC_FETCH_SUB_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_ACQUIRE); /* test release barrier */ - ATOMIC_FETCH_SUB_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELEASE); + ATOMIC_FETCH_SUB_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELEASE); ATOMIC_FETCH_SUB_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELEASE); diff --git a/testsuites/smptests/smpatomic05/tasks.c b/testsuites/smptests/smpatomic05/tasks.c index 5e7da77867..cf41cc1d64 100644 --- a/testsuites/smptests/smpatomic05/tasks.c +++ b/testsuites/smptests/smpatomic05/tasks.c @@ -55,17 +55,17 @@ rtems_task Test_task( /* Print that the task is up and running. */ /* test relaxed barrier */ - ATOMIC_FETCH_AND_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELAXED); + ATOMIC_FETCH_AND_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELAXED); ATOMIC_FETCH_AND_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELAXED); /* test acquire barrier */ - ATOMIC_FETCH_AND_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_ACQUIRE); + ATOMIC_FETCH_AND_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_ACQUIRE); ATOMIC_FETCH_AND_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_ACQUIRE); /* test release barrier */ - ATOMIC_FETCH_AND_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELEASE); + ATOMIC_FETCH_AND_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELEASE); ATOMIC_FETCH_AND_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELEASE); diff --git a/testsuites/smptests/smpatomic06/tasks.c b/testsuites/smptests/smpatomic06/tasks.c index 772d745922..a0409c7a6e 100644 --- a/testsuites/smptests/smpatomic06/tasks.c +++ b/testsuites/smptests/smpatomic06/tasks.c @@ -55,17 +55,17 @@ rtems_task Test_task( /* Print that the task is up and running. */ /* test relaxed barrier */ - ATOMIC_FETCH_OR_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELAXED); + ATOMIC_FETCH_OR_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELAXED); ATOMIC_FETCH_OR_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELAXED); /* test acquire barrier */ - ATOMIC_FETCH_OR_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_ACQUIRE); + ATOMIC_FETCH_OR_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_ACQUIRE); ATOMIC_FETCH_OR_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_ACQUIRE); /* test release barrier */ - ATOMIC_FETCH_OR_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELEASE); + ATOMIC_FETCH_OR_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELEASE); ATOMIC_FETCH_OR_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELEASE); diff --git a/testsuites/smptests/smpatomic07/tasks.c b/testsuites/smptests/smpatomic07/tasks.c index ab1b51cec9..345439b62d 100644 --- a/testsuites/smptests/smpatomic07/tasks.c +++ b/testsuites/smptests/smpatomic07/tasks.c @@ -71,17 +71,17 @@ rtems_task Test_task( /* Print that the task is up and running. */ /* test relaxed barrier */ - ATOMIC_CAS_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELAXED); + ATOMIC_CAS_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELAXED); ATOMIC_CAS_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELAXED); /* test acquire barrier */ - ATOMIC_CAS_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_ACQUIRE); + ATOMIC_CAS_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_ACQUIRE); ATOMIC_CAS_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_ACQUIRE); /* test release barrier */ - ATOMIC_CAS_NO_BARRIER(uint, Uint, uint_fast32_t, cpu_num, ATOMIC_ORDER_RELEASE); + ATOMIC_CAS_NO_BARRIER(ulong, Ulong, unsigned long, cpu_num, ATOMIC_ORDER_RELEASE); ATOMIC_CAS_NO_BARRIER(ptr, Pointer, uintptr_t, cpu_num, ATOMIC_ORDER_RELEASE); diff --git a/testsuites/smptests/smpatomic08/init.c b/testsuites/smptests/smpatomic08/init.c index 031f7c90b7..055a8071df 100644 --- a/testsuites/smptests/smpatomic08/init.c +++ b/testsuites/smptests/smpatomic08/init.c @@ -24,42 +24,42 @@ /* FIXME: Add barrier to Score */ typedef struct { - Atomic_Uint value; - Atomic_Uint sense; + Atomic_Ulong value; + Atomic_Ulong sense; } SMP_barrier_Control; typedef struct { - uint_fast32_t sense; + unsigned long sense; } SMP_barrier_State; #define SMP_BARRIER_CONTROL_INITIALIZER \ - { ATOMIC_INITIALIZER_UINT( 0 ), ATOMIC_INITIALIZER_UINT( 0 ) } + { ATOMIC_INITIALIZER_ULONG( 0 ), ATOMIC_INITIALIZER_ULONG( 0 ) } #define SMP_BARRIER_STATE_INITIALIZER { 0 } static void _SMP_barrier_Wait( SMP_barrier_Control *control, SMP_barrier_State *state, - uint_fast32_t count + unsigned long count ) { - uint_fast32_t sense = ~state->sense; - uint_fast32_t previous_value; + unsigned long sense = ~state->sense; + unsigned long previous_value; state->sense = sense; - previous_value = _Atomic_Fetch_add_uint( + previous_value = _Atomic_Fetch_add_ulong( &control->value, 1, ATOMIC_ORDER_RELAXED ); if ( previous_value + 1 == count ) { - _Atomic_Store_uint( &control->value, 0, ATOMIC_ORDER_RELAXED ); - _Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE ); + _Atomic_Store_ulong( &control->value, 0, ATOMIC_ORDER_RELAXED ); + _Atomic_Store_ulong( &control->sense, sense, ATOMIC_ORDER_RELEASE ); } else { while ( - _Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense + _Atomic_Load_ulong( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense ) { /* Wait */ } @@ -73,13 +73,13 @@ static void _SMP_barrier_Wait( #define CPU_COUNT 32 typedef struct { - Atomic_Uint stop; + Atomic_Ulong stop; SMP_barrier_Control barrier; size_t worker_count; rtems_id stop_worker_timer_id; - Atomic_Uint atomic_value; - uint_fast32_t per_worker_value[CPU_COUNT]; - uint32_t normal_value; + Atomic_Ulong atomic_value; + unsigned long per_worker_value[CPU_COUNT]; + unsigned long normal_value; Atomic_Flag global_flag; } test_context; @@ -90,13 +90,13 @@ typedef struct { } test_case; static test_context test_instance = { - .stop = ATOMIC_INITIALIZER_UINT(0), + .stop = ATOMIC_INITIALIZER_ULONG(0), .barrier = SMP_BARRIER_CONTROL_INITIALIZER }; static bool stop(test_context *ctx) { - return _Atomic_Load_uint(&ctx->stop, ATOMIC_ORDER_RELAXED) != 0; + return _Atomic_Load_ulong(&ctx->stop, ATOMIC_ORDER_RELAXED) != 0; } static bool is_master_worker(size_t worker_index) @@ -110,32 +110,32 @@ static void test_fini( bool atomic ) { - uint_fast32_t expected_value = 0; - uint_fast32_t actual_value; + unsigned long expected_value = 0; + unsigned long actual_value; size_t worker_index; printf("=== atomic %s test case ==\n", test); for (worker_index = 0; worker_index < ctx->worker_count; ++worker_index) { - uint_fast32_t worker_value = ctx->per_worker_value[worker_index]; + unsigned long worker_value = ctx->per_worker_value[worker_index]; expected_value += worker_value; printf( - "worker %zu value: %" PRIuFAST32 "\n", + "worker %zu value: %lu\n", worker_index, worker_value ); } if (atomic) { - actual_value = _Atomic_Load_uint(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + actual_value = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); } else { actual_value = ctx->normal_value; } printf( - "atomic value: expected = %" PRIuFAST32 ", actual = %" PRIuFAST32 "\n", + "atomic value: expected = %lu, actual = %lu\n", expected_value, actual_value ); @@ -145,16 +145,16 @@ static void test_fini( static void test_atomic_add_init(test_context *ctx) { - _Atomic_Init_uint(&ctx->atomic_value, 0); + _Atomic_Init_ulong(&ctx->atomic_value, 0); } static void test_atomic_add_body(test_context *ctx, size_t worker_index) { - uint_fast32_t counter = 0; + unsigned long counter = 0; while (!stop(ctx)) { ++counter; - _Atomic_Fetch_add_uint(&ctx->atomic_value, 1, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_add_ulong(&ctx->atomic_value, 1, ATOMIC_ORDER_RELAXED); } ctx->per_worker_value[worker_index] = counter; @@ -173,7 +173,7 @@ static void test_atomic_flag_init(test_context *ctx) static void test_atomic_flag_body(test_context *ctx, size_t worker_index) { - uint_fast32_t counter = 0; + unsigned long counter = 0; while (!stop(ctx)) { while (_Atomic_Flag_test_and_set(&ctx->global_flag, ATOMIC_ORDER_ACQUIRE)) { @@ -196,16 +196,16 @@ static void test_atomic_flag_fini(test_context *ctx) static void test_atomic_sub_init(test_context *ctx) { - _Atomic_Init_uint(&ctx->atomic_value, 0); + _Atomic_Init_ulong(&ctx->atomic_value, 0); } static void test_atomic_sub_body(test_context *ctx, size_t worker_index) { - uint_fast32_t counter = 0; + unsigned long counter = 0; while (!stop(ctx)) { --counter; - _Atomic_Fetch_sub_uint(&ctx->atomic_value, 1, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_sub_ulong(&ctx->atomic_value, 1, ATOMIC_ORDER_RELAXED); } ctx->per_worker_value[worker_index] = counter; @@ -218,21 +218,21 @@ static void test_atomic_sub_fini(test_context *ctx) static void test_atomic_compare_exchange_init(test_context *ctx) { - _Atomic_Init_uint(&ctx->atomic_value, 0); + _Atomic_Init_ulong(&ctx->atomic_value, 0); ctx->normal_value = 0; } static void test_atomic_compare_exchange_body(test_context *ctx, size_t worker_index) { - uint_fast32_t counter = 0; + unsigned long counter = 0; while (!stop(ctx)) { bool success; do { - uint_fast32_t zero = 0; + unsigned long zero = 0; - success = _Atomic_Compare_exchange_uint( + success = _Atomic_Compare_exchange_ulong( &ctx->atomic_value, &zero, 1, @@ -244,7 +244,7 @@ static void test_atomic_compare_exchange_body(test_context *ctx, size_t worker_i ++counter; ++ctx->normal_value; - _Atomic_Store_uint(&ctx->atomic_value, 0, ATOMIC_ORDER_RELEASE); + _Atomic_Store_ulong(&ctx->atomic_value, 0, ATOMIC_ORDER_RELEASE); } ctx->per_worker_value[worker_index] = counter; @@ -257,26 +257,26 @@ static void test_atomic_compare_exchange_fini(test_context *ctx) static void test_atomic_or_and_init(test_context *ctx) { - _Atomic_Init_uint(&ctx->atomic_value, 0); + _Atomic_Init_ulong(&ctx->atomic_value, 0); } static void test_atomic_or_and_body(test_context *ctx, size_t worker_index) { - uint_fast32_t the_bit = 1UL << worker_index; - uint_fast32_t current_bit = 0; + unsigned long the_bit = 1UL << worker_index; + unsigned long current_bit = 0; while (!stop(ctx)) { - uint_fast32_t previous; + unsigned long previous; if (current_bit != 0) { - previous = _Atomic_Fetch_and_uint( + previous = _Atomic_Fetch_and_ulong( &ctx->atomic_value, ~the_bit, ATOMIC_ORDER_RELAXED ); current_bit = 0; } else { - previous = _Atomic_Fetch_or_uint( + previous = _Atomic_Fetch_or_ulong( &ctx->atomic_value, the_bit, ATOMIC_ORDER_RELAXED @@ -325,14 +325,14 @@ static void stop_worker_timer(rtems_id timer_id, void *arg) { test_context *ctx = arg; - _Atomic_Store_uint(&ctx->stop, 1, ATOMIC_ORDER_RELAXED); + _Atomic_Store_ulong(&ctx->stop, 1, ATOMIC_ORDER_RELAXED); } static void start_worker_stop_timer(test_context *ctx) { rtems_status_code sc; - _Atomic_Store_uint(&ctx->stop, 0, ATOMIC_ORDER_RELEASE); + _Atomic_Store_ulong(&ctx->stop, 0, ATOMIC_ORDER_RELEASE); sc = rtems_timer_fire_after( ctx->stop_worker_timer_id, -- cgit v1.2.3