From bbed18668fbf78b5728ec4dc42c35565e3451165 Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Wed, 29 May 2013 10:41:18 +0200 Subject: smptests/smplock01: New test --- testsuites/smptests/smplock01/init.c | 405 +++++++++++++++++++++++++++++++++++ 1 file changed, 405 insertions(+) create mode 100644 testsuites/smptests/smplock01/init.c (limited to 'testsuites/smptests/smplock01/init.c') diff --git a/testsuites/smptests/smplock01/init.c b/testsuites/smptests/smplock01/init.c new file mode 100644 index 0000000000..88ef985386 --- /dev/null +++ b/testsuites/smptests/smplock01/init.c @@ -0,0 +1,405 @@ +/* + * Copyright (c) 2013 embedded brains GmbH. All rights reserved. + * + * embedded brains GmbH + * Dornierstr. 4 + * 82178 Puchheim + * Germany + * + * + * The license and distribution terms for this file may be + * found in the file LICENSE in this distribution or at + * http://www.rtems.com/license/LICENSE. + */ + +#ifdef HAVE_CONFIG_H + #include "config.h" +#endif + +#include + +#include "tmacros.h" + +/* FIXME: Use C11 for atomic operations */ + +static void atomic_store(int *addr, int value) +{ + *addr = value; + + RTEMS_COMPILER_MEMORY_BARRIER(); +} + +static unsigned int atomic_load(const int *addr) +{ + RTEMS_COMPILER_MEMORY_BARRIER(); + + return *addr; +} + +/* FIXME: Add barrier to Score */ + +typedef struct { + int value; + int sense; + SMP_lock_Control lock; +} barrier_control; + +typedef struct { + int sense; +} barrier_state; + +#define BARRIER_CONTROL_INITIALIZER { 0, 0, SMP_LOCK_INITIALIZER } + +#define BARRIER_STATE_INITIALIZER { 0 } + +static void barrier_wait( + barrier_control *control, + barrier_state *state, + int cpu_count +) +{ + int sense = ~state->sense; + int value; + + state->sense = sense; + + _SMP_lock_Acquire(&control->lock); + value = control->value; + ++value; + control->value = value; + _SMP_lock_Release(&control->lock); + + if (value == cpu_count) { + atomic_store(&control->value, 0); + atomic_store(&control->sense, sense); + } + + while (atomic_load(&control->sense) != sense) { + /* Wait */ + } +} + +#define TASK_PRIORITY 1 + +#define CPU_COUNT 32 + +#define TEST_COUNT 5 + +typedef enum { + INITIAL, + START_TEST, + STOP_TEST +} states; + +typedef struct { + int state; + barrier_control barrier; + rtems_id timer_id; + rtems_interval timeout; + unsigned long counter[TEST_COUNT]; + unsigned long test_counter[TEST_COUNT][CPU_COUNT]; + SMP_lock_Control lock; +} global_context; + +static global_context context = { + .state = INITIAL, + .barrier = BARRIER_CONTROL_INITIALIZER, + .lock = SMP_LOCK_INITIALIZER +}; + +static const char *test_names[TEST_COUNT] = { + "aquire global lock with local counter", + "aquire global lock with global counter", + "aquire local lock with local counter", + "aquire local lock with global counter", + "aquire global lock with busy section" +}; + +static void stop_test_timer(rtems_id timer_id, void *arg) +{ + global_context *ctx = arg; + + atomic_store(&ctx->state, STOP_TEST); +} + +static void wait_for_state(global_context *ctx, int desired_state) +{ + while (atomic_load(&ctx->state) != desired_state) { + /* Wait */ + } +} + +static bool assert_state(global_context *ctx, int desired_state) +{ + return atomic_load(&ctx->state) == desired_state; +} + +typedef void (*test_body)( + int test, + global_context *ctx, + barrier_state *bs, + int cpu_count, + int cpu_self +); + +static void test_0_body( + int test, + global_context *ctx, + barrier_state *bs, + int cpu_count, + int cpu_self +) +{ + unsigned long counter = 0; + + while (assert_state(ctx, START_TEST)) { + _SMP_lock_Acquire(&ctx->lock); + _SMP_lock_Release(&ctx->lock); + ++counter; + } + + ctx->test_counter[test][cpu_self] = counter; +} + +static void test_1_body( + int test, + global_context *ctx, + barrier_state *bs, + int cpu_count, + int cpu_self +) +{ + unsigned long counter = 0; + + while (assert_state(ctx, START_TEST)) { + _SMP_lock_Acquire(&ctx->lock); + ++ctx->counter[test]; + _SMP_lock_Release(&ctx->lock); + ++counter; + } + + ctx->test_counter[test][cpu_self] = counter; +} + +static void test_2_body( + int test, + global_context *ctx, + barrier_state *bs, + int cpu_count, + int cpu_self +) +{ + unsigned long counter = 0; + SMP_lock_Control lock = SMP_LOCK_INITIALIZER; + + while (assert_state(ctx, START_TEST)) { + _SMP_lock_Acquire(&lock); + _SMP_lock_Release(&lock); + ++counter; + } + + ctx->test_counter[test][cpu_self] = counter; +} + +static void test_3_body( + int test, + global_context *ctx, + barrier_state *bs, + int cpu_count, + int cpu_self +) +{ + unsigned long counter = 0; + SMP_lock_Control lock = SMP_LOCK_INITIALIZER; + + while (assert_state(ctx, START_TEST)) { + _SMP_lock_Acquire(&lock); + + /* The counter value is not interesting, only the access to it */ + ++ctx->counter[test]; + + _SMP_lock_Release(&lock); + ++counter; + } + + ctx->test_counter[test][cpu_self] = counter; +} + +static void busy_section(void) +{ + int i; + + for (i = 0; i < 101; ++i) { + RTEMS_COMPILER_MEMORY_BARRIER(); + } +} + +static void test_4_body( + int test, + global_context *ctx, + barrier_state *bs, + int cpu_count, + int cpu_self +) +{ + unsigned long counter = 0; + + while (assert_state(ctx, START_TEST)) { + _SMP_lock_Acquire(&ctx->lock); + busy_section(); + _SMP_lock_Release(&ctx->lock); + ++counter; + } + + ctx->test_counter[test][cpu_self] = counter; +} + +static const test_body test_bodies[TEST_COUNT] = { + test_0_body, + test_1_body, + test_2_body, + test_3_body, + test_4_body +}; + +static void run_tests( + global_context *ctx, + barrier_state *bs, + int cpu_count, + int cpu_self, + bool master +) +{ + int test; + + for (test = 0; test < TEST_COUNT; ++test) { + barrier_wait(&ctx->barrier, bs, cpu_count); + + if (master) { + rtems_status_code sc = rtems_timer_fire_after( + ctx->timer_id, + ctx->timeout, + stop_test_timer, + ctx + ); + rtems_test_assert(sc == RTEMS_SUCCESSFUL); + + atomic_store(&ctx->state, START_TEST); + } + + wait_for_state(ctx, START_TEST); + + (*test_bodies[test])(test, ctx, bs, cpu_count, cpu_self); + } + + barrier_wait(&ctx->barrier, bs, cpu_count); +} + +static void task(rtems_task_argument arg) +{ + global_context *ctx = (global_context *) arg; + int cpu_count = (int) rtems_smp_get_number_of_processors(); + int cpu_self = rtems_smp_get_current_processor(); + rtems_status_code sc; + barrier_state bs = BARRIER_STATE_INITIALIZER; + + run_tests(ctx, &bs, cpu_count, cpu_self, false); + + sc = rtems_task_suspend(RTEMS_SELF); + rtems_test_assert(sc == RTEMS_SUCCESSFUL); +} + +static void test(void) +{ + global_context *ctx = &context; + int cpu_count = (int) rtems_smp_get_number_of_processors(); + int cpu_self = rtems_smp_get_current_processor(); + int cpu; + int test; + rtems_status_code sc; + barrier_state bs = BARRIER_STATE_INITIALIZER; + + for (cpu = 0; cpu < cpu_count; ++cpu) { + if (cpu != cpu_self) { + rtems_id task_id; + + sc = rtems_task_create( + rtems_build_name('T', 'A', 'S', 'K'), + TASK_PRIORITY, + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_MODES, + RTEMS_DEFAULT_ATTRIBUTES, + &task_id + ); + rtems_test_assert(sc == RTEMS_SUCCESSFUL); + + sc = rtems_task_start(task_id, task, (rtems_task_argument) ctx); + rtems_test_assert(sc == RTEMS_SUCCESSFUL); + } + } + + ctx->timeout = 10 * rtems_clock_get_ticks_per_second(); + + sc = rtems_timer_create(rtems_build_name('T', 'I', 'M', 'R'), &ctx->timer_id); + rtems_test_assert(sc == RTEMS_SUCCESSFUL); + + run_tests(ctx, &bs, cpu_count, cpu_self, true); + + for (test = 0; test < TEST_COUNT; ++test) { + unsigned long sum = 0; + + printf("%s\n", test_names[test]); + + for (cpu = 0; cpu < cpu_count; ++cpu) { + unsigned long local_counter = ctx->test_counter[test][cpu]; + + sum += local_counter; + + printf( + "\tprocessor %i, local counter %lu\n", + cpu, + local_counter + ); + } + + printf( + "\tglobal counter %lu, sum of local counter %lu\n", + ctx->counter[test], + sum + ); + } +} + +static void Init(rtems_task_argument arg) +{ + puts("\n\n*** TEST SMPLOCK 1 ***"); + + test(); + + puts("*** END OF TEST SMPLOCK 1 ***"); + + rtems_test_exit(0); +} + +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER +#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER + +#define CONFIGURE_SMP_APPLICATION + +#define CONFIGURE_SMP_MAXIMUM_PROCESSORS CPU_COUNT + +#define CONFIGURE_MAXIMUM_TASKS CPU_COUNT + +#define CONFIGURE_MAXIMUM_SEMAPHORES 1 + +#define CONFIGURE_MAXIMUM_TIMERS 1 + +#define CONFIGURE_INIT_TASK_PRIORITY TASK_PRIORITY +#define CONFIGURE_INIT_TASK_INITIAL_MODES RTEMS_DEFAULT_MODES +#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES + +#define CONFIGURE_RTEMS_INIT_TASKS_TABLE + +#define CONFIGURE_INIT + +#include -- cgit v1.2.3