From 4e3d9a4d6c76fba8e31138d503f736405dafc213 Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Wed, 18 Feb 2015 17:46:37 +0100 Subject: score: Make available Make available for all RTEMS configurations. Use inline functions instead of macros. Use ISR disable/enable on uni-processor configurations to ensure atomicity. Update #2273. --- testsuites/sptests/spatomic01/Makefile.am | 19 ++ testsuites/sptests/spatomic01/init.c | 254 +++++++++++++++++++++++++++ testsuites/sptests/spatomic01/spatomic01.doc | 37 ++++ testsuites/sptests/spatomic01/spatomic01.scn | 9 + 4 files changed, 319 insertions(+) create mode 100644 testsuites/sptests/spatomic01/Makefile.am create mode 100644 testsuites/sptests/spatomic01/init.c create mode 100644 testsuites/sptests/spatomic01/spatomic01.doc create mode 100644 testsuites/sptests/spatomic01/spatomic01.scn (limited to 'testsuites/sptests/spatomic01') diff --git a/testsuites/sptests/spatomic01/Makefile.am b/testsuites/sptests/spatomic01/Makefile.am new file mode 100644 index 0000000000..abb5209804 --- /dev/null +++ b/testsuites/sptests/spatomic01/Makefile.am @@ -0,0 +1,19 @@ +rtems_tests_PROGRAMS = spatomic01 +spatomic01_SOURCES = init.c + +dist_rtems_tests_DATA = spatomic01.scn spatomic01.doc + +include $(RTEMS_ROOT)/make/custom/@RTEMS_BSP@.cfg +include $(top_srcdir)/../automake/compile.am +include $(top_srcdir)/../automake/leaf.am + +AM_CPPFLAGS += -I$(top_srcdir)/../support/include + +LINK_OBJS = $(spatomic01_OBJECTS) +LINK_LIBS = $(spatomic01_LDLIBS) + +spatomic01$(EXEEXT): $(spatomic01_OBJECTS) $(spatomic01_DEPENDENCIES) + @rm -f spatomic01$(EXEEXT) + $(make-exe) + +include $(top_srcdir)/../automake/local.am diff --git a/testsuites/sptests/spatomic01/init.c b/testsuites/sptests/spatomic01/init.c new file mode 100644 index 0000000000..f98c5504ff --- /dev/null +++ b/testsuites/sptests/spatomic01/init.c @@ -0,0 +1,254 @@ +/* + * Copyright (c) 2013-2014 embedded brains GmbH. All rights reserved. + * + * embedded brains GmbH + * Dornierstr. 4 + * 82178 Puchheim + * Germany + * + * + * Copyright (c) 2013 Deng Hengyi. + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rtems.org/license/LICENSE. + */ + +#ifdef HAVE_CONFIG_H + #include "config.h" +#endif + +#include +#include +#include + +#include "tmacros.h" + +const char rtems_test_name[] = "SPATOMIC 1"; + +typedef struct { + Atomic_Uint atomic_int_value; + Atomic_Ulong atomic_value; +} test_context; + +static test_context test_instance; + +static void test_static_and_dynamic_initialization(void) +{ + static Atomic_Uint static_uint = + ATOMIC_INITIALIZER_UINT(0xc01dc0feU); + static Atomic_Ulong static_ulong = + ATOMIC_INITIALIZER_ULONG(0xdeadbeefUL); + static Atomic_Pointer static_ptr = + ATOMIC_INITIALIZER_PTR(&static_ptr); + static Atomic_Flag static_flag = ATOMIC_INITIALIZER_FLAG; + + Atomic_Uint stack_uint; + Atomic_Ulong stack_ulong; + Atomic_Pointer stack_ptr; + Atomic_Flag stack_flag; + + puts("=== static and dynamic initialization test case ==="); + + _Atomic_Init_uint(&stack_uint, 0xc01dc0feU); + _Atomic_Init_ulong(&stack_ulong, 0xdeadbeefUL); + _Atomic_Init_ptr(&stack_ptr, &static_ptr); + _Atomic_Flag_clear(&stack_flag, ATOMIC_ORDER_RELAXED); + + rtems_test_assert( + memcmp(&stack_uint, &static_uint, sizeof(stack_uint)) == 0 + ); + rtems_test_assert( + memcmp(&stack_ulong, &static_ulong, sizeof(stack_ulong)) == 0 + ); + rtems_test_assert( + memcmp(&stack_ptr, &static_ptr, sizeof(stack_ptr)) == 0 + ); + rtems_test_assert( + memcmp(&stack_flag, &static_flag, sizeof(stack_flag)) == 0 + ); + + rtems_test_assert( + _Atomic_Load_uint(&stack_uint, ATOMIC_ORDER_RELAXED) == 0xc01dc0feU + ); + rtems_test_assert( + _Atomic_Load_ulong(&stack_ulong, ATOMIC_ORDER_RELAXED) == 0xdeadbeefUL + ); + rtems_test_assert( + _Atomic_Load_ptr(&stack_ptr, ATOMIC_ORDER_RELAXED) == &static_ptr + ); + rtems_test_assert( + !_Atomic_Flag_test_and_set(&stack_flag, ATOMIC_ORDER_RELAXED) + ); +} + +typedef void (*simple_test_body)(test_context *ctx); + +static void test_simple_atomic_add_body(test_context *ctx) +{ + unsigned int ia = 8, ib = 4; + unsigned int ic; + unsigned long a = 2, b = 1; + unsigned long c; + + puts("=== atomic simple add test case ==="); + + _Atomic_Store_uint(&ctx->atomic_int_value, ia, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_add_uint(&ctx->atomic_int_value, ib, ATOMIC_ORDER_RELAXED); + ic = _Atomic_Load_uint(&ctx->atomic_int_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(ic == (ia + ib)); + + _Atomic_Store_ulong(&ctx->atomic_value, a, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_add_ulong(&ctx->atomic_value, b, ATOMIC_ORDER_RELAXED); + c = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(c == (a + b)); +} + +static void test_simple_atomic_sub_body(test_context *ctx) +{ + unsigned int ia = 8, ib = 4; + unsigned int ic; + unsigned long a = 2, b = 1; + unsigned long c; + + puts("=== atomic simple sub test case ==="); + + _Atomic_Store_uint(&ctx->atomic_int_value, ia, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_sub_uint(&ctx->atomic_int_value, ib, ATOMIC_ORDER_RELAXED); + ic = _Atomic_Load_uint(&ctx->atomic_int_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(ic == (ia - ib)); + + _Atomic_Store_ulong(&ctx->atomic_value, a, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_sub_ulong(&ctx->atomic_value, b, ATOMIC_ORDER_RELAXED); + c = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(c == (a - b)); +} + +static void test_simple_atomic_or_body(test_context *ctx) +{ + unsigned int ia = 8, ib = 4; + unsigned int ic; + unsigned long a = 2, b = 1; + unsigned long c; + + puts("=== atomic simple or test case ==="); + + _Atomic_Store_uint(&ctx->atomic_int_value, ia, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_or_uint(&ctx->atomic_int_value, ib, ATOMIC_ORDER_RELAXED); + ic = _Atomic_Load_uint(&ctx->atomic_int_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(ic == (ia | ib)); + + _Atomic_Store_ulong(&ctx->atomic_value, a, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_or_ulong(&ctx->atomic_value, b, ATOMIC_ORDER_RELAXED); + c = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(c == (a | b)); +} + +static void test_simple_atomic_and_body(test_context *ctx) +{ + unsigned int ia = 8, ib = 4; + unsigned int ic; + unsigned long a = 2, b = 1; + unsigned long c; + + puts("=== atomic simple and test case ==="); + + _Atomic_Store_uint(&ctx->atomic_int_value, ia, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_and_uint(&ctx->atomic_int_value, ib, ATOMIC_ORDER_RELAXED); + ic = _Atomic_Load_uint(&ctx->atomic_int_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(ic == (ia & ib)); + + _Atomic_Store_ulong(&ctx->atomic_value, a, ATOMIC_ORDER_RELAXED); + _Atomic_Fetch_and_ulong(&ctx->atomic_value, b, ATOMIC_ORDER_RELAXED); + c = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(c == (a & b)); +} + +static void test_simple_atomic_exchange_body(test_context *ctx) +{ + unsigned int ia = 8, ib = 4; + unsigned int ic; + unsigned long a = 2, b = 1; + unsigned long c; + + puts("=== atomic simple exchange test case ==="); + + _Atomic_Store_uint(&ctx->atomic_int_value, ia, ATOMIC_ORDER_RELAXED); + _Atomic_Exchange_uint(&ctx->atomic_int_value, ib, ATOMIC_ORDER_RELAXED); + ic = _Atomic_Load_uint(&ctx->atomic_int_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(ic == ib); + + _Atomic_Store_ulong(&ctx->atomic_value, a, ATOMIC_ORDER_RELAXED); + _Atomic_Exchange_ulong(&ctx->atomic_value, b, ATOMIC_ORDER_RELAXED); + c = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(c == b); +} + +static void test_simple_atomic_compare_exchange_body(test_context *ctx) +{ + unsigned int ia = 8, ib = 4; + unsigned int ic; + unsigned long a = 2, b = 1; + unsigned long c; + + puts("=== atomic simple compare exchange test case ==="); + + _Atomic_Store_uint(&ctx->atomic_int_value, ia, ATOMIC_ORDER_RELAXED); + _Atomic_Compare_exchange_uint(&ctx->atomic_int_value, &ia, ib, + ATOMIC_ORDER_RELAXED, ATOMIC_ORDER_RELAXED); + ic = _Atomic_Load_uint(&ctx->atomic_int_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(ic == ib); + + _Atomic_Store_ulong(&ctx->atomic_value, a, ATOMIC_ORDER_RELAXED); + _Atomic_Compare_exchange_ulong(&ctx->atomic_value, &a, b, + ATOMIC_ORDER_RELAXED, ATOMIC_ORDER_RELAXED); + c = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + rtems_test_assert(c == b); +} + +static const simple_test_body simple_test_bodies[] = { + test_simple_atomic_add_body, + test_simple_atomic_sub_body, + test_simple_atomic_or_body, + test_simple_atomic_and_body, + test_simple_atomic_exchange_body, + test_simple_atomic_compare_exchange_body, +}; + +#define SIMPLE_TEST_COUNT RTEMS_ARRAY_SIZE(simple_test_bodies) + +static void simple_tests(void) +{ + test_context *ctx = &test_instance; + size_t test; + + for (test = 0; test < SIMPLE_TEST_COUNT; ++test) { + const simple_test_body *test_body = &simple_test_bodies[test]; + + (*test_body)(ctx); + } +} + +static void Init(rtems_task_argument arg) +{ + TEST_BEGIN(); + + test_static_and_dynamic_initialization(); + simple_tests(); + + TEST_END(); + rtems_test_exit(0); +} + +#define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER +#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER + +#define CONFIGURE_MAXIMUM_TASKS 1 + +#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION + +#define CONFIGURE_RTEMS_INIT_TASKS_TABLE + +#define CONFIGURE_INIT + +#include diff --git a/testsuites/sptests/spatomic01/spatomic01.doc b/testsuites/sptests/spatomic01/spatomic01.doc new file mode 100644 index 0000000000..85fae09c7c --- /dev/null +++ b/testsuites/sptests/spatomic01/spatomic01.doc @@ -0,0 +1,37 @@ +This file describes the directives and concepts tested by this test set. + +test set name: spatomic01 + +directives: + + - ATOMIC_INITIALIZER_FLAG + - ATOMIC_INITIALIZER_PTR() + - ATOMIC_INITIALIZER_UINT() + - ATOMIC_INITIALIZER_ULONG() + - _Atomic_Compare_exchange_uint() + - _Atomic_Compare_exchange_ulong() + - _Atomic_Exchange_uint() + - _Atomic_Exchange_ulong() + - _Atomic_Fence() + - _Atomic_Fetch_add_uint() + - _Atomic_Fetch_add_ulong() + - _Atomic_Fetch_and_uint() + - _Atomic_Fetch_and_ulong() + - _Atomic_Fetch_or_uint() + - _Atomic_Fetch_or_ulong() + - _Atomic_Fetch_sub_uint() + - _Atomic_Fetch_sub_ulong() + - _Atomic_Flag_clear() + - _Atomic_Flag_test_and_set() + - _Atomic_Init_ptr() + - _Atomic_Init_uint() + - _Atomic_Init_ulong() + - _Atomic_Load_ptr() + - _Atomic_Load_uint() + - _Atomic_Load_ulong() + - _Atomic_Store_uint() + - _Atomic_Store_ulong() + +concepts: + + - Ensure that the atomic operations work. diff --git a/testsuites/sptests/spatomic01/spatomic01.scn b/testsuites/sptests/spatomic01/spatomic01.scn new file mode 100644 index 0000000000..237efde239 --- /dev/null +++ b/testsuites/sptests/spatomic01/spatomic01.scn @@ -0,0 +1,9 @@ +*** BEGIN OF TEST SPATOMIC 1 *** +=== static and dynamic initialization test case === +=== atomic simple add test case === +=== atomic simple sub test case === +=== atomic simple or test case === +=== atomic simple and test case === +=== atomic simple exchange test case === +=== atomic simple compare exchange test case === +*** END OF TEST SPATOMIC 1 *** -- cgit v1.2.3