From df8d7bd76f5014583d6cc20f72f335e5fe2bd0cc Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Tue, 9 Apr 2019 10:58:35 +0200 Subject: score: Use processor mask in _SMP_Multicast_action Processor_mask is the internal data type to deal with processor sets. --- testsuites/smptests/smpmulticast01/init.c | 288 +++++++++++++++++++++ .../smptests/smpmulticast01/smpmulticast01.doc | 12 + .../smptests/smpmulticast01/smpmulticast01.scn | 54 ++++ 3 files changed, 354 insertions(+) create mode 100644 testsuites/smptests/smpmulticast01/init.c create mode 100644 testsuites/smptests/smpmulticast01/smpmulticast01.doc create mode 100644 testsuites/smptests/smpmulticast01/smpmulticast01.scn (limited to 'testsuites/smptests/smpmulticast01') diff --git a/testsuites/smptests/smpmulticast01/init.c b/testsuites/smptests/smpmulticast01/init.c new file mode 100644 index 0000000000..2319582ab6 --- /dev/null +++ b/testsuites/smptests/smpmulticast01/init.c @@ -0,0 +1,288 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (C) 2019 embedded brains GmbH + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include + +#include + +#include +#include + +#define CPU_COUNT 32 + +const char rtems_test_name[] = "SMPMULTICAST 1"; + +static const T_config config = { + .name = "SMPMultiCast", + .putchar = T_putchar_default, + .verbosity = T_VERBOSE, + .now = T_now +}; + +typedef struct { + Atomic_Uint id[CPU_COUNT]; +} test_context; + +static test_context test_instance; + +static void multicast_action_irq_disabled( + const Processor_mask *targets, + SMP_Action_handler handler, + void *arg +) +{ + rtems_interrupt_level level; + + rtems_interrupt_local_disable(level); + _SMP_Multicast_action(targets, handler, arg); + rtems_interrupt_local_enable(level); +} + +static void multicast_action_dispatch_disabled( + const Processor_mask *targets, + SMP_Action_handler handler, + void *arg +) +{ + Per_CPU_Control *cpu_self; + + cpu_self = _Thread_Dispatch_disable(); + _SMP_Multicast_action(targets, handler, arg); + _Thread_Dispatch_enable(cpu_self); +} + +static void action(void *arg) +{ + test_context *ctx; + uint32_t self; + unsigned expected; + bool success; + + ctx = arg; + self = rtems_scheduler_get_processor(); + expected = 0; + success = _Atomic_Compare_exchange_uint( + &ctx->id[self], + &expected, + self + 1, + ATOMIC_ORDER_RELAXED, + ATOMIC_ORDER_RELAXED + ); + T_quiet_true(success, "set CPU identifier failed"); +} + +static void test_unicast( + test_context *ctx, + void (*multicast_action)(const Processor_mask *, SMP_Action_handler, void *), + bool before_multitasking +) +{ + uint32_t step; + uint32_t i; + uint32_t n; + uint32_t self; + + T_plan(1); + step = 0; + self = rtems_scheduler_get_processor(); + n = rtems_scheduler_get_processor_maximum(); + + for (i = 0; i < n; ++i) { + Processor_mask cpus; + uint32_t j; + + memset(ctx, 0, sizeof(*ctx)); + + _Processor_mask_Zero(&cpus); + _Processor_mask_Set(&cpus, i); + (*multicast_action)(&cpus, action, ctx); + + for (j = 0; j < n; ++j) { + unsigned id; + + ++step; + id = _Atomic_Load_uint(&ctx->id[j], ATOMIC_ORDER_RELAXED); + + if (before_multitasking) { + if (j == self) { + T_quiet_eq_uint(j + 1, id); + } else { + T_quiet_eq_uint(0, id); + } + } else { + if (j == i) { + T_quiet_eq_uint(j + 1, id); + } else { + T_quiet_eq_uint(0, id); + } + } + } + } + + T_step_eq_u32(0, step, n * n); +} + +static void test_broadcast( + test_context *ctx, + void (*multicast_action)(const Processor_mask *, SMP_Action_handler, void *), + bool before_multitasking +) +{ + uint32_t step; + uint32_t i; + uint32_t n; + uint32_t self; + + T_plan(1); + step = 0; + self = rtems_scheduler_get_processor(); + n = rtems_scheduler_get_processor_maximum(); + + for (i = 0; i < n; ++i) { + uint32_t j; + + memset(ctx, 0, sizeof(*ctx)); + + (*multicast_action)(NULL, action, ctx); + + for (j = 0; j < n; ++j) { + unsigned id; + + ++step; + id = _Atomic_Load_uint(&ctx->id[j], ATOMIC_ORDER_RELAXED); + + if (before_multitasking) { + if (j == self) { + T_quiet_eq_uint(j + 1, id); + } else { + T_quiet_eq_uint(0, id); + } + } else { + T_quiet_eq_uint(j + 1, id); + } + } + } + + T_step_eq_u32(0, step, n * n); +} + +static void test_before_multitasking(void) +{ + test_context *ctx; + + ctx = &test_instance; + + T_case_begin("UnicastBeforeMultitasking", NULL); + test_unicast(ctx, _SMP_Multicast_action, true); + T_case_end(); + + T_case_begin("UnicastBeforeMultitaskingIRQDisabled", NULL); + test_unicast(ctx, multicast_action_irq_disabled, true); + T_case_end(); + + T_case_begin("UnicastBeforeMultitaskingDispatchDisabled", NULL); + test_unicast(ctx, multicast_action_dispatch_disabled, true); + T_case_end(); + + T_case_begin("BroadcastBeforeMultitasking", NULL); + test_broadcast(ctx, _SMP_Multicast_action, true); + T_case_end(); + + T_case_begin("BroadcastBeforeMultitaskingIRQDisabled", NULL); + test_broadcast(ctx, multicast_action_irq_disabled, true); + T_case_end(); + + T_case_begin("BroadcastBeforeMultitaskingDispatchDisabled", NULL); + test_broadcast(ctx, multicast_action_dispatch_disabled, true); + T_case_end(); +} + +static void after_drivers(void) +{ + TEST_BEGIN(); + T_run_initialize(&config); + test_before_multitasking(); +} + +RTEMS_SYSINIT_ITEM( + after_drivers, + RTEMS_SYSINIT_DEVICE_DRIVERS, + RTEMS_SYSINIT_ORDER_LAST +); + +static void Init(rtems_task_argument arg) +{ + test_context *ctx; + bool ok; + + ctx = &test_instance; + + T_case_begin("UnicastDuringMultitasking", NULL); + test_unicast(ctx, _SMP_Multicast_action, false); + T_case_end(); + + T_case_begin("UnicastDuringMultitaskingIRQDisabled", NULL); + test_unicast(ctx, multicast_action_irq_disabled, false); + T_case_end(); + + T_case_begin("UnicastDuringMultitaskingDispatchDisabled", NULL); + test_unicast(ctx, multicast_action_dispatch_disabled, false); + T_case_end(); + + T_case_begin("BroadcastDuringMultitasking", NULL); + test_broadcast(ctx, _SMP_Multicast_action, false); + T_case_end(); + + T_case_begin("BroadcastDuringMultitaskingIRQDisabled", NULL); + test_broadcast(ctx, multicast_action_irq_disabled, false); + T_case_end(); + + T_case_begin("BroadcastDuringMultitaskingDispatchDisabled", NULL); + test_broadcast(ctx, multicast_action_dispatch_disabled, false); + T_case_end(); + + ok = T_run_finalize(); + rtems_test_assert(ok); + TEST_END(); + rtems_test_exit(0); +} + +#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER + +#define CONFIGURE_MAXIMUM_TASKS 1 + +#define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT + +#define CONFIGURE_RTEMS_INIT_TASKS_TABLE + +#define CONFIGURE_INIT + +#include diff --git a/testsuites/smptests/smpmulticast01/smpmulticast01.doc b/testsuites/smptests/smpmulticast01/smpmulticast01.doc new file mode 100644 index 0000000000..da6580028f --- /dev/null +++ b/testsuites/smptests/smpmulticast01/smpmulticast01.doc @@ -0,0 +1,12 @@ +This file describes the directives and concepts tested by this test set. + +test set name: smpmulticast01 + +directives: + + - _SMP_Multicast_action() + +concepts: + + - Ensure that _SMP_Multicast_action() works before multitasking. + - Ensure that _SMP_Multicast_action() works during multitasking. diff --git a/testsuites/smptests/smpmulticast01/smpmulticast01.scn b/testsuites/smptests/smpmulticast01/smpmulticast01.scn new file mode 100644 index 0000000000..ea532fdead --- /dev/null +++ b/testsuites/smptests/smpmulticast01/smpmulticast01.scn @@ -0,0 +1,54 @@ +*** BEGIN OF TEST SMPMULTICAST 1 *** +*** TEST VERSION: 5.0.0.c44199ccea624f31b1116fa2e47d547944e90909-modified +*** TEST STATE: EXPECTED-PASS +*** TEST BUILD: RTEMS_POSIX_API RTEMS_SMP +*** TEST TOOLS: 7.4.0 20181206 (RTEMS 5, RSB e0aec65182449a4e22b820e773087636edaf5b32, Newlib 1d35a003f) +A:SMPMultiCast +S:Platform:RTEMS +S:Compiler:7.4.0 20181206 (RTEMS 5, RSB e0aec65182449a4e22b820e773087636edaf5b32, Newlib 1d35a003f) +S:Version:5.0.0.c44199ccea624f31b1116fa2e47d547944e90909 +S:BSP:qoriq_e6500_32 +S:RTEMS_DEBUG:0 +S:RTEMS_MULTIPROCESSING:0 +S:RTEMS_POSIX_API:1 +S:RTEMS_PROFILING:0 +S:RTEMS_SMP:1 +B:UnicastBeforeMultitasking +P:0:0:IDLE:init.c:150 +E:UnicastBeforeMultitasking:N:1:F:0:D:0.001999 +B:UnicastBeforeMultitaskingIRQDisabled +P:0:0:IDLE:init.c:150 +E:UnicastBeforeMultitaskingIRQDisabled:N:1:F:0:D:0.001999 +B:UnicastBeforeMultitaskingDispatchDisabled +P:0:0:IDLE:init.c:150 +E:UnicastBeforeMultitaskingDispatchDisabled:N:1:F:0:D:0.001999 +B:BroadcastBeforeMultitasking +P:0:0:IDLE:init.c:194 +E:BroadcastBeforeMultitasking:N:1:F:0:D:0.001999 +B:BroadcastBeforeMultitaskingIRQDisabled +P:0:0:IDLE:init.c:194 +E:BroadcastBeforeMultitaskingIRQDisabled:N:1:F:0:D:0.001999 +B:BroadcastBeforeMultitaskingDispatchDisabled +P:0:0:IDLE:init.c:194 +E:BroadcastBeforeMultitaskingDispatchDisabled:N:1:F:0:D:0.001999 +B:UnicastDuringMultitasking +P:0:23:UI1:init.c:150 +E:UnicastDuringMultitasking:N:1:F:0:D:0.001999 +B:UnicastDuringMultitaskingIRQDisabled +P:0:23:UI1:init.c:150 +E:UnicastDuringMultitaskingIRQDisabled:N:1:F:0:D:0.002000 +B:UnicastDuringMultitaskingDispatchDisabled +P:0:23:UI1:init.c:150 +E:UnicastDuringMultitaskingDispatchDisabled:N:1:F:0:D:0.002000 +B:BroadcastDuringMultitasking +P:0:23:UI1:init.c:194 +E:BroadcastDuringMultitasking:N:1:F:0:D:0.002134 +B:BroadcastDuringMultitaskingIRQDisabled +P:0:23:UI1:init.c:194 +E:BroadcastDuringMultitaskingIRQDisabled:N:1:F:0:D:0.002165 +B:BroadcastDuringMultitaskingDispatchDisabled +P:0:23:UI1:init.c:194 +E:BroadcastDuringMultitaskingDispatchDisabled:N:1:F:0:D:0.002130 +Z:SMPMultiCast:C:12:N:12:F:0:D:0.125615 + +*** END OF TEST SMPMULTICAST 1 *** -- cgit v1.2.3