From f5d93a74219a38b461fe24d4c80d79208df37e8e Mon Sep 17 00:00:00 2001 From: Gedare Bloom Date: Fri, 23 Jan 2026 12:14:04 -0700 Subject: [PATCH] testsuites/smptests: reformat with clang-format Updates #3860. Updates #5358. --- testsuites/smptests/smp01/init.c | 45 +- testsuites/smptests/smp01/system.h | 13 +- testsuites/smptests/smp01/tasks.c | 19 +- testsuites/smptests/smp02/init.c | 56 +- testsuites/smptests/smp02/system.h | 26 +- testsuites/smptests/smp02/tasks.c | 30 +- testsuites/smptests/smp03/init.c | 48 +- testsuites/smptests/smp03/system.h | 28 +- testsuites/smptests/smp03/tasks.c | 11 +- testsuites/smptests/smp05/init.c | 50 +- testsuites/smptests/smp07/init.c | 95 +- testsuites/smptests/smp08/init.c | 54 +- testsuites/smptests/smp08/system.h | 26 +- testsuites/smptests/smp08/tasks.c | 13 +- testsuites/smptests/smp09/init.c | 52 +- testsuites/smptests/smpaffinity01/init.c | 185 +- testsuites/smptests/smpatomic01/init.c | 576 +++--- testsuites/smptests/smpcache01/init.c | 65 +- testsuites/smptests/smpcapture01/init.c | 197 +- testsuites/smptests/smpcapture02/init.c | 441 ++-- testsuites/smptests/smpclock01/init.c | 130 +- testsuites/smptests/smpfatal01/init.c | 79 +- testsuites/smptests/smpfatal02/init.c | 69 +- testsuites/smptests/smpfatal03/init.c | 23 +- testsuites/smptests/smpfatal04/init.c | 22 +- testsuites/smptests/smpfatal05/init.c | 40 +- testsuites/smptests/smpfatal06/init.c | 18 +- testsuites/smptests/smpfatal08/init.c | 52 +- testsuites/smptests/smpfatal09/init.c | 14 +- testsuites/smptests/smpipi01/init.c | 225 ++- testsuites/smptests/smpirqs01/init.c | 171 +- testsuites/smptests/smpload01/init.c | 280 +-- testsuites/smptests/smplock01/init.c | 620 +++--- testsuites/smptests/smpmigration01/init.c | 170 +- testsuites/smptests/smpmigration02/init.c | 410 ++-- testsuites/smptests/smpmrsp01/init.c | 1797 +++++++++-------- testsuites/smptests/smpmulticast01/init.c | 389 ++-- testsuites/smptests/smpmutex01/init.c | 1216 +++++------ testsuites/smptests/smpmutex02/init.c | 411 ++-- testsuites/smptests/smpopenmp01/init.c | 209 +- testsuites/smptests/smppsxaffinity01/init.c | 71 +- testsuites/smptests/smppsxaffinity02/init.c | 173 +- testsuites/smptests/smppsxmutex01/init.c | 162 +- testsuites/smptests/smppsxsignal01/init.c | 118 +- testsuites/smptests/smpschedaffinity01/init.c | 146 +- testsuites/smptests/smpschedaffinity02/init.c | 159 +- testsuites/smptests/smpschedaffinity03/init.c | 49 +- testsuites/smptests/smpschedaffinity04/init.c | 129 +- testsuites/smptests/smpschedaffinity05/init.c | 189 +- testsuites/smptests/smpschededf01/init.c | 88 +- testsuites/smptests/smpschededf02/init.c | 380 ++-- testsuites/smptests/smpschededf03/init.c | 88 +- testsuites/smptests/smpschededf04/init.c | 82 +- testsuites/smptests/smpschedsem01/init.c | 52 +- testsuites/smptests/smpscheduler01/init.c | 136 +- testsuites/smptests/smpscheduler02/init.c | 498 ++--- testsuites/smptests/smpscheduler03/init.c | 13 +- testsuites/smptests/smpscheduler03/test.c | 423 ++-- testsuites/smptests/smpscheduler04/init.c | 288 +-- testsuites/smptests/smpscheduler05/init.c | 8 +- testsuites/smptests/smpscheduler06/init.c | 15 +- testsuites/smptests/smpscheduler07/init.c | 8 +- testsuites/smptests/smpsignal01/init.c | 164 +- testsuites/smptests/smpstart01/init.c | 67 +- testsuites/smptests/smpstrongapa01/init.c | 303 ++- .../smptests/smpswitchextension01/init.c | 139 +- testsuites/smptests/smpthreadlife01/init.c | 352 ++-- testsuites/smptests/smpthreadpin01/init.c | 538 ++--- testsuites/smptests/smpunsupported01/init.c | 40 +- testsuites/smptests/smpwakeafter01/init.c | 178 +- 70 files changed, 6699 insertions(+), 6732 deletions(-) diff --git a/testsuites/smptests/smp01/init.c b/testsuites/smptests/smp01/init.c index 070516bf46..34e9227794 100644 --- a/testsuites/smptests/smp01/init.c +++ b/testsuites/smptests/smp01/init.c @@ -37,31 +37,30 @@ const char rtems_test_name[] = "SMP 1"; -void Loop() { +void Loop() +{ volatile int i; - for (i=0; i<300000; i++); + for ( i = 0; i < 300000; i++ ); } -rtems_task Init( - rtems_task_argument argument -) +rtems_task Init( rtems_task_argument argument ) { (void) argument; - uint32_t i; - char ch; - uint32_t cpu_self; - rtems_id id; - rtems_status_code status; - bool allDone; + uint32_t i; + char ch; + uint32_t cpu_self; + rtems_id id; + rtems_status_code status; + bool allDone; cpu_self = rtems_scheduler_get_processor(); /* XXX - Delay a bit to allow debug messages from * startup to print. This may need to go away when * debug messages go away. - */ + */ Loop(); TEST_BEGIN(); @@ -69,12 +68,12 @@ rtems_task Init( locked_print_initialize(); /* Initialize the TaskRan array */ - for ( i=0; i -rtems_task Test_task( - rtems_task_argument task_index -) +rtems_task Test_task( rtems_task_argument task_index ) { (void) task_index; - uint32_t cpu_num; - char name[5]; - char *p; + uint32_t cpu_num; + char name[ 5 ]; + char *p; /* Get the task name */ p = rtems_object_get_name( RTEMS_SELF, 5, name ); rtems_test_assert( p != NULL ); - /* Get the CPU Number */ + /* Get the CPU Number */ cpu_num = rtems_scheduler_get_processor(); /* Print that the task is up and running. */ Loop(); - locked_printf(" CPU %" PRIu32 " running Task %s\n", cpu_num, name); + locked_printf( " CPU %" PRIu32 " running Task %s\n", cpu_num, name ); /* Set the flag that the task is up and running */ - TaskRan[cpu_num] = true; - + TaskRan[ cpu_num ] = true; /* Drop into a loop which will keep this task on * running on the cpu. */ - while(1); + while ( 1 ); } diff --git a/testsuites/smptests/smp02/init.c b/testsuites/smptests/smp02/init.c index c630c49b3f..d584a897c8 100644 --- a/testsuites/smptests/smp02/init.c +++ b/testsuites/smptests/smp02/init.c @@ -38,15 +38,13 @@ const char rtems_test_name[] = "SMP 2"; -static void success(void) +static void success( void ) { TEST_END(); rtems_test_exit( 0 ); } -rtems_task Init( - rtems_task_argument argument -) +rtems_task Init( rtems_task_argument argument ) { (void) argument; @@ -55,7 +53,7 @@ rtems_task Init( uint32_t cpu_num; rtems_id id; rtems_status_code status; - char str[80]; + char str[ 80 ]; TEST_BEGIN(); @@ -67,21 +65,19 @@ rtems_task Init( /* Create/verify synchronisation semaphore */ status = rtems_semaphore_create( - rtems_build_name ('S', 'E', 'M', '1'), - 1, - RTEMS_LOCAL | - RTEMS_SIMPLE_BINARY_SEMAPHORE | - RTEMS_PRIORITY, + rtems_build_name( 'S', 'E', 'M', '1' ), 1, - &Semaphore); + RTEMS_LOCAL | RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, + 1, + &Semaphore + ); directive_failed( status, "rtems_semaphore_create" ); /* Lock semaphore */ - status = rtems_semaphore_obtain( Semaphore, RTEMS_WAIT, 0); - directive_failed( status,"rtems_semaphore_obtain of SEM1\n"); - - for ( i=1; i < rtems_scheduler_get_processor_maximum(); i++ ){ + status = rtems_semaphore_obtain( Semaphore, RTEMS_WAIT, 0 ); + directive_failed( status, "rtems_semaphore_obtain of SEM1\n" ); + for ( i = 1; i < rtems_scheduler_get_processor_maximum(); i++ ) { /* Create and start tasks for each CPU */ ch = '0' + i; @@ -95,8 +91,8 @@ rtems_task Init( ); cpu_num = rtems_scheduler_get_processor(); - locked_printf(" CPU %" PRIu32 " start task TA%c\n", cpu_num, ch); - status = rtems_task_start( id, Test_task, i+1 ); + locked_printf( " CPU %" PRIu32 " start task TA%c\n", cpu_num, ch ); + status = rtems_task_start( id, Test_task, i + 1 ); directive_failed( status, str ); } @@ -104,27 +100,25 @@ rtems_task Init( * Release the semaphore, allowing the blocked tasks to start. */ status = rtems_semaphore_release( Semaphore ); - directive_failed( status,"rtems_semaphore_release of SEM1\n"); - + directive_failed( status, "rtems_semaphore_release of SEM1\n" ); /* * Wait for log full. print the log and end the program. - */ - while (Log_index < LOG_SIZE) - ; - - for (i=0; i< LOG_SIZE; i++) { - if ( Log[i].IsLocked ) { + */ + while ( Log_index < LOG_SIZE ); + + for ( i = 0; i < LOG_SIZE; i++ ) { + if ( Log[ i ].IsLocked ) { locked_printf( - " CPU %d Task TA%" PRIu32 " Obtain\n", - Log[i].cpu_num, - Log[i].task_index + " CPU %d Task TA%" PRIu32 " Obtain\n", + Log[ i ].cpu_num, + Log[ i ].task_index ); } else { locked_printf( - " CPU %d Task TA%" PRIu32 " Release\n", - Log[i].cpu_num, - Log[i].task_index + " CPU %d Task TA%" PRIu32 " Release\n", + Log[ i ].cpu_num, + Log[ i ].task_index ); } } diff --git a/testsuites/smptests/smp02/system.h b/testsuites/smptests/smp02/system.h index f010ad4e51..70cb4f1dda 100644 --- a/testsuites/smptests/smp02/system.h +++ b/testsuites/smptests/smp02/system.h @@ -31,37 +31,31 @@ /* functions */ -rtems_task Init( - rtems_task_argument argument -); +rtems_task Init( rtems_task_argument argument ); -rtems_task Test_task( - rtems_task_argument argument -); +rtems_task Test_task( rtems_task_argument argument ); /* configuration information */ #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_PROCESSORS 4 +#define CONFIGURE_MAXIMUM_PROCESSORS 4 -#define CONFIGURE_MAXIMUM_TASKS \ - (1 + CONFIGURE_MAXIMUM_PROCESSORS) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + CONFIGURE_MAXIMUM_PROCESSORS ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_RTEMS_INIT_TASKS_TABLE #define CONFIGURE_INIT_TASK_STACK_SIZE \ - (3 * CONFIGURE_MINIMUM_TASK_STACK_SIZE) + ( 3 * CONFIGURE_MINIMUM_TASK_STACK_SIZE ) #define CONFIGURE_RTEMS_INIT_TASKS_TABLE -#define CONFIGURE_MAXIMUM_SEMAPHORES 2 +#define CONFIGURE_MAXIMUM_SEMAPHORES 2 #include - /* global variables */ /* @@ -74,11 +68,11 @@ typedef struct { uint32_t task_index; } Log_t; -#define LOG_SIZE 20 +#define LOG_SIZE 20 -TEST_EXTERN rtems_id Semaphore; /* synchronisation semaphore */ -TEST_EXTERN Log_t Log[LOG_SIZE]; /* A log of locks/unlocks */ -TEST_EXTERN volatile uint32_t Log_index; /* Index into log */ +TEST_EXTERN rtems_id Semaphore; /* synchronisation semaphore */ +TEST_EXTERN Log_t Log[ LOG_SIZE ]; /* A log of locks/unlocks */ +TEST_EXTERN volatile uint32_t Log_index; /* Index into log */ /* * Handy macros and static inline functions diff --git a/testsuites/smptests/smp02/tasks.c b/testsuites/smptests/smp02/tasks.c index 85e4187465..8d15338379 100644 --- a/testsuites/smptests/smp02/tasks.c +++ b/testsuites/smptests/smp02/tasks.c @@ -33,22 +33,21 @@ #include "system.h" static void LogSemaphore( - bool obtained, - uint32_t cpu_num, - uint32_t task_index -){ - if (Log_index < LOG_SIZE) { + bool obtained, + uint32_t cpu_num, + uint32_t task_index +) +{ + if ( Log_index < LOG_SIZE ) { /* Log the information */ - Log[ Log_index ].IsLocked = obtained; - Log[ Log_index ].cpu_num = cpu_num; + Log[ Log_index ].IsLocked = obtained; + Log[ Log_index ].cpu_num = cpu_num; Log[ Log_index ].task_index = task_index; Log_index++; } } -rtems_task Test_task( - rtems_task_argument task_index -) +rtems_task Test_task( rtems_task_argument task_index ) { uint32_t cpu_num; rtems_status_code sc; @@ -56,15 +55,14 @@ rtems_task Test_task( cpu_num = rtems_scheduler_get_processor(); do { - /* Poll to obtain the synchronization semaphore */ do { sc = rtems_semaphore_obtain( Semaphore, RTEMS_NO_WAIT, 0 ); - } while (sc != RTEMS_SUCCESSFUL ); + } while ( sc != RTEMS_SUCCESSFUL ); + + LogSemaphore( true, cpu_num, task_index ); + LogSemaphore( false, cpu_num, task_index ); - LogSemaphore(true, cpu_num, task_index); - LogSemaphore(false, cpu_num, task_index); - rtems_semaphore_release( Semaphore ); - } while(1); + } while ( 1 ); } diff --git a/testsuites/smptests/smp03/init.c b/testsuites/smptests/smp03/init.c index e7401e6121..19e00d65d4 100644 --- a/testsuites/smptests/smp03/init.c +++ b/testsuites/smptests/smp03/init.c @@ -38,32 +38,29 @@ const char rtems_test_name[] = "SMP 3"; -static void success(void) +static void success( void ) { TEST_END(); rtems_test_exit( 0 ); } -void Loop() { +void Loop() +{ volatile int i; - for (i=0; i<300000; i++); + for ( i = 0; i < 300000; i++ ); } -void PrintTaskInfo( - const char *task_name -) +void PrintTaskInfo( const char *task_name ) { uint32_t cpu_num; cpu_num = rtems_scheduler_get_processor(); - locked_printf(" CPU %" PRIu32 " running task %s\n", cpu_num, task_name ); + locked_printf( " CPU %" PRIu32 " running task %s\n", cpu_num, task_name ); } -rtems_task Init( - rtems_task_argument argument -) +rtems_task Init( rtems_task_argument argument ) { (void) argument; @@ -85,22 +82,21 @@ rtems_task Init( } /* Initialize the TaskRan array */ - TaskRan[0] = true; - for ( i=1; i - /* global variables */ /* @@ -74,12 +68,10 @@ TEST_EXTERN volatile bool TaskRan[ CONFIGURE_MAXIMUM_PROCESSORS + 1 ]; /* * Keep the names and IDs in global variables so another task can use them. */ -void Loop(void); -void PrintTaskInfo( - const char *task_name -); +void Loop( void ); +void PrintTaskInfo( const char *task_name ); -TEST_EXTERN volatile bool TestFinished; +TEST_EXTERN volatile bool TestFinished; /* * Handy macros and static inline functions diff --git a/testsuites/smptests/smp03/tasks.c b/testsuites/smptests/smp03/tasks.c index 0852339279..61e77f3c63 100644 --- a/testsuites/smptests/smp03/tasks.c +++ b/testsuites/smptests/smp03/tasks.c @@ -32,19 +32,16 @@ #include "system.h" -rtems_task Test_task( - rtems_task_argument task_index -) +rtems_task Test_task( rtems_task_argument task_index ) { - char task_name[5]; + char task_name[ 5 ]; /* Show that this task is running on cpu X */ sprintf( task_name, "TA%" PRIuPTR, task_index ); PrintTaskInfo( task_name ); - TaskRan[task_index] = true; + TaskRan[ task_index ] = true; /* Wait for the test to end without giving up this processor */ - while(1) - ; + while ( 1 ); } diff --git a/testsuites/smptests/smp05/init.c b/testsuites/smptests/smp05/init.c index df9b5e8de3..650e07fd2a 100644 --- a/testsuites/smptests/smp05/init.c +++ b/testsuites/smptests/smp05/init.c @@ -37,46 +37,40 @@ const char rtems_test_name[] = "SMP 5"; static volatile bool init_task_done; -rtems_task Init( - rtems_task_argument argument -); +rtems_task Init( rtems_task_argument argument ); -rtems_task Test_task( - rtems_task_argument argument -); +rtems_task Test_task( rtems_task_argument argument ); - -static void success(void) +static void success( void ) { TEST_END(); rtems_test_exit( 0 ); } -rtems_task Test_task( - rtems_task_argument argument -) +rtems_task Test_task( rtems_task_argument argument ) { (void) argument; - while (!init_task_done) { + while ( !init_task_done ) { /* Wait */ } - locked_printf( "Shut down from CPU %" PRIu32 "\n", rtems_scheduler_get_processor() ); + locked_printf( + "Shut down from CPU %" PRIu32 "\n", + rtems_scheduler_get_processor() + ); success(); } -rtems_task Init( - rtems_task_argument argument -) +rtems_task Init( rtems_task_argument argument ) { (void) argument; - uint32_t i; - char ch; - uint32_t cpu_num; - rtems_id id; - rtems_status_code status; + uint32_t i; + char ch; + uint32_t cpu_num; + rtems_id id; + rtems_status_code status; locked_print_initialize(); TEST_BEGIN(); @@ -85,7 +79,7 @@ rtems_task Init( success(); } - for ( i=0; i then ) + while ( 1 ) { + if ( rtems_clock_get_ticks_since_boot() > then ) { break; - if ( TSRFired && TaskRan ) + } + if ( TSRFired && TaskRan ) { break; + } }; /* Validate the timer fired and that the task ran */ - if ( !TSRFired ) + if ( !TSRFired ) { locked_printf( "*** ERROR TSR DID NOT FIRE ***" ); + } if ( !TaskRan ) { locked_printf( "*** ERROR TASK DID NOT RUN ***" ); - rtems_test_exit(0); + rtems_test_exit( 0 ); } /* End the program */ @@ -201,14 +198,14 @@ rtems_task Init( #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER -#define CONFIGURE_MAXIMUM_PROCESSORS 2 -#define CONFIGURE_MAXIMUM_TIMERS 1 +#define CONFIGURE_MAXIMUM_PROCESSORS 2 +#define CONFIGURE_MAXIMUM_TIMERS 1 -#define CONFIGURE_MAXIMUM_TASKS 2 +#define CONFIGURE_MAXIMUM_TASKS 2 #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_RTEMS_INIT_TASKS_TABLE -#define CONFIGURE_MAXIMUM_SEMAPHORES 2 +#define CONFIGURE_MAXIMUM_SEMAPHORES 2 #define CONFIGURE_INIT diff --git a/testsuites/smptests/smp08/init.c b/testsuites/smptests/smp08/init.c index 1cc30a3b17..aeb8bf07c1 100644 --- a/testsuites/smptests/smp08/init.c +++ b/testsuites/smptests/smp08/init.c @@ -35,10 +35,7 @@ const char rtems_test_name[] = "SMP 8"; -void PrintTaskInfo( - const char *task_name, - rtems_time_of_day *_tb -) +void PrintTaskInfo( const char *task_name, rtems_time_of_day *_tb ) { uint32_t cpu_num; @@ -47,48 +44,48 @@ void PrintTaskInfo( /* Print the cpu number and task name */ locked_printf( " CPU %" PRIu32 " running task %s - rtems_clock_get_tod " - "%02" PRId32 ":%02" PRId32 ":%02" PRId32 " %02" PRId32 - "/%02" PRId32 "/%04" PRId32 "\n", + "%02" PRId32 ":%02" PRId32 ":%02" PRId32 " %02" PRId32 "/%02" PRId32 + "/%04" PRId32 "\n", cpu_num, task_name, - _tb->hour, _tb->minute, _tb->second, - _tb->month, _tb->day, _tb->year - ); + _tb->hour, + _tb->minute, + _tb->second, + _tb->month, + _tb->day, + _tb->year + ); } -rtems_task Init( - rtems_task_argument argument -) +rtems_task Init( rtems_task_argument argument ) { (void) argument; rtems_status_code status; rtems_time_of_day time; uint32_t i; - char ch[4]; + char ch[ 4 ]; rtems_id id; TEST_BEGIN(); - + locked_print_initialize(); - time.year = 1988; - time.month = 12; - time.day = 31; - time.hour = 9; + time.year = 1988; + time.month = 12; + time.day = 31; + time.hour = 9; time.minute = 0; time.second = 0; - time.ticks = 0; + time.ticks = 0; status = rtems_clock_set( &time ); /* Create/verify synchronisation semaphore */ status = rtems_semaphore_create( - rtems_build_name ('S', 'E', 'M', '1'), - 1, - RTEMS_LOCAL | - RTEMS_SIMPLE_BINARY_SEMAPHORE | - RTEMS_PRIORITY, + rtems_build_name( 'S', 'E', 'M', '1' ), + 1, + RTEMS_LOCAL | RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, 1, &Semaphore ); @@ -97,11 +94,10 @@ rtems_task Init( /* Show that the init task is running on this cpu */ PrintTaskInfo( "Init", &time ); - for ( i=1; i <= rtems_scheduler_get_processor_maximum() *3; i++ ) { - - sprintf(ch, "%02" PRIu32, i ); + for ( i = 1; i <= rtems_scheduler_get_processor_maximum() * 3; i++ ) { + sprintf( ch, "%02" PRIu32, i ); status = rtems_task_create( - rtems_build_name( 'T', 'A', ch[0], ch[1] ), + rtems_build_name( 'T', 'A', ch[ 0 ], ch[ 1 ] ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, @@ -110,7 +106,7 @@ rtems_task Init( ); directive_failed( status, "task create" ); - status = rtems_task_start( id, Test_task, i+1 ); + status = rtems_task_start( id, Test_task, i + 1 ); directive_failed( status, "task start" ); } diff --git a/testsuites/smptests/smp08/system.h b/testsuites/smptests/smp08/system.h index 22cbf620d2..3508ed2081 100644 --- a/testsuites/smptests/smp08/system.h +++ b/testsuites/smptests/smp08/system.h @@ -31,13 +31,9 @@ /* functions */ -rtems_task Init( - rtems_task_argument argument -); +rtems_task Init( rtems_task_argument argument ); -rtems_task Test_task( - rtems_task_argument argument -); +rtems_task Test_task( rtems_task_argument argument ); /* configuration information */ @@ -46,25 +42,21 @@ rtems_task Test_task( #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_PROCESSORS 4 +#define CONFIGURE_MAXIMUM_PROCESSORS 4 -#define CONFIGURE_MAXIMUM_TASKS \ - (1 + (CONFIGURE_MAXIMUM_PROCESSORS*3) ) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + ( CONFIGURE_MAXIMUM_PROCESSORS * 3 ) ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT #define CONFIGURE_RTEMS_INIT_TASKS_TABLE -#define CONFIGURE_EXTRA_TASK_STACKS (3 * RTEMS_MINIMUM_STACK_SIZE) -#define CONFIGURE_MAXIMUM_SEMAPHORES 2 - +#define CONFIGURE_EXTRA_TASK_STACKS ( 3 * RTEMS_MINIMUM_STACK_SIZE ) +#define CONFIGURE_MAXIMUM_SEMAPHORES 2 + #include -TEST_EXTERN rtems_id Semaphore; /* synchronisation semaphore */ +TEST_EXTERN rtems_id Semaphore; /* synchronisation semaphore */ -void PrintTaskInfo( - const char *task_name, - rtems_time_of_day *_tb -); +void PrintTaskInfo( const char *task_name, rtems_time_of_day *_tb ); /* end of include file */ diff --git a/testsuites/smptests/smp08/tasks.c b/testsuites/smptests/smp08/tasks.c index 7445fa40a5..b1859b165e 100644 --- a/testsuites/smptests/smp08/tasks.c +++ b/testsuites/smptests/smp08/tasks.c @@ -32,17 +32,15 @@ #include "system.h" -rtems_task Test_task( - rtems_task_argument unused -) +rtems_task Test_task( rtems_task_argument unused ) { (void) unused; rtems_id tid; rtems_time_of_day time; - uint32_t task_index; + uint32_t task_index; rtems_status_code status; - char name[5]; + char name[ 5 ]; char *p; /* Get the task name */ @@ -52,7 +50,7 @@ rtems_task Test_task( status = rtems_task_ident( RTEMS_WHO_AM_I, RTEMS_SEARCH_ALL_NODES, &tid ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); task_index = task_number( tid ); - for ( ; ; ) { + for ( ;; ) { status = rtems_clock_get_tod( &time ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); if ( time.second >= 35 ) { @@ -66,7 +64,8 @@ rtems_task Test_task( PrintTaskInfo( p, &time ); status = rtems_task_wake_after( - task_index * 5 * rtems_clock_get_ticks_per_second() ); + task_index * 5 * rtems_clock_get_ticks_per_second() + ); rtems_test_assert( status == RTEMS_SUCCESSFUL ); } } diff --git a/testsuites/smptests/smp09/init.c b/testsuites/smptests/smp09/init.c index c3c19df0cc..55364b7807 100644 --- a/testsuites/smptests/smp09/init.c +++ b/testsuites/smptests/smp09/init.c @@ -38,45 +38,35 @@ const char rtems_test_name[] = "SMP 9"; volatile int killtime; -rtems_task Init( - rtems_task_argument argument -); +rtems_task Init( rtems_task_argument argument ); -rtems_task Test_task( - rtems_task_argument argument -); +rtems_task Test_task( rtems_task_argument argument ); -rtems_task Test_task( - rtems_task_argument argument -) +rtems_task Test_task( rtems_task_argument argument ) { (void) argument; - while (1) - ; + while ( 1 ); /* XXX something goes here */ } -rtems_task Init( - rtems_task_argument argument -) +rtems_task Init( rtems_task_argument argument ) { (void) argument; - uint32_t i; - char ch; - uint32_t cpu_num; - rtems_id id; - rtems_status_code status; + uint32_t i; + char ch; + uint32_t cpu_num; + rtems_id id; + rtems_status_code status; TEST_BEGIN(); locked_print_initialize(); - for ( killtime=0; killtime<1000000; killtime++ ) - ; - - for ( i=0; ibase.worker_count; - ++worker_index + worker_index = 0; worker_index < ctx->base.worker_count; ++worker_index ) { - unsigned long 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: %lu\n", - worker_index, - worker_value - ); + printf( "worker %zu value: %lu\n", worker_index, worker_value ); } - if (atomic) { - actual_value = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + if ( atomic ) { + actual_value = _Atomic_Load_ulong( + &ctx->atomic_value, + ATOMIC_ORDER_RELAXED + ); } else { actual_value = ctx->normal_value; } @@ -114,14 +111,13 @@ static void test_fini( actual_value ); - rtems_test_assert(expected_value == actual_value); + rtems_test_assert( expected_value == actual_value ); } - static rtems_interval test_atomic_add_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -129,36 +125,36 @@ static rtems_interval test_atomic_add_init( smpatomic01_context *ctx = (smpatomic01_context *) base; - _Atomic_Init_ulong(&ctx->atomic_value, 0); + _Atomic_Init_ulong( &ctx->atomic_value, 0 ); return test_duration(); } static void test_atomic_add_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; (void) active_workers; smpatomic01_context *ctx = (smpatomic01_context *) base; - unsigned long counter = 0; + unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { ++counter; - _Atomic_Fetch_add_ulong(&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; + ctx->per_worker_value[ worker_index ] = counter; } static void test_atomic_add_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -166,13 +162,13 @@ static void test_atomic_add_fini( smpatomic01_context *ctx = (smpatomic01_context *) base; - test_fini(ctx, "add", true); + test_fini( ctx, "add", true ); } static rtems_interval test_atomic_flag_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -180,7 +176,7 @@ static rtems_interval test_atomic_flag_init( smpatomic01_context *ctx = (smpatomic01_context *) base; - _Atomic_Flag_clear(&ctx->global_flag, ATOMIC_ORDER_RELEASE); + _Atomic_Flag_clear( &ctx->global_flag, ATOMIC_ORDER_RELEASE ); ctx->normal_value = 0; return test_duration(); @@ -188,49 +184,37 @@ static rtems_interval test_atomic_flag_init( static void test_atomic_flag_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; (void) active_workers; smpatomic01_context *ctx = (smpatomic01_context *) base; - unsigned long counter = 0; + unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - while (_Atomic_Flag_test_and_set(&ctx->global_flag, ATOMIC_ORDER_ACQUIRE)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + while ( + _Atomic_Flag_test_and_set( &ctx->global_flag, ATOMIC_ORDER_ACQUIRE ) + ) { /* Wait */ } ++counter; ++ctx->normal_value; - _Atomic_Flag_clear(&ctx->global_flag, ATOMIC_ORDER_RELEASE); + _Atomic_Flag_clear( &ctx->global_flag, ATOMIC_ORDER_RELEASE ); } - ctx->per_worker_value[worker_index] = counter; + ctx->per_worker_value[ worker_index ] = counter; } static void test_atomic_flag_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers - ) -{ - (void) arg; - (void) active_workers; - - smpatomic01_context *ctx = (smpatomic01_context *) base; - - test_fini(ctx, "flag", false); -} - -static rtems_interval test_atomic_sub_init( - rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -238,36 +222,50 @@ static rtems_interval test_atomic_sub_init( smpatomic01_context *ctx = (smpatomic01_context *) base; - _Atomic_Init_ulong(&ctx->atomic_value, 0); + test_fini( ctx, "flag", false ); +} + +static rtems_interval test_atomic_sub_init( + rtems_test_parallel_context *base, + void *arg, + size_t active_workers +) +{ + (void) arg; + (void) active_workers; + + smpatomic01_context *ctx = (smpatomic01_context *) base; + + _Atomic_Init_ulong( &ctx->atomic_value, 0 ); return test_duration(); } static void test_atomic_sub_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; (void) active_workers; smpatomic01_context *ctx = (smpatomic01_context *) base; - unsigned long counter = 0; + unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { --counter; - _Atomic_Fetch_sub_ulong(&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; + ctx->per_worker_value[ worker_index ] = counter; } static void test_atomic_sub_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -275,13 +273,13 @@ static void test_atomic_sub_fini( smpatomic01_context *ctx = (smpatomic01_context *) base; - test_fini(ctx, "sub", true); + test_fini( ctx, "sub", true ); } static rtems_interval test_atomic_compare_exchange_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -289,7 +287,7 @@ static rtems_interval test_atomic_compare_exchange_init( smpatomic01_context *ctx = (smpatomic01_context *) base; - _Atomic_Init_ulong(&ctx->atomic_value, 0); + _Atomic_Init_ulong( &ctx->atomic_value, 0 ); ctx->normal_value = 0; return test_duration(); @@ -297,18 +295,18 @@ static rtems_interval test_atomic_compare_exchange_init( static void test_atomic_compare_exchange_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; (void) active_workers; smpatomic01_context *ctx = (smpatomic01_context *) base; - unsigned long counter = 0; + unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { bool success; do { @@ -321,21 +319,21 @@ static void test_atomic_compare_exchange_body( ATOMIC_ORDER_ACQUIRE, ATOMIC_ORDER_RELAXED ); - } while (!success); + } while ( !success ); ++counter; ++ctx->normal_value; - _Atomic_Store_ulong(&ctx->atomic_value, 0, ATOMIC_ORDER_RELEASE); + _Atomic_Store_ulong( &ctx->atomic_value, 0, ATOMIC_ORDER_RELEASE ); } - ctx->per_worker_value[worker_index] = counter; + ctx->per_worker_value[ worker_index ] = counter; } static void test_atomic_compare_exchange_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -343,13 +341,13 @@ static void test_atomic_compare_exchange_fini( smpatomic01_context *ctx = (smpatomic01_context *) base; - test_fini(ctx, "compare exchange", false); + test_fini( ctx, "compare exchange", false ); } static rtems_interval test_atomic_or_and_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -357,29 +355,29 @@ static rtems_interval test_atomic_or_and_init( smpatomic01_context *ctx = (smpatomic01_context *) base; - _Atomic_Init_ulong(&ctx->atomic_value, 0); + _Atomic_Init_ulong( &ctx->atomic_value, 0 ); return test_duration(); } static void test_atomic_or_and_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; (void) active_workers; smpatomic01_context *ctx = (smpatomic01_context *) base; - unsigned long the_bit = 1UL << worker_index; - unsigned long current_bit = 0; + unsigned long the_bit = 1UL << worker_index; + unsigned long current_bit = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { unsigned long previous; - if (current_bit != 0) { + if ( current_bit != 0 ) { previous = _Atomic_Fetch_and_ulong( &ctx->atomic_value, ~the_bit, @@ -395,16 +393,16 @@ static void test_atomic_or_and_body( current_bit = the_bit; } - rtems_test_assert((previous & the_bit) != current_bit); + rtems_test_assert( ( previous & the_bit ) != current_bit ); } - ctx->per_worker_value[worker_index] = current_bit; + ctx->per_worker_value[ worker_index ] = current_bit; } static void test_atomic_or_and_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -412,13 +410,13 @@ static void test_atomic_or_and_fini( smpatomic01_context *ctx = (smpatomic01_context *) base; - test_fini(ctx, "or/and", true); + test_fini( ctx, "or/and", true ); } static rtems_interval test_atomic_fence_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -428,16 +426,16 @@ static rtems_interval test_atomic_fence_init( ctx->normal_value = 0; ctx->second_value = 0; - _Atomic_Fence(ATOMIC_ORDER_RELEASE); + _Atomic_Fence( ATOMIC_ORDER_RELEASE ); return test_duration(); } static void test_atomic_fence_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; @@ -445,33 +443,33 @@ static void test_atomic_fence_body( smpatomic01_context *ctx = (smpatomic01_context *) base; - if (rtems_test_parallel_is_master_worker(worker_index)) { + if ( rtems_test_parallel_is_master_worker( worker_index ) ) { unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { ++counter; ctx->normal_value = counter; - _Atomic_Fence(ATOMIC_ORDER_RELEASE); + _Atomic_Fence( ATOMIC_ORDER_RELEASE ); ctx->second_value = counter; } } else { - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { unsigned long n; unsigned long s; s = ctx->second_value; - _Atomic_Fence(ATOMIC_ORDER_ACQUIRE); + _Atomic_Fence( ATOMIC_ORDER_ACQUIRE ); n = ctx->normal_value; - rtems_test_assert(n - s < LONG_MAX); + rtems_test_assert( n - s < LONG_MAX ); } } } static void test_atomic_fence_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -489,66 +487,66 @@ static void test_atomic_fence_fini( static rtems_interval test_atomic_store_load_rmw_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; smpatomic01_context *ctx = (smpatomic01_context *) base; - size_t i; + size_t i; - _Atomic_Init_ulong(&ctx->atomic_value, 0); + _Atomic_Init_ulong( &ctx->atomic_value, 0 ); - _SMP_barrier_Control_initialize(&ctx->barrier); + _SMP_barrier_Control_initialize( &ctx->barrier ); - for (i = 0; i < active_workers; ++i) { - _SMP_barrier_State_initialize(&ctx->barrier_state[i]); + for ( i = 0; i < active_workers; ++i ) { + _SMP_barrier_State_initialize( &ctx->barrier_state[ i ] ); } return 0; } -static sbintime_t now(void) +static sbintime_t now( void ) { struct bintime bt; - rtems_bsd_binuptime(&bt); - return bttosbt(bt); + rtems_bsd_binuptime( &bt ); + return bttosbt( bt ); } static void test_atomic_store_load_rmw_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; smpatomic01_context *ctx = (smpatomic01_context *) base; - uint32_t cpu_self_index; - sbintime_t t; - int counter; + uint32_t cpu_self_index; + sbintime_t t; + int counter; - if (rtems_test_parallel_is_master_worker(worker_index)) { + if ( rtems_test_parallel_is_master_worker( worker_index ) ) { rtems_status_code sc; - sc = rtems_task_wake_after(1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); t = now(); - t += (MS_PER_TICK / 2) * SBT_1MS; + t += ( MS_PER_TICK / 2 ) * SBT_1MS; ctx->load_trigger_time = t; t += MS_PER_TICK * SBT_1MS; ctx->rmw_trigger_time = t; } - _Atomic_Fence(ATOMIC_ORDER_SEQ_CST); + _Atomic_Fence( ATOMIC_ORDER_SEQ_CST ); _SMP_barrier_Wait( &ctx->barrier, - &ctx->barrier_state[worker_index], + &ctx->barrier_state[ worker_index ], active_workers ); @@ -563,85 +561,87 @@ static void test_atomic_store_load_rmw_body( counter = 0; t = ctx->load_trigger_time; - while (now() < t) { + while ( now() < t ) { /* Wait */ } - if (cpu_self_index == 0) { - _Atomic_Store_ulong(&ctx->atomic_value, 1, ATOMIC_ORDER_RELEASE); - } else { - while (_Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_ACQUIRE) == 0) { - ++counter; - } - } - - ctx->load_change_time[cpu_self_index] = now(); - ctx->load_count[cpu_self_index] = counter; - - /* Read-modify-write test case */ - - if (cpu_self_index == 0) { - _Atomic_Store_ulong(&ctx->atomic_value, 0, ATOMIC_ORDER_RELAXED); - } - - counter = 0; - t = ctx->rmw_trigger_time; - - while (now() < t) { - /* Wait */ - } - - if (cpu_self_index == 0) { - _Atomic_Store_ulong(&ctx->atomic_value, 1, ATOMIC_ORDER_RELAXED); + if ( cpu_self_index == 0 ) { + _Atomic_Store_ulong( &ctx->atomic_value, 1, ATOMIC_ORDER_RELEASE ); } else { while ( - (_Atomic_Fetch_or_ulong(&ctx->atomic_value, 2, ATOMIC_ORDER_RELAXED) & 1) - == 0 + _Atomic_Load_ulong( &ctx->atomic_value, ATOMIC_ORDER_ACQUIRE ) == 0 ) { ++counter; } } - ctx->rmw_change_time[cpu_self_index] = now(); - ctx->rmw_count[cpu_self_index] = counter; + ctx->load_change_time[ cpu_self_index ] = now(); + ctx->load_count[ cpu_self_index ] = counter; + + /* Read-modify-write test case */ + + if ( cpu_self_index == 0 ) { + _Atomic_Store_ulong( &ctx->atomic_value, 0, ATOMIC_ORDER_RELAXED ); + } + + counter = 0; + t = ctx->rmw_trigger_time; + + while ( now() < t ) { + /* Wait */ + } + + if ( cpu_self_index == 0 ) { + _Atomic_Store_ulong( &ctx->atomic_value, 1, ATOMIC_ORDER_RELAXED ); + } else { + while ( + ( _Atomic_Fetch_or_ulong( &ctx->atomic_value, 2, ATOMIC_ORDER_RELAXED ) & + 1 ) == 0 + ) { + ++counter; + } + } + + ctx->rmw_change_time[ cpu_self_index ] = now(); + ctx->rmw_count[ cpu_self_index ] = counter; } static void test_atomic_store_load_rmw_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; smpatomic01_context *ctx = (smpatomic01_context *) base; - size_t i; - struct bintime bt; - struct timespec ts; + size_t i; + struct bintime bt; + struct timespec ts; - printf("=== atomic store release and load acquire test case ===\n"); + printf( "=== atomic store release and load acquire test case ===\n" ); - for (i = 0; i < active_workers; ++i) { - bt = sbttobt(ctx->load_change_time[i] - ctx->load_trigger_time); - bintime2timespec(&bt, &ts); + for ( i = 0; i < active_workers; ++i ) { + bt = sbttobt( ctx->load_change_time[ i ] - ctx->load_trigger_time ); + bintime2timespec( &bt, &ts ); printf( "processor %zu delta %lins, load count %i\n", i, ts.tv_nsec, - ctx->load_count[i] + ctx->load_count[ i ] ); } - printf("=== atomic read-modify-write test case ===\n"); + printf( "=== atomic read-modify-write test case ===\n" ); - for (i = 0; i < active_workers; ++i) { - bt = sbttobt(ctx->rmw_change_time[i] - ctx->rmw_trigger_time); - bintime2timespec(&bt, &ts); + for ( i = 0; i < active_workers; ++i ) { + bt = sbttobt( ctx->rmw_change_time[ i ] - ctx->rmw_trigger_time ); + bintime2timespec( &bt, &ts ); printf( "processor %zu delta %lins, read-modify-write count %i\n", i, ts.tv_nsec, - ctx->rmw_count[i] + ctx->rmw_count[ i ] ); } } @@ -654,8 +654,8 @@ static void test_atomic_store_load_rmw_fini( static rtems_interval test_seqlock_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -665,33 +665,36 @@ static rtems_interval test_seqlock_init( ctx->normal_value = 0; ctx->second_value = 0; - _Atomic_Store_ulong(&ctx->atomic_value, 0, ATOMIC_ORDER_RELEASE); + _Atomic_Store_ulong( &ctx->atomic_value, 0, ATOMIC_ORDER_RELEASE ); return test_duration(); } -static unsigned long seqlock_read(smpatomic01_context *ctx) +static unsigned long seqlock_read( smpatomic01_context *ctx ) { unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { unsigned long seq0; unsigned long seq1; unsigned long a; unsigned long b; do { - seq0 = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_ACQUIRE); + seq0 = _Atomic_Load_ulong( &ctx->atomic_value, ATOMIC_ORDER_ACQUIRE ); a = ctx->normal_value; b = ctx->second_value; - seq1 = - _Atomic_Fetch_add_ulong(&ctx->atomic_value, 0, ATOMIC_ORDER_RELEASE); - } while (seq0 != seq1 || seq0 % 2 != 0); + seq1 = _Atomic_Fetch_add_ulong( + &ctx->atomic_value, + 0, + ATOMIC_ORDER_RELEASE + ); + } while ( seq0 != seq1 || seq0 % 2 != 0 ); ++counter; - rtems_test_assert(a == b); + rtems_test_assert( a == b ); } return counter; @@ -699,9 +702,9 @@ static unsigned long seqlock_read(smpatomic01_context *ctx) static void test_single_writer_seqlock_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; @@ -709,8 +712,8 @@ static void test_single_writer_seqlock_body( (void) worker_index; smpatomic01_context *ctx = (smpatomic01_context *) base; - uint32_t cpu_self_index; - unsigned long counter; + uint32_t cpu_self_index; + unsigned long counter; /* * Use the physical processor index, to observe timing differences introduced @@ -718,58 +721,54 @@ static void test_single_writer_seqlock_body( */ cpu_self_index = rtems_scheduler_get_processor(); - if (cpu_self_index == 0) { + if ( cpu_self_index == 0 ) { counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { unsigned long seq; - seq = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); - _Atomic_Store_ulong(&ctx->atomic_value, seq + 1, ATOMIC_ORDER_RELAXED); + seq = _Atomic_Load_ulong( &ctx->atomic_value, ATOMIC_ORDER_RELAXED ); + _Atomic_Store_ulong( &ctx->atomic_value, seq + 1, ATOMIC_ORDER_RELAXED ); /* There is no atomic store with acquire/release semantics */ - _Atomic_Fence(ATOMIC_ORDER_ACQ_REL); + _Atomic_Fence( ATOMIC_ORDER_ACQ_REL ); ++counter; ctx->normal_value = counter; ctx->second_value = counter; - _Atomic_Store_ulong(&ctx->atomic_value, seq + 2, ATOMIC_ORDER_RELEASE); + _Atomic_Store_ulong( &ctx->atomic_value, seq + 2, ATOMIC_ORDER_RELEASE ); } } else { - counter = seqlock_read(ctx); + counter = seqlock_read( ctx ); } - ctx->per_worker_value[cpu_self_index] = counter; + ctx->per_worker_value[ cpu_self_index ] = counter; } static void test_single_writer_seqlock_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; smpatomic01_context *ctx = (smpatomic01_context *) base; - size_t i; + size_t i; - printf("=== single writer seqlock test case ===\n"); + printf( "=== single writer seqlock test case ===\n" ); - for (i = 0; i < active_workers; ++i) { - printf( - "processor %zu count %lu\n", - i, - ctx->per_worker_value[i] - ); + for ( i = 0; i < active_workers; ++i ) { + printf( "processor %zu count %lu\n", i, ctx->per_worker_value[ i ] ); } } static void test_multi_writer_seqlock_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; @@ -777,8 +776,8 @@ static void test_multi_writer_seqlock_body( (void) worker_index; smpatomic01_context *ctx = (smpatomic01_context *) base; - uint32_t cpu_self_index; - unsigned long counter; + uint32_t cpu_self_index; + unsigned long counter; /* * Use the physical processor index, to observe timing differences introduced @@ -786,117 +785,102 @@ static void test_multi_writer_seqlock_body( */ cpu_self_index = rtems_scheduler_get_processor(); - if (cpu_self_index % 2 == 0) { + if ( cpu_self_index % 2 == 0 ) { counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { unsigned long seq; do { - seq = _Atomic_Load_ulong(&ctx->atomic_value, ATOMIC_ORDER_RELAXED); + seq = _Atomic_Load_ulong( &ctx->atomic_value, ATOMIC_ORDER_RELAXED ); } while ( - seq % 2 != 0 - || !_Atomic_Compare_exchange_ulong( - &ctx->atomic_value, - &seq, - seq + 1, - ATOMIC_ORDER_ACQ_REL, - ATOMIC_ORDER_RELAXED - ) + seq % 2 != 0 || !_Atomic_Compare_exchange_ulong( + &ctx->atomic_value, + &seq, + seq + 1, + ATOMIC_ORDER_ACQ_REL, + ATOMIC_ORDER_RELAXED + ) ); ++counter; ctx->normal_value = counter; ctx->second_value = counter; - _Atomic_Store_ulong(&ctx->atomic_value, seq + 2, ATOMIC_ORDER_RELEASE); + _Atomic_Store_ulong( &ctx->atomic_value, seq + 2, ATOMIC_ORDER_RELEASE ); } } else { - counter = seqlock_read(ctx); + counter = seqlock_read( ctx ); } - ctx->per_worker_value[cpu_self_index] = counter; + ctx->per_worker_value[ cpu_self_index ] = counter; } static void test_multi_writer_seqlock_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; smpatomic01_context *ctx = (smpatomic01_context *) base; - size_t i; + size_t i; - printf("=== multi writer seqlock test case ===\n"); + printf( "=== multi writer seqlock test case ===\n" ); - for (i = 0; i < active_workers; ++i) { - printf( - "processor %zu count %lu\n", - i, - ctx->per_worker_value[i] - ); + for ( i = 0; i < active_workers; ++i ) { + printf( "processor %zu count %lu\n", i, ctx->per_worker_value[ i ] ); } } static const rtems_test_parallel_job test_jobs[] = { - { - .init = test_atomic_add_init, + { .init = test_atomic_add_init, .body = test_atomic_add_body, - .fini = test_atomic_add_fini - }, { - .init = test_atomic_flag_init, + .fini = test_atomic_add_fini }, + { .init = test_atomic_flag_init, .body = test_atomic_flag_body, - .fini = test_atomic_flag_fini - }, { - .init = test_atomic_sub_init, + .fini = test_atomic_flag_fini }, + { .init = test_atomic_sub_init, .body = test_atomic_sub_body, - .fini = test_atomic_sub_fini - }, { - .init = test_atomic_compare_exchange_init, + .fini = test_atomic_sub_fini }, + { .init = test_atomic_compare_exchange_init, .body = test_atomic_compare_exchange_body, - .fini = test_atomic_compare_exchange_fini - }, { - .init = test_atomic_or_and_init, + .fini = test_atomic_compare_exchange_fini }, + { .init = test_atomic_or_and_init, .body = test_atomic_or_and_body, - .fini = test_atomic_or_and_fini - }, { - .init = test_atomic_fence_init, + .fini = test_atomic_or_and_fini }, + { .init = test_atomic_fence_init, .body = test_atomic_fence_body, - .fini = test_atomic_fence_fini - }, { - .init = test_atomic_store_load_rmw_init, + .fini = test_atomic_fence_fini }, + { .init = test_atomic_store_load_rmw_init, .body = test_atomic_store_load_rmw_body, - .fini = test_atomic_store_load_rmw_fini - }, { - .init = test_seqlock_init, + .fini = test_atomic_store_load_rmw_fini }, + { .init = test_seqlock_init, .body = test_single_writer_seqlock_body, - .fini = test_single_writer_seqlock_fini - }, { - .init = test_seqlock_init, + .fini = test_single_writer_seqlock_fini }, + { .init = test_seqlock_init, .body = test_multi_writer_seqlock_body, - .fini = test_multi_writer_seqlock_fini - } + .fini = test_multi_writer_seqlock_fini } }; static void setup_worker( rtems_test_parallel_context *base, - size_t worker_index, - rtems_id worker_id + size_t worker_index, + rtems_id worker_id ) { (void) base; (void) worker_index; - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority prio; - sc = rtems_task_set_priority(worker_id, WORKER_PRIORITY, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( worker_id, WORKER_PRIORITY, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -907,18 +891,18 @@ static void Init(rtems_task_argument arg) rtems_test_parallel( &ctx->base, setup_worker, - &test_jobs[0], - RTEMS_ARRAY_SIZE(test_jobs) + &test_jobs[ 0 ], + RTEMS_ARRAY_SIZE( test_jobs ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MICROSECONDS_PER_TICK (MS_PER_TICK * 1000) +#define CONFIGURE_MICROSECONDS_PER_TICK ( MS_PER_TICK * 1000 ) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT @@ -926,9 +910,9 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_TIMERS 1 -#define CONFIGURE_INIT_TASK_PRIORITY MASTER_PRIORITY +#define CONFIGURE_INIT_TASK_PRIORITY MASTER_PRIORITY #define CONFIGURE_INIT_TASK_INITIAL_MODES RTEMS_DEFAULT_MODES -#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES +#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpcache01/init.c b/testsuites/smptests/smpcache01/init.c index 3bf8b003b3..510468cf23 100644 --- a/testsuites/smptests/smpcache01/init.c +++ b/testsuites/smptests/smpcache01/init.c @@ -48,8 +48,8 @@ const char rtems_test_name[] = "SMPCACHE 1"; typedef struct { SMP_barrier_Control barrier; - bool do_longjmp[CPU_COUNT]; - jmp_buf instruction_invalidate_return_context[CPU_COUNT]; + bool do_longjmp[ CPU_COUNT ]; + jmp_buf instruction_invalidate_return_context[ CPU_COUNT ]; } test_context; static test_context ctx = { @@ -72,14 +72,16 @@ static void test_cache_invalidate_multiple_instruction_lines( void ) { uint32_t self = rtems_scheduler_get_processor(); - ctx.do_longjmp[self] = true; + ctx.do_longjmp[ self ] = true; - if (setjmp(ctx.instruction_invalidate_return_context[self]) == 0) { - rtems_cache_invalidate_multiple_instruction_lines( &function_to_flush, - 4 /* arbitrary size */ ); + if ( setjmp( ctx.instruction_invalidate_return_context[ self ] ) == 0 ) { + rtems_cache_invalidate_multiple_instruction_lines( + &function_to_flush, + 4 /* arbitrary size */ + ); } - ctx.do_longjmp[self] = false; + ctx.do_longjmp[ self ] = false; } static void barrier( SMP_barrier_State *bs ) @@ -100,7 +102,7 @@ static void call_tests( SMP_barrier_State *bs ) { size_t i; - for (i = 0; i < RTEMS_ARRAY_SIZE( test_cases ); ++i) { + for ( i = 0; i < RTEMS_ARRAY_SIZE( test_cases ); ++i ) { barrier( bs ); ( *test_cases[ i ] )(); barrier( bs ); @@ -111,7 +113,7 @@ static void call_tests_isr_disabled( SMP_barrier_State *bs ) { size_t i; - for (i = 0; i < RTEMS_ARRAY_SIZE( test_cases ); ++i) { + for ( i = 0; i < RTEMS_ARRAY_SIZE( test_cases ); ++i ) { ISR_Level isr_level; _ISR_Local_disable( isr_level ); @@ -126,7 +128,7 @@ static void call_tests_with_thread_dispatch_disabled( SMP_barrier_State *bs ) { size_t i; - for (i = 0; i < RTEMS_ARRAY_SIZE( test_cases ); ++i) { + for ( i = 0; i < RTEMS_ARRAY_SIZE( test_cases ); ++i ) { Per_CPU_Control *cpu_self; cpu_self = _Thread_Dispatch_disable(); @@ -137,10 +139,11 @@ static void call_tests_with_thread_dispatch_disabled( SMP_barrier_State *bs ) } } -static void cmlog( const char* str ) +static void cmlog( const char *str ) { - if ( rtems_scheduler_get_processor() == 0 ) + if ( rtems_scheduler_get_processor() == 0 ) { printf( "%s", str ); + } } static void all_tests( void ) @@ -150,7 +153,7 @@ static void all_tests( void ) /* Call test cases */ cmlog( "Calling test cases. " ); call_tests( &bs ); - cmlog( "Done!\n"); + cmlog( "Done!\n" ); /* Call test cases with ISR disabled */ cmlog( "Calling test cases with ISR disabled. " ); @@ -158,9 +161,9 @@ static void all_tests( void ) cmlog( "Done!\n" ); /* Call test cases with thread dispatch disabled */ - cmlog( "Calling test cases with thread_dispatch_disabled. "); + cmlog( "Calling test cases with thread_dispatch_disabled. " ); call_tests_with_thread_dispatch_disabled( &bs ); - cmlog( "Done!\n"); + cmlog( "Done!\n" ); /* Done. Free up memory. */ _SMP_barrier_Wait( @@ -170,7 +173,7 @@ static void all_tests( void ) ); } -static void worker_task(rtems_task_argument arg) +static void worker_task( rtems_task_argument arg ) { (void) arg; @@ -178,21 +181,21 @@ static void worker_task(rtems_task_argument arg) all_tests(); - sc = rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void test_smp_cache_manager( void ) { rtems_status_code sc; - size_t worker_index; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + size_t worker_index; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - for (worker_index = 1; worker_index < cpu_count; ++worker_index) { + for ( worker_index = 1; worker_index < cpu_count; ++worker_index ) { rtems_id worker_id; sc = rtems_task_create( - rtems_build_name('W', 'R', 'K', '0'+worker_index), + rtems_build_name( 'W', 'R', 'K', '0' + worker_index ), WORKER_PRIORITY, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, @@ -208,8 +211,7 @@ static void test_smp_cache_manager( void ) all_tests(); } - -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -218,13 +220,13 @@ static void Init(rtems_task_argument arg) test_smp_cache_manager(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code error + bool always_set_to_false, + rtems_fatal_code error ) { (void) always_set_to_false; @@ -232,9 +234,9 @@ static void fatal_extension( uint32_t self = rtems_scheduler_get_processor(); - if (source == RTEMS_FATAL_SOURCE_EXCEPTION && ctx.do_longjmp[self]) { - _ISR_Set_level(0); - longjmp(ctx.instruction_invalidate_return_context[self], 1); + if ( source == RTEMS_FATAL_SOURCE_EXCEPTION && ctx.do_longjmp[ self ] ) { + _ISR_Set_level( 0 ); + longjmp( ctx.instruction_invalidate_return_context[ self ], 1 ); } } @@ -248,8 +250,7 @@ static void fatal_extension( #define CONFIGURE_MAXIMUM_TIMERS 1 #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_RTEMS_INIT_TASKS_TABLE diff --git a/testsuites/smptests/smpcapture01/init.c b/testsuites/smptests/smpcapture01/init.c index 3b34e0d8bd..9ff446f0f0 100644 --- a/testsuites/smptests/smpcapture01/init.c +++ b/testsuites/smptests/smpcapture01/init.c @@ -64,58 +64,60 @@ struct task_data_t { int migrate_cpu; }; -static struct task_data_t task_data[TASK_COUNT] = { - {0x0, {{0xc}}, 7, false, 3, -1, 2}, - {0x0, {{0xf}}, 8, false, 2, -1, -1}, - {0x0, {{0x3}}, 5, false, 1, -1, 0}, - {0x0, {{0x9}}, 6, false, 0, -1, 3}, - {0x0, {{0x2}}, 9, false, -1, -1, 1} +static struct task_data_t task_data[ TASK_COUNT ] = { + { 0x0, { { 0xc } }, 7, false, 3, -1, 2 }, + { 0x0, { { 0xf } }, 8, false, 2, -1, -1 }, + { 0x0, { { 0x3 } }, 5, false, 1, -1, 0 }, + { 0x0, { { 0x9 } }, 6, false, 0, -1, 3 }, + { 0x0, { { 0x2 } }, 9, false, -1, -1, 1 } }; -rtems_id task_sem; +rtems_id task_sem; /* * Spin loop to allow tasks to delay without yeilding the * processor. */ -static void test_delay(rtems_interval ticks) +static void test_delay( rtems_interval ticks ) { rtems_interval start, stop; start = rtems_clock_get_ticks_since_boot(); do { stop = rtems_clock_get_ticks_since_boot(); - } while ( (stop - start) < ticks ); + } while ( ( stop - start ) < ticks ); } -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; - rtems_status_code sc; + rtems_status_code sc; - while (true) { - sc = rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0); - if (sc == RTEMS_SUCCESSFUL) { - task_data[arg].ran = true; - task_data[arg].actual_cpu = rtems_scheduler_get_processor(); - rtems_semaphore_release(task_sem); - test_delay(1); + while ( true ) { + sc = rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ); + if ( sc == RTEMS_SUCCESSFUL ) { + task_data[ arg ].ran = true; + task_data[ arg ].actual_cpu = rtems_scheduler_get_processor(); + rtems_semaphore_release( task_sem ); + test_delay( 1 ); } } } -static void set_init_task(void) +static void set_init_task( void ) { - while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL ); + while ( + rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ) != RTEMS_SUCCESSFUL + ); /* Set Init task data */ - task_data[0].ran = true; - task_data[0].actual_cpu = rtems_scheduler_get_processor(); + task_data[ 0 ].ran = true; + task_data[ 0 ].actual_cpu = rtems_scheduler_get_processor(); - rtems_semaphore_release(task_sem); + rtems_semaphore_release( task_sem ); } -static void test(void) +static void test( void ) { rtems_status_code sc; rtems_task_argument i; @@ -125,61 +127,56 @@ static void test(void) /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); - if (cpu_count != 4) { - printf("Test requires a minimum of 4 cores\n"); + if ( cpu_count != 4 ) { + printf( "Test requires a minimum of 4 cores\n" ); return; } - size = sizeof(cpu_set_t); - task_data[0].id = rtems_task_self(); + size = sizeof( cpu_set_t ); + task_data[ 0 ].id = rtems_task_self(); sc = rtems_semaphore_create( - rtems_build_name('S', 'E', 'M', '0'), - 1, /* initial count = 1 */ - RTEMS_LOCAL | - RTEMS_SIMPLE_BINARY_SEMAPHORE | - RTEMS_NO_INHERIT_PRIORITY | - RTEMS_NO_PRIORITY_CEILING | - RTEMS_FIFO, + rtems_build_name( 'S', 'E', 'M', '0' ), + 1, /* initial count = 1 */ + RTEMS_LOCAL | RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY | + RTEMS_NO_PRIORITY_CEILING | RTEMS_FIFO, 0, &task_sem ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_set_affinity( task_data[ 0 ].id, size, - &task_data[0].cpuset + &task_data[ 0 ].cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Create and start tasks on each cpu with the appropriate affinity. */ - for (i = 1; i < TASK_COUNT; i++) { + for ( i = 1; i < TASK_COUNT; i++ ) { + sc = rtems_task_create( + rtems_build_name( 'T', 'A', '0', '0' + i ), + task_data[ i ].priority, + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_MODES, + RTEMS_DEFAULT_ATTRIBUTES, + &task_data[ i ].id + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_create( - rtems_build_name('T', 'A', '0', '0'+i), - task_data[ i ].priority, - RTEMS_MINIMUM_STACK_SIZE, - RTEMS_DEFAULT_MODES, - RTEMS_DEFAULT_ATTRIBUTES, - &task_data[ i ].id - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( + task_data[ i ].id, + size, + &task_data[ i ].cpuset + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_affinity( - task_data[ i ].id, - size, - &task_data[i].cpuset - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - - sc = rtems_task_start( task_data[ i ].id, task, i ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_data[ i ].id, task, i ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } /* spin for 10 ticks */ - test_delay(10); + test_delay( 10 ); set_init_task(); @@ -190,50 +187,53 @@ static void test(void) task_data[ i ].priority, &priority ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - test_delay(10); + test_delay( 10 ); - while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL ); - for (i = 0; i < TASK_COUNT; i++) { + while ( + rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ) != RTEMS_SUCCESSFUL + ); + for ( i = 0; i < TASK_COUNT; i++ ) { task_data[ i ].expected_cpu = task_data[ i ].migrate_cpu; task_data[ i ].actual_cpu = -1; task_data[ i ].ran = false; } - rtems_semaphore_release(task_sem); - test_delay(10); + rtems_semaphore_release( task_sem ); + test_delay( 10 ); set_init_task(); - for (i = 1; i < TASK_COUNT; i++) { + for ( i = 1; i < TASK_COUNT; i++ ) { sc = rtems_task_delete( task_data[ i ].id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - test_delay(25); + test_delay( 25 ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - rtems_status_code sc; - rtems_name to_name = rtems_build_name('I', 'D', 'L', 'E');; - uint32_t i; + rtems_status_code sc; + rtems_name to_name = rtems_build_name( 'I', 'D', 'L', 'E' ); + ; + uint32_t i; TEST_BEGIN(); - sc = rtems_capture_open (5000, NULL); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_open( 5000, NULL ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_capture_watch_ceiling (0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_watch_ceiling( 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_capture_watch_floor (20); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_watch_floor( 20 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_capture_watch_global (true); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_watch_global( true ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_capture_set_trigger ( + sc = rtems_capture_set_trigger( 0, 0, to_name, @@ -241,11 +241,11 @@ static void Init(rtems_task_argument arg) rtems_capture_from_any, rtems_capture_switch ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 1; i < TASK_COUNT; i++) { - to_name = rtems_build_name('T', 'A', '0', '0'+i); - sc = rtems_capture_set_trigger ( + for ( i = 1; i < TASK_COUNT; i++ ) { + to_name = rtems_build_name( 'T', 'A', '0', '0' + i ); + sc = rtems_capture_set_trigger( 0, 0, to_name, @@ -255,20 +255,20 @@ static void Init(rtems_task_argument arg) ); } - sc = rtems_capture_set_control (true); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_set_control( true ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); test(); - sc = rtems_capture_set_control (false); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_set_control( false ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_capture_print_trace_records ( 22, false ); - rtems_capture_print_trace_records ( 22, false ); - rtems_capture_print_trace_records ( 22, false ); + rtems_capture_print_trace_records( 22, false ); + rtems_capture_print_trace_records( 22, false ); + rtems_capture_print_trace_records( 22, false ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -282,14 +282,15 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_RTEMS_INIT_TASKS_TABLE -#define CONFIGURE_INIT_TASK_PRIORITY 7 +#define CONFIGURE_INIT_TASK_PRIORITY 7 #define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT -#define TASK_ALLOCATION_SIZE (5) -#define CONFIGURE_MAXIMUM_TASKS rtems_resource_unlimited(TASK_ALLOCATION_SIZE) -#define CONFIGURE_EXTRA_TASK_STACKS (75 * RTEMS_MINIMUM_STACK_SIZE) +#define TASK_ALLOCATION_SIZE ( 5 ) +#define CONFIGURE_MAXIMUM_TASKS \ + rtems_resource_unlimited( TASK_ALLOCATION_SIZE ) +#define CONFIGURE_EXTRA_TASK_STACKS ( 75 * RTEMS_MINIMUM_STACK_SIZE ) -#define CONFIGURE_MAXIMUM_USER_EXTENSIONS (5) +#define CONFIGURE_MAXIMUM_USER_EXTENSIONS ( 5 ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpcapture02/init.c b/testsuites/smptests/smpcapture02/init.c index 775e488945..9b927da523 100644 --- a/testsuites/smptests/smpcapture02/init.c +++ b/testsuites/smptests/smpcapture02/init.c @@ -47,35 +47,31 @@ const char rtems_test_name[] = "SMPCAPTURE 2"; -#define MAX_CPUS 4 -#define TASKS_PER_CPU 5 -#define ITERATIONS 3 -#define TASK_PRIO 30 -#define CLOCK_TICKS 100 +#define MAX_CPUS 4 +#define TASKS_PER_CPU 5 +#define ITERATIONS 3 +#define TASK_PRIO 30 +#define CLOCK_TICKS 100 -typedef struct { +typedef struct { rtems_id id; rtems_id task_sem; rtems_id prev_sem; } per_cpu_task_data; typedef struct { - bool found; - const char *info; - rtems_option options; + bool found; + const char *info; + rtems_option options; rtems_interrupt_handler handler; - void *arg; + void *arg; } clock_interrupt_handler; -static rtems_id finished_sem; -static per_cpu_task_data task_data[ TASKS_PER_CPU * TASKS_PER_CPU ]; +static rtems_id finished_sem; +static per_cpu_task_data task_data[ TASKS_PER_CPU * TASKS_PER_CPU ]; static rtems_interrupt_handler org_clock_handler; -typedef enum { - enter_add_number, - exit_add_number, - clock_tick -} cap_rec_type; +typedef enum { enter_add_number, exit_add_number, clock_tick } cap_rec_type; /* * These records define the data stored in the capture trace. @@ -97,14 +93,14 @@ typedef struct { /* * Create a printable set of char's from a name. */ -#define PNAME(n) \ - (char) (n >> 24) & 0xff, (char) (n >> 16) & 0xff, \ - (char) (n >> 8) & 0xff, (char) (n >> 0) & 0xff +#define PNAME( n ) \ + (char) ( n >> 24 ) & 0xff, (char) ( n >> 16 ) & 0xff, \ + (char) ( n >> 8 ) & 0xff, (char) ( n >> 0 ) & 0xff /* * The function that we want to trace */ -static uint32_t add_number(uint32_t a, uint32_t b) +static uint32_t add_number( uint32_t a, uint32_t b ) { return a + b; } @@ -113,45 +109,49 @@ static uint32_t add_number(uint32_t a, uint32_t b) * The wrapper for the function we want to trace. Records * input arguments and the result to the capture trace. */ -static uint32_t add_number_wrapper(uint32_t a, uint32_t b) +static uint32_t add_number_wrapper( uint32_t a, uint32_t b ) { rtems_capture_record_lock_context lock; - enter_add_number_record enter_rec; - exit_add_number_record exit_rec; - cap_rec_type id; - uint32_t res; - void* rec; + enter_add_number_record enter_rec; + exit_add_number_record exit_rec; + cap_rec_type id; + uint32_t res; + void *rec; id = enter_add_number; enter_rec.a = a; enter_rec.b = b; - rec = rtems_capture_record_open(_Thread_Get_executing(), - RTEMS_CAPTURE_TIMESTAMP, - sizeof(id) + sizeof(enter_rec), - &lock); - rtems_test_assert(rec != NULL); - rec = rtems_capture_record_append(rec, &id, sizeof(id)); - rtems_test_assert(rec != NULL); - rec = rtems_capture_record_append(rec, &enter_rec, sizeof(enter_rec)); - rtems_test_assert(rec != NULL); - rtems_capture_record_close(&lock); + rec = rtems_capture_record_open( + _Thread_Get_executing(), + RTEMS_CAPTURE_TIMESTAMP, + sizeof( id ) + sizeof( enter_rec ), + &lock + ); + rtems_test_assert( rec != NULL ); + rec = rtems_capture_record_append( rec, &id, sizeof( id ) ); + rtems_test_assert( rec != NULL ); + rec = rtems_capture_record_append( rec, &enter_rec, sizeof( enter_rec ) ); + rtems_test_assert( rec != NULL ); + rtems_capture_record_close( &lock ); - res = add_number(a, b); + res = add_number( a, b ); id = exit_add_number; exit_rec.res = res; - rec = rtems_capture_record_open(_Thread_Get_executing(), - RTEMS_CAPTURE_TIMESTAMP, - sizeof(id) + sizeof(exit_rec), - &lock); - rtems_test_assert(rec != NULL); - rec = rtems_capture_record_append(rec, &id, sizeof(id)); - rtems_test_assert(rec != NULL); - rec = rtems_capture_record_append(rec, &exit_rec, sizeof(exit_rec)); - rtems_test_assert(rec != NULL); - rtems_capture_record_close(&lock); + rec = rtems_capture_record_open( + _Thread_Get_executing(), + RTEMS_CAPTURE_TIMESTAMP, + sizeof( id ) + sizeof( exit_rec ), + &lock + ); + rtems_test_assert( rec != NULL ); + rec = rtems_capture_record_append( rec, &id, sizeof( id ) ); + rtems_test_assert( rec != NULL ); + rec = rtems_capture_record_append( rec, &exit_rec, sizeof( exit_rec ) ); + rtems_test_assert( rec != NULL ); + rtems_capture_record_close( &lock ); return res; } @@ -159,50 +159,53 @@ static uint32_t add_number_wrapper(uint32_t a, uint32_t b) /* * Task that calls the function we want to trace */ -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; rtems_status_code sc; - uint32_t i; + uint32_t i; for ( i = 0; i < ITERATIONS; i++ ) { /* * Wait until the previous task in the task chain * has completed its operation. */ - sc = rtems_semaphore_obtain(task_data[arg].prev_sem, 0, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( task_data[ arg ].prev_sem, 0, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - add_number_wrapper(arg, i); + add_number_wrapper( arg, i ); /* * Signal the next task in the chain to continue */ - sc = rtems_semaphore_release(task_data[arg].task_sem); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( task_data[ arg ].task_sem ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } /* Signal the main task that this task has finished */ - sc = rtems_semaphore_release(finished_sem); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_task_suspend(rtems_task_self()); + sc = rtems_semaphore_release( finished_sem ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_task_suspend( rtems_task_self() ); } -static void test(uint32_t cpu_count) +static void test( uint32_t cpu_count ) { - rtems_status_code sc; - uint32_t t; - uint32_t c; + rtems_status_code sc; + uint32_t t; + uint32_t c; rtems_task_argument idx; - cpu_set_t cpu_set; + cpu_set_t cpu_set; /* Semaphore to signal end of test */ - sc = rtems_semaphore_create(rtems_build_name('D', 'o', 'n', 'e'), 0, - RTEMS_LOCAL | - RTEMS_NO_INHERIT_PRIORITY | - RTEMS_NO_PRIORITY_CEILING | - RTEMS_FIFO, 0, &finished_sem); + sc = rtems_semaphore_create( + rtems_build_name( 'D', 'o', 'n', 'e' ), + 0, + RTEMS_LOCAL | RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | + RTEMS_FIFO, + 0, + &finished_sem + ); /* * Create a set of tasks per CPU. Chain them together using @@ -213,80 +216,91 @@ static void test(uint32_t cpu_count) for ( t = 0; t < TASKS_PER_CPU; t++ ) { idx = c * TASKS_PER_CPU + t; - sc = rtems_task_create(rtems_build_name('T', 'A', '0' + c, '0' + t), - TASK_PRIO, - RTEMS_MINIMUM_STACK_SIZE, - RTEMS_DEFAULT_MODES, - RTEMS_DEFAULT_ATTRIBUTES, - &task_data[idx].id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_create( + rtems_build_name( 'T', 'A', '0' + c, '0' + t ), + TASK_PRIO, + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_MODES, + RTEMS_DEFAULT_ATTRIBUTES, + &task_data[ idx ].id + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_create(rtems_build_name('S', 'E', '0' + c, '0' + t), - 0, - RTEMS_LOCAL | - RTEMS_SIMPLE_BINARY_SEMAPHORE | - RTEMS_NO_INHERIT_PRIORITY | - RTEMS_NO_PRIORITY_CEILING | - RTEMS_FIFO, 0, &task_data[idx].task_sem); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_create( + rtems_build_name( 'S', 'E', '0' + c, '0' + t ), + 0, + RTEMS_LOCAL | RTEMS_SIMPLE_BINARY_SEMAPHORE | + RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_FIFO, + 0, + &task_data[ idx ].task_sem + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - task_data[(idx + 1) % (cpu_count * TASKS_PER_CPU)].prev_sem = - task_data[idx].task_sem; + task_data[ ( idx + 1 ) % ( cpu_count * TASKS_PER_CPU ) ].prev_sem = + task_data[ idx ].task_sem; - CPU_ZERO_S(sizeof(cpu_set_t), &cpu_set); - CPU_SET_S(c, sizeof(cpu_set_t), &cpu_set); + CPU_ZERO_S( sizeof( cpu_set_t ), &cpu_set ); + CPU_SET_S( c, sizeof( cpu_set_t ), &cpu_set ); - sc = rtems_task_set_affinity(task_data[idx].id, sizeof(cpu_set_t), - &cpu_set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( + task_data[ idx ].id, + sizeof( cpu_set_t ), + &cpu_set + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } /* Start the tasks */ for ( idx = 0; idx < cpu_count * TASKS_PER_CPU; idx++ ) { - sc = rtems_task_start(task_data[idx].id, task, idx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_data[ idx ].id, task, idx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } /* Start chain */ - sc = rtems_semaphore_release(task_data[0].task_sem); + sc = rtems_semaphore_release( task_data[ 0 ].task_sem ); /* Wait until chain has completed */ for ( idx = 0; idx < cpu_count * TASKS_PER_CPU; idx++ ) { - rtems_semaphore_obtain(finished_sem, 0, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_semaphore_obtain( finished_sem, 0, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - } /* Writes an entry in the capture trace for every clock tick */ -static void clock_tick_wrapper(void *arg) +static void clock_tick_wrapper( void *arg ) { rtems_capture_record_lock_context lock; - cap_rec_type id = clock_tick; - Thread_Control* tcb = _Thread_Get_executing(); - void* rec; + cap_rec_type id = clock_tick; + Thread_Control *tcb = _Thread_Get_executing(); + void *rec; - rec = rtems_capture_record_open(tcb, - RTEMS_CAPTURE_TIMESTAMP, - sizeof(id), - &lock); - rtems_test_assert(rec != NULL); - rec = rtems_capture_record_append(rec, &id, sizeof(id)); - rtems_test_assert(rec != NULL); - rtems_capture_record_close(&lock); + rec = rtems_capture_record_open( + tcb, + RTEMS_CAPTURE_TIMESTAMP, + sizeof( id ), + &lock + ); + rtems_test_assert( rec != NULL ); + rec = rtems_capture_record_append( rec, &id, sizeof( id ) ); + rtems_test_assert( rec != NULL ); + rtems_capture_record_close( &lock ); - org_clock_handler(arg); + org_clock_handler( arg ); } /* Tries to locate the clock interrupt handler by looking * for a handler with the name "Clock" or "clock" */ static void locate_clock_interrupt_handler( - void *arg, const char *info, rtems_option options, - rtems_interrupt_handler handler, void *handler_arg) + void *arg, + const char *info, + rtems_option options, + rtems_interrupt_handler handler, + void *handler_arg +) { - clock_interrupt_handler *cih = (clock_interrupt_handler*)arg; - if ( !strcmp(info, "clock") || !strcmp(info, "Clock") ) { + clock_interrupt_handler *cih = (clock_interrupt_handler *) arg; + if ( !strcmp( info, "clock" ) || !strcmp( info, "Clock" ) ) { cih->info = info; cih->options = options; cih->handler = handler; @@ -295,27 +309,27 @@ static void locate_clock_interrupt_handler( } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - rtems_status_code sc; - uint32_t i; - uint32_t cpu; - uint32_t cpu_count; - uint32_t enter_count; - uint32_t exit_count; - uint32_t clock_tick_count; - uint32_t res_should_be; - rtems_vector_number vec; - size_t read; - const void *recs; - cap_rec_type id; - rtems_capture_record rec; - rtems_capture_record prev_rec; + rtems_status_code sc; + uint32_t i; + uint32_t cpu; + uint32_t cpu_count; + uint32_t enter_count; + uint32_t exit_count; + uint32_t clock_tick_count; + uint32_t res_should_be; + rtems_vector_number vec; + size_t read; + const void *recs; + cap_rec_type id; + rtems_capture_record rec; + rtems_capture_record prev_rec; enter_add_number_record enter_rec; - exit_add_number_record exit_rec; - clock_interrupt_handler cih = {.found = 0}; + exit_add_number_record exit_rec; + clock_interrupt_handler cih = { .found = 0 }; #ifdef VERBOSE rtems_name name; @@ -326,23 +340,28 @@ static void Init(rtems_task_argument arg) /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); - sc = rtems_capture_open(50000, NULL); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_open( 50000, NULL ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_capture_watch_global(true); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_watch_global( true ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_capture_set_control(true); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_set_control( true ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Run main test */ - test(cpu_count); + test( cpu_count ); /* Try to find the clock interrupt handler */ for ( vec = 0; vec < BSP_INTERRUPT_VECTOR_COUNT; vec++ ) { - rtems_interrupt_handler_iterate(vec, locate_clock_interrupt_handler, &cih); - if ( cih.found ) + rtems_interrupt_handler_iterate( + vec, + locate_clock_interrupt_handler, + &cih + ); + if ( cih.found ) { break; + } } /* If we find the clock interrupt handler we replace it with @@ -350,101 +369,123 @@ static void Init(rtems_task_argument arg) */ if ( cih.found ) { #ifdef VERBOSE - printf("Found a clock handler\n"); + printf( "Found a clock handler\n" ); #endif org_clock_handler = cih.handler; - rtems_interrupt_handler_install(vec, cih.info, - cih.options | RTEMS_INTERRUPT_REPLACE, clock_tick_wrapper, cih.arg); + rtems_interrupt_handler_install( + vec, + cih.info, + cih.options | RTEMS_INTERRUPT_REPLACE, + clock_tick_wrapper, + cih.arg + ); - rtems_task_wake_after(CLOCK_TICKS); + rtems_task_wake_after( CLOCK_TICKS ); } /* Disable capturing */ - sc = rtems_capture_set_control(false); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_capture_set_control( false ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); clock_tick_count = 0; /* Read out the trace from all processors */ for ( cpu = 0; cpu < cpu_count; cpu++ ) { - sc = rtems_capture_read(cpu, &read, &recs); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(recs != NULL); + sc = rtems_capture_read( cpu, &read, &recs ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( recs != NULL ); - memset(&rec, 0, sizeof(rec)); + memset( &rec, 0, sizeof( rec ) ); prev_rec = rec; enter_count = 0; exit_count = 0; res_should_be = 0; for ( i = 0; i < read; i++ ) { - - recs = rtems_capture_record_extract(recs, &rec, sizeof(rec)); - rtems_test_assert(recs != NULL); + recs = rtems_capture_record_extract( recs, &rec, sizeof( rec ) ); + rtems_test_assert( recs != NULL ); /* Verify that time goes forward */ - rtems_test_assert(rec.time >= prev_rec.time); + rtems_test_assert( rec.time >= prev_rec.time ); - if ((rec.events & RTEMS_CAPTURE_TIMESTAMP) != 0) { - recs = rtems_capture_record_extract(recs, &id, sizeof(id)); - rtems_test_assert(recs != NULL); + if ( ( rec.events & RTEMS_CAPTURE_TIMESTAMP ) != 0 ) { + recs = rtems_capture_record_extract( recs, &id, sizeof( id ) ); + rtems_test_assert( recs != NULL ); - switch (id) { - case enter_add_number: - rtems_test_assert(enter_count == exit_count); - enter_count++; - recs = rtems_capture_record_extract(recs, - &enter_rec, - sizeof(enter_rec)); - rtems_test_assert(recs != NULL); - res_should_be = add_number(enter_rec.a, enter_rec.b); + switch ( id ) { + case enter_add_number: + rtems_test_assert( enter_count == exit_count ); + enter_count++; + recs = rtems_capture_record_extract( + recs, + &enter_rec, + sizeof( enter_rec ) + ); + rtems_test_assert( recs != NULL ); + res_should_be = add_number( enter_rec.a, enter_rec.b ); #ifdef VERBOSE - /* Print record */ - rtems_object_get_classic_name(rec.task_id, &name); - printf("Time: %"PRIu64"us Task: %c%c%c%c => Add %"PRIu32" and %"PRIu32" is %"PRIu32"\n", - rec.time / 1000, PNAME(name), enter_rec.a, enter_rec.b, res_should_be); + /* Print record */ + rtems_object_get_classic_name( rec.task_id, &name ); + printf( + "Time: %" PRIu64 "us Task: %c%c%c%c => Add %" PRIu32 + " and %" PRIu32 " is %" PRIu32 "\n", + rec.time / 1000, + PNAME( name ), + enter_rec.a, + enter_rec.b, + res_should_be + ); #endif - break; - case exit_add_number: - rtems_test_assert(enter_count == exit_count+1); - exit_count++; - recs = rtems_capture_record_extract(recs, - &exit_rec, - sizeof(exit_rec)); - rtems_test_assert(recs != NULL); + break; + case exit_add_number: + rtems_test_assert( enter_count == exit_count + 1 ); + exit_count++; + recs = rtems_capture_record_extract( + recs, + &exit_rec, + sizeof( exit_rec ) + ); + rtems_test_assert( recs != NULL ); #ifdef VERBOSE - /* Print record */ - rtems_object_get_classic_name(rec.task_id, &name); - printf("Time: %"PRIu64"us Task: %c%c%c%c => Result is %"PRIu32"\n", - rec.time / 1000, PNAME(name), exit_rec.res); + /* Print record */ + rtems_object_get_classic_name( rec.task_id, &name ); + printf( + "Time: %" PRIu64 "us Task: %c%c%c%c => Result is %" PRIu32 "\n", + rec.time / 1000, + PNAME( name ), + exit_rec.res + ); #endif - /* Verify that the result matches the expected result */ - rtems_test_assert(res_should_be == exit_rec.res); - break; - case clock_tick: - clock_tick_count++; + /* Verify that the result matches the expected result */ + rtems_test_assert( res_should_be == exit_rec.res ); + break; + case clock_tick: + clock_tick_count++; #ifdef VERBOSE - rtems_object_get_classic_name(rec.task_id, &name); - printf("Time: %"PRIu64"us Task: %c%c%c%c => Clock tick\n", - rec.time/1000, PNAME(name)); + rtems_object_get_classic_name( rec.task_id, &name ); + printf( + "Time: %" PRIu64 "us Task: %c%c%c%c => Clock tick\n", + rec.time / 1000, + PNAME( name ) + ); #endif - break; - default: - rtems_test_assert(0); + break; + default: + rtems_test_assert( 0 ); } } prev_rec = rec; } - rtems_test_assert(enter_count == exit_count); - rtems_test_assert(enter_count == TASKS_PER_CPU * ITERATIONS); + rtems_test_assert( enter_count == exit_count ); + rtems_test_assert( enter_count == TASKS_PER_CPU * ITERATIONS ); - rtems_capture_release(cpu, read); + rtems_capture_release( cpu, read ); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -454,12 +495,12 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS MAX_CPUS #define CONFIGURE_MAXIMUM_PROCESSORS MAX_CPUS -#define CONFIGURE_MAXIMUM_SEMAPHORES MAX_CPUS * TASKS_PER_CPU + 1 -#define CONFIGURE_MAXIMUM_TASKS MAX_CPUS * TASKS_PER_CPU + 1 +#define CONFIGURE_MAXIMUM_SEMAPHORES MAX_CPUS *TASKS_PER_CPU + 1 +#define CONFIGURE_MAXIMUM_TASKS MAX_CPUS *TASKS_PER_CPU + 1 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE -#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1 -#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION +#define CONFIGURE_MAXIMUM_USER_EXTENSIONS 1 +#define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_INIT #include diff --git a/testsuites/smptests/smpclock01/init.c b/testsuites/smptests/smpclock01/init.c index 1134564847..3a8814a7c7 100644 --- a/testsuites/smptests/smpclock01/init.c +++ b/testsuites/smptests/smpclock01/init.c @@ -40,16 +40,16 @@ #define CPU_COUNT 2 -#define SCHEDULER_A rtems_build_name(' ', ' ', ' ', 'A') +#define SCHEDULER_A rtems_build_name( ' ', ' ', ' ', 'A' ) -#define SCHEDULER_B rtems_build_name(' ', ' ', ' ', 'B') +#define SCHEDULER_B rtems_build_name( ' ', ' ', ' ', 'B' ) const char rtems_test_name[] = "SMPCLOCK 1"; typedef struct { SMP_barrier_Control barrier; - SMP_barrier_State delay_barrier_state; - SMP_barrier_State timer_barrier_state; + SMP_barrier_State delay_barrier_state; + SMP_barrier_State timer_barrier_state; } test_context; static test_context test_instance = { @@ -58,95 +58,95 @@ static test_context test_instance = { .timer_barrier_state = SMP_BARRIER_STATE_INITIALIZER }; -static void wait(test_context *ctx, SMP_barrier_State *bs) +static void wait( test_context *ctx, SMP_barrier_State *bs ) { - _SMP_barrier_Wait(&ctx->barrier, bs, CPU_COUNT); + _SMP_barrier_Wait( &ctx->barrier, bs, CPU_COUNT ); } -static void timer_isr(rtems_id id, void *arg) +static void timer_isr( rtems_id id, void *arg ) { (void) id; test_context *ctx = arg; /* (B) */ - wait(ctx, &ctx->timer_barrier_state); + wait( ctx, &ctx->timer_barrier_state ); } -static void timer_task(rtems_task_argument arg) +static void timer_task( rtems_task_argument arg ) { (void) arg; - test_context *ctx = (test_context *) arg; + test_context *ctx = (test_context *) arg; rtems_status_code sc; - rtems_id timer_id; + rtems_id timer_id; - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - sc = rtems_timer_create(SCHEDULER_B, &timer_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_create( SCHEDULER_B, &timer_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (A) */ - wait(ctx, &ctx->timer_barrier_state); + wait( ctx, &ctx->timer_barrier_state ); - sc = rtems_timer_fire_after(timer_id, 1, timer_isr, ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_fire_after( timer_id, 1, timer_isr, ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_wake_after(1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_timer_delete(timer_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_delete( timer_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (C) */ - wait(ctx, &ctx->timer_barrier_state); + wait( ctx, &ctx->timer_barrier_state ); - while (true) { + while ( true ) { /* Wait for deletion */ } } -static void delay_clock_tick(test_context *ctx) +static void delay_clock_tick( test_context *ctx ) { - rtems_interrupt_level level; - const Per_CPU_Control *cpu_self = _Per_CPU_Get_by_index(0); - const Per_CPU_Control *cpu_other = _Per_CPU_Get_by_index(1); - uint64_t ticks; + rtems_interrupt_level level; + const Per_CPU_Control *cpu_self = _Per_CPU_Get_by_index( 0 ); + const Per_CPU_Control *cpu_other = _Per_CPU_Get_by_index( 1 ); + uint64_t ticks; - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); rtems_test_spin_until_next_tick(); ticks = cpu_self->Watchdog.ticks; - rtems_interrupt_local_disable(level); + rtems_interrupt_local_disable( level ); /* (A) */ - wait(ctx, &ctx->delay_barrier_state); + wait( ctx, &ctx->delay_barrier_state ); /* (B) */ - wait(ctx, &ctx->delay_barrier_state); + wait( ctx, &ctx->delay_barrier_state ); - rtems_test_assert(cpu_self->Watchdog.ticks == ticks); - rtems_test_assert(cpu_other->Watchdog.ticks == ticks + 1); + rtems_test_assert( cpu_self->Watchdog.ticks == ticks ); + rtems_test_assert( cpu_other->Watchdog.ticks == ticks + 1 ); - rtems_interrupt_local_enable(level); + rtems_interrupt_local_enable( level ); - rtems_test_assert(cpu_self->Watchdog.ticks == ticks + 1); - rtems_test_assert(cpu_other->Watchdog.ticks == ticks + 1); + rtems_test_assert( cpu_self->Watchdog.ticks == ticks + 1 ); + rtems_test_assert( cpu_other->Watchdog.ticks == ticks + 1 ); /* (C) */ - wait(ctx, &ctx->delay_barrier_state); + wait( ctx, &ctx->delay_barrier_state ); } -static void test(void) +static void test( void ) { - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; - rtems_id scheduler_b_id; - rtems_id task_id; + rtems_id scheduler_b_id; + rtems_id task_id; - sc = rtems_scheduler_ident(SCHEDULER_B, &scheduler_b_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHEDULER_B, &scheduler_b_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( SCHEDULER_B, @@ -156,21 +156,21 @@ static void test(void) RTEMS_DEFAULT_ATTRIBUTES, &task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( task_id, scheduler_b_id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(task_id, timer_task, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_id, timer_task, (rtems_task_argument) ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - delay_clock_tick(ctx); + delay_clock_tick( ctx ); - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -178,16 +178,16 @@ static void Init(rtems_task_argument arg) TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); - if (rtems_scheduler_get_processor_maximum() == CPU_COUNT) { + if ( rtems_scheduler_get_processor_maximum() == CPU_COUNT ) { test(); } - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -199,16 +199,16 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_SIMPLE_SMP(a); -RTEMS_SCHEDULER_SIMPLE_SMP(b); +RTEMS_SCHEDULER_SIMPLE_SMP( a ); +RTEMS_SCHEDULER_SIMPLE_SMP( b ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(a, SCHEDULER_A), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(b, SCHEDULER_B) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( a, SCHEDULER_A ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( b, SCHEDULER_B ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_MAXIMUM_TASKS CPU_COUNT diff --git a/testsuites/smptests/smpfatal01/init.c b/testsuites/smptests/smpfatal01/init.c index d97a18823d..0e31528d44 100644 --- a/testsuites/smptests/smpfatal01/init.c +++ b/testsuites/smptests/smpfatal01/init.c @@ -49,78 +49,76 @@ static uint32_t other_cpu; static SMP_barrier_Control barrier = SMP_BARRIER_CONTROL_INITIALIZER; -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - assert(0); + assert( 0 ); } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { - assert(!always_set_to_false); + assert( !always_set_to_false ); - if (source == RTEMS_FATAL_SOURCE_SMP) { + if ( source == RTEMS_FATAL_SOURCE_SMP ) { SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t self = rtems_scheduler_get_processor(); + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t self = rtems_scheduler_get_processor(); - if (self == other_cpu) { - assert(code == SMP_FATAL_SHUTDOWN); + if ( self == other_cpu ) { + assert( code == SMP_FATAL_SHUTDOWN ); } else { - assert(code == SMP_FATAL_SHUTDOWN_RESPONSE); + assert( code == SMP_FATAL_SHUTDOWN_RESPONSE ); } - _SMP_barrier_Wait(&barrier, &barrier_state, cpu_count); + _SMP_barrier_Wait( &barrier, &barrier_state, cpu_count ); - if (self == other_cpu) { + if ( self == other_cpu ) { uint32_t cpu; - for (cpu = 0; cpu < cpu_count; ++cpu) { + for ( cpu = 0; cpu < cpu_count; ++cpu ) { const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu ); - Per_CPU_State state = _Per_CPU_Get_state(per_cpu); + Per_CPU_State state = _Per_CPU_Get_state( per_cpu ); - assert(state == PER_CPU_STATE_SHUTDOWN); + assert( state == PER_CPU_STATE_SHUTDOWN ); } - for (cpu = cpu_count; cpu < MAX_CPUS; ++cpu) { + for ( cpu = cpu_count; cpu < MAX_CPUS; ++cpu ) { const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu ); - Per_CPU_State state = _Per_CPU_Get_state(per_cpu); + Per_CPU_State state = _Per_CPU_Get_state( per_cpu ); - assert(state == PER_CPU_STATE_INITIAL); + assert( state == PER_CPU_STATE_INITIAL ); } TEST_END(); } else { - _SMP_barrier_Wait(&barrier, &barrier_state, cpu_count); + _SMP_barrier_Wait( &barrier, &barrier_state, cpu_count ); } } } -static void shutdown_handler(void *arg) +static void shutdown_handler( void *arg ) { (void) arg; _SMP_Request_shutdown(); - _SMP_Fatal(SMP_FATAL_SHUTDOWN); + _SMP_Fatal( SMP_FATAL_SHUTDOWN ); } static const Per_CPU_Job_context shutdown_context = { .handler = shutdown_handler }; -static Per_CPU_Job shutdown_job = { - .context = &shutdown_context -}; +static Per_CPU_Job shutdown_job = { .context = &shutdown_context }; static rtems_status_code test_driver_init( rtems_device_major_number major, rtems_device_minor_number minor, - void *arg + void *arg ) { (void) major; @@ -133,34 +131,34 @@ static rtems_status_code test_driver_init( TEST_BEGIN(); - assert(rtems_configuration_get_maximum_processors() == MAX_CPUS); + assert( rtems_configuration_get_maximum_processors() == MAX_CPUS ); main_cpu = self; - other_cpu = (self + 1) % cpu_count; + other_cpu = ( self + 1 ) % cpu_count; - for (cpu = 0; cpu < MAX_CPUS; ++cpu) { + for ( cpu = 0; cpu < MAX_CPUS; ++cpu ) { const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu ); - Per_CPU_State state = _Per_CPU_Get_state(per_cpu); + Per_CPU_State state = _Per_CPU_Get_state( per_cpu ); - if (cpu == self) { - assert(state == PER_CPU_STATE_INITIAL); - } else if (cpu < cpu_count) { + if ( cpu == self ) { + assert( state == PER_CPU_STATE_INITIAL ); + } else if ( cpu < cpu_count ) { assert( - state == PER_CPU_STATE_INITIAL - || state == PER_CPU_STATE_READY_TO_START_MULTITASKING + state == PER_CPU_STATE_INITIAL || + state == PER_CPU_STATE_READY_TO_START_MULTITASKING ); } else { - assert(state == PER_CPU_STATE_INITIAL); + assert( state == PER_CPU_STATE_INITIAL ); } } - if (cpu_count > 1) { + if ( cpu_count > 1 ) { Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( other_cpu ); - _Per_CPU_Submit_job(per_cpu, &shutdown_job); + _Per_CPU_Submit_job( per_cpu, &shutdown_job ); } else { TEST_END(); - exit(0); + exit( 0 ); } return RTEMS_SUCCESSFUL; @@ -173,8 +171,7 @@ static rtems_status_code test_driver_init( { .initialization_entry = test_driver_init } #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_MAXIMUM_PROCESSORS MAX_CPUS diff --git a/testsuites/smptests/smpfatal02/init.c b/testsuites/smptests/smpfatal02/init.c index cfaccf25f0..6a258e0746 100644 --- a/testsuites/smptests/smpfatal02/init.c +++ b/testsuites/smptests/smpfatal02/init.c @@ -47,61 +47,61 @@ static uint32_t main_cpu; static SMP_barrier_Control barrier = SMP_BARRIER_CONTROL_INITIALIZER; -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - assert(0); + assert( 0 ); } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; - uint32_t self = rtems_scheduler_get_processor(); - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t self = rtems_scheduler_get_processor(); + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - assert(!always_set_to_false); + assert( !always_set_to_false ); if ( source == RTEMS_FATAL_SOURCE_APPLICATION ) { uint32_t cpu; - assert(self == main_cpu); - assert(code == 0xdeadbeef); + assert( self == main_cpu ); + assert( code == 0xdeadbeef ); _SMP_Request_shutdown(); - _SMP_barrier_Wait(&barrier, &barrier_state, cpu_count); + _SMP_barrier_Wait( &barrier, &barrier_state, cpu_count ); - for (cpu = 0; cpu < cpu_count; ++cpu) { + for ( cpu = 0; cpu < cpu_count; ++cpu ) { const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu ); - Per_CPU_State state = _Per_CPU_Get_state(per_cpu); + Per_CPU_State state = _Per_CPU_Get_state( per_cpu ); - assert(state == PER_CPU_STATE_SHUTDOWN); + assert( state == PER_CPU_STATE_SHUTDOWN ); } - for (cpu = cpu_count; cpu < MAX_CPUS; ++cpu) { + for ( cpu = cpu_count; cpu < MAX_CPUS; ++cpu ) { const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu ); - Per_CPU_State state = _Per_CPU_Get_state(per_cpu); + Per_CPU_State state = _Per_CPU_Get_state( per_cpu ); - assert(state == PER_CPU_STATE_INITIAL); + assert( state == PER_CPU_STATE_INITIAL ); } TEST_END(); } else if ( source == RTEMS_FATAL_SOURCE_SMP ) { - assert(self != main_cpu); - assert(code == SMP_FATAL_SHUTDOWN_RESPONSE); - _SMP_barrier_Wait(&barrier, &barrier_state, cpu_count); - _SMP_barrier_Wait(&barrier, &barrier_state, cpu_count); + assert( self != main_cpu ); + assert( code == SMP_FATAL_SHUTDOWN_RESPONSE ); + _SMP_barrier_Wait( &barrier, &barrier_state, cpu_count ); + _SMP_barrier_Wait( &barrier, &barrier_state, cpu_count ); } } static rtems_status_code test_driver_init( rtems_device_major_number major, rtems_device_minor_number minor, - void *arg + void *arg ) { (void) major; @@ -114,31 +114,31 @@ static rtems_status_code test_driver_init( TEST_BEGIN(); - assert(rtems_configuration_get_maximum_processors() == MAX_CPUS); + assert( rtems_configuration_get_maximum_processors() == MAX_CPUS ); main_cpu = self; - for (cpu = 0; cpu < MAX_CPUS; ++cpu) { + for ( cpu = 0; cpu < MAX_CPUS; ++cpu ) { const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu ); - Per_CPU_State state = _Per_CPU_Get_state(per_cpu); + Per_CPU_State state = _Per_CPU_Get_state( per_cpu ); - if (cpu == self) { - assert(state == PER_CPU_STATE_INITIAL); - } else if (cpu < cpu_count) { + if ( cpu == self ) { + assert( state == PER_CPU_STATE_INITIAL ); + } else if ( cpu < cpu_count ) { assert( - state == PER_CPU_STATE_INITIAL - || state == PER_CPU_STATE_READY_TO_START_MULTITASKING + state == PER_CPU_STATE_INITIAL || + state == PER_CPU_STATE_READY_TO_START_MULTITASKING ); } else { - assert(state == PER_CPU_STATE_INITIAL); + assert( state == PER_CPU_STATE_INITIAL ); } } - if (cpu_count > 1) { - rtems_fatal(RTEMS_FATAL_SOURCE_APPLICATION, 0xdeadbeef); + if ( cpu_count > 1 ) { + rtems_fatal( RTEMS_FATAL_SOURCE_APPLICATION, 0xdeadbeef ); } else { TEST_END(); - exit(0); + exit( 0 ); } return RTEMS_SUCCESSFUL; @@ -151,8 +151,7 @@ static rtems_status_code test_driver_init( { .initialization_entry = test_driver_init } #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_MAXIMUM_PROCESSORS MAX_CPUS diff --git a/testsuites/smptests/smpfatal03/init.c b/testsuites/smptests/smpfatal03/init.c index 207f685d5f..ec2f24dcf9 100644 --- a/testsuites/smptests/smpfatal03/init.c +++ b/testsuites/smptests/smpfatal03/init.c @@ -37,7 +37,7 @@ static void Init( rtems_task_argument arg ) TEST_BEGIN(); sc = rtems_semaphore_create( - rtems_build_name('M', 'R', 'S', 'P'), + rtems_build_name( 'M', 'R', 'S', 'P' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING, @@ -46,10 +46,7 @@ static void Init( rtems_task_argument arg ) ); rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_timer_create( - rtems_build_name( 'E', 'V', 'I', 'L' ), - &timer_id - ); + sc = rtems_timer_create( rtems_build_name( 'E', 'V', 'I', 'L' ), &timer_id ); rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_obtain( sem_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); @@ -64,14 +61,13 @@ static void Init( rtems_task_argument arg ) static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { if ( - source == INTERNAL_ERROR_CORE - && !always_set_to_false - && code == INTERNAL_ERROR_THREAD_QUEUE_ENQUEUE_STICKY_FROM_BAD_STATE + source == INTERNAL_ERROR_CORE && !always_set_to_false && + code == INTERNAL_ERROR_THREAD_QUEUE_ENQUEUE_STICKY_FROM_BAD_STATE ) { TEST_END(); } @@ -81,11 +77,10 @@ static void fatal_extension( #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION -#define CONFIGURE_MAXIMUM_TASKS 1 -#define CONFIGURE_MAXIMUM_TIMERS 1 +#define CONFIGURE_MAXIMUM_TASKS 1 +#define CONFIGURE_MAXIMUM_TIMERS 1 #define CONFIGURE_MAXIMUM_SEMAPHORES 1 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE diff --git a/testsuites/smptests/smpfatal04/init.c b/testsuites/smptests/smpfatal04/init.c index 7328d5fc34..802fe6fee5 100644 --- a/testsuites/smptests/smpfatal04/init.c +++ b/testsuites/smptests/smpfatal04/init.c @@ -39,31 +39,30 @@ const char rtems_test_name[] = "SMPFATAL 4"; -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - assert(0); + assert( 0 ); } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { TEST_BEGIN(); if ( - source == RTEMS_FATAL_SOURCE_SMP - && !always_set_to_false - && code == SMP_FATAL_BOOT_PROCESSOR_NOT_ASSIGNED_TO_SCHEDULER + source == RTEMS_FATAL_SOURCE_SMP && !always_set_to_false && + code == SMP_FATAL_BOOT_PROCESSOR_NOT_ASSIGNED_TO_SCHEDULER ) { rtems_status_code sc; - rtems_id id; + rtems_id id; - sc = rtems_scheduler_ident_by_processor(0, &id); - assert(sc == RTEMS_INCORRECT_STATE); + sc = rtems_scheduler_ident_by_processor( 0, &id ); + assert( sc == RTEMS_INCORRECT_STATE ); TEST_END(); } @@ -73,8 +72,7 @@ static void fatal_extension( #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_SCHEDULER_TABLE_ENTRIES diff --git a/testsuites/smptests/smpfatal05/init.c b/testsuites/smptests/smpfatal05/init.c index 8c0952d0ef..029c142c6d 100644 --- a/testsuites/smptests/smpfatal05/init.c +++ b/testsuites/smptests/smpfatal05/init.c @@ -39,25 +39,24 @@ const char rtems_test_name[] = "SMPFATAL 5"; -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - assert(0); + assert( 0 ); } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { TEST_BEGIN(); if ( - source == RTEMS_FATAL_SOURCE_SMP - && !always_set_to_false - && code == SMP_FATAL_MANDATORY_PROCESSOR_NOT_PRESENT + source == RTEMS_FATAL_SOURCE_SMP && !always_set_to_false && + code == SMP_FATAL_MANDATORY_PROCESSOR_NOT_PRESENT ) { TEST_END(); } @@ -67,8 +66,7 @@ static void fatal_extension( #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION /* Lets see when the first RTEMS system hits this limit */ #define CONFIGURE_MAXIMUM_PROCESSORS 64 @@ -77,23 +75,23 @@ static void fatal_extension( #include -RTEMS_SCHEDULER_SIMPLE_SMP(a); +RTEMS_SCHEDULER_SIMPLE_SMP( a ); #define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(a, rtems_build_name('S', 'I', 'M', 'P')) + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( a, rtems_build_name( 'S', 'I', 'M', 'P' ) ) #define ASSIGN \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ - ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ + ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ + ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ + ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ + ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ + ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ + ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, ASSIGN, \ + ASSIGN #define CONFIGURE_MAXIMUM_TASKS 1 diff --git a/testsuites/smptests/smpfatal06/init.c b/testsuites/smptests/smpfatal06/init.c index d32891543a..79e4fac6fa 100644 --- a/testsuites/smptests/smpfatal06/init.c +++ b/testsuites/smptests/smpfatal06/init.c @@ -35,7 +35,7 @@ const char rtems_test_name[] = "SMPFATAL 6"; -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -43,21 +43,20 @@ static void Init(rtems_task_argument arg) TEST_BEGIN(); - rtems_interrupt_local_disable(level); + rtems_interrupt_local_disable( level ); (void) level; - rtems_task_wake_after(1); + rtems_task_wake_after( 1 ); } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { if ( - source == INTERNAL_ERROR_CORE - && !always_set_to_false - && code == INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT + source == INTERNAL_ERROR_CORE && !always_set_to_false && + code == INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT ) { TEST_END(); } @@ -67,8 +66,7 @@ static void fatal_extension( #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_MAXIMUM_PROCESSORS 2 diff --git a/testsuites/smptests/smpfatal08/init.c b/testsuites/smptests/smpfatal08/init.c index 791843c283..b5f7db9444 100644 --- a/testsuites/smptests/smpfatal08/init.c +++ b/testsuites/smptests/smpfatal08/init.c @@ -47,7 +47,7 @@ const char rtems_test_name[] = "SMPFATAL 8"; * without BSP support. */ -void bsp_start_on_secondary_processor(struct Per_CPU_Control *cpu_self) +void bsp_start_on_secondary_processor( struct Per_CPU_Control *cpu_self ) { /* Provided to avoid multiple definitions of the CPU SMP support functions */ (void) cpu_self; @@ -56,70 +56,69 @@ void bsp_start_on_secondary_processor(struct Per_CPU_Control *cpu_self) } #if QORIQ_THREAD_COUNT > 1 -void qoriq_start_thread(Per_CPU_Control *cpu_self) +void qoriq_start_thread( Per_CPU_Control *cpu_self ) { /* Provided to avoid multiple definitions of the CPU SMP support functions */ (void) cpu_self; } #endif -uint32_t _CPU_SMP_Initialize(void) +uint32_t _CPU_SMP_Initialize( void ) { return 2; } -bool _CPU_SMP_Start_processor(uint32_t cpu_index) +bool _CPU_SMP_Start_processor( uint32_t cpu_index ) { (void) cpu_index; return false; } -void _CPU_SMP_Finalize_initialization(uint32_t cpu_count) +void _CPU_SMP_Finalize_initialization( uint32_t cpu_count ) { (void) cpu_count; - assert(0); + assert( 0 ); } -void _CPU_SMP_Prepare_start_multitasking(void) +void _CPU_SMP_Prepare_start_multitasking( void ) { - assert(0); + assert( 0 ); } -#if defined(RTEMS_PARAVIRT) \ - || (!defined(__leon__) && !defined(__PPC__) \ - && !defined(__arm__) && !defined(__riscv)) -uint32_t _CPU_SMP_Get_current_processor(void) +#if defined( RTEMS_PARAVIRT ) || \ + ( !defined( __leon__ ) && !defined( __PPC__ ) && !defined( __arm__ ) && \ + !defined( __riscv ) ) +uint32_t _CPU_SMP_Get_current_processor( void ) { return 0; } #endif -void _CPU_SMP_Send_interrupt(uint32_t target_processor_index) +void _CPU_SMP_Send_interrupt( uint32_t target_processor_index ) { (void) target_processor_index; } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - assert(0); + assert( 0 ); } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { TEST_BEGIN(); if ( - source == RTEMS_FATAL_SOURCE_SMP - && !always_set_to_false - && code == SMP_FATAL_START_OF_MANDATORY_PROCESSOR_FAILED + source == RTEMS_FATAL_SOURCE_SMP && !always_set_to_false && + code == SMP_FATAL_START_OF_MANDATORY_PROCESSOR_FAILED ) { TEST_END(); } @@ -129,8 +128,7 @@ static void fatal_extension( #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_MAXIMUM_PROCESSORS 2 @@ -138,14 +136,14 @@ static void fatal_extension( #include -RTEMS_SCHEDULER_SIMPLE_SMP(a); +RTEMS_SCHEDULER_SIMPLE_SMP( a ); #define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(a, rtems_build_name('S', 'I', 'M', 'P')) + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( a, rtems_build_name( 'S', 'I', 'M', 'P' ) ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) #define CONFIGURE_MAXIMUM_TASKS 1 diff --git a/testsuites/smptests/smpfatal09/init.c b/testsuites/smptests/smpfatal09/init.c index dd1af3d9f6..418ac1d681 100644 --- a/testsuites/smptests/smpfatal09/init.c +++ b/testsuites/smptests/smpfatal09/init.c @@ -38,7 +38,7 @@ PER_CPU_DATA_NEED_INITIALIZATION(); -static PER_CPU_DATA_ITEM(int, i) = 123; +static PER_CPU_DATA_ITEM( int, i ) = 123; const char rtems_test_name[] = "SMPFATAL 9"; @@ -76,14 +76,13 @@ RTEMS_SYSINIT_ITEM( static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { if ( - source == INTERNAL_ERROR_CORE - && !always_set_to_false - && code == INTERNAL_ERROR_NO_MEMORY_FOR_PER_CPU_DATA + source == INTERNAL_ERROR_CORE && !always_set_to_false && + code == INTERNAL_ERROR_NO_MEMORY_FOR_PER_CPU_DATA ) { TEST_END(); } @@ -94,8 +93,7 @@ static void fatal_extension( #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_MAXIMUM_PROCESSORS 2 diff --git a/testsuites/smptests/smpipi01/init.c b/testsuites/smptests/smpipi01/init.c index ee2523cb57..a7b56c3299 100644 --- a/testsuites/smptests/smpipi01/init.c +++ b/testsuites/smptests/smpipi01/init.c @@ -43,17 +43,17 @@ const char rtems_test_name[] = "SMPIPI 1"; typedef struct { uint32_t value; - uint32_t cache_line_separation[31]; + uint32_t cache_line_separation[ 31 ]; } test_counter; typedef struct { - test_counter counters[CPU_COUNT]; - uint32_t copy_counters[CPU_COUNT]; + test_counter counters[ CPU_COUNT ]; + uint32_t copy_counters[ CPU_COUNT ]; SMP_barrier_Control barrier; - SMP_barrier_State main_barrier_state; - SMP_barrier_State worker_barrier_state; - Per_CPU_Job jobs[CPU_COUNT][2]; - Per_CPU_Job sync_jobs[2]; + SMP_barrier_State main_barrier_state; + SMP_barrier_State worker_barrier_state; + Per_CPU_Job jobs[ CPU_COUNT ][ 2 ]; + Per_CPU_Job sync_jobs[ 2 ]; } test_context; static test_context test_instance = { @@ -62,24 +62,21 @@ static test_context test_instance = { .worker_barrier_state = SMP_BARRIER_STATE_INITIALIZER }; -static void barrier( - test_context *ctx, - SMP_barrier_State *state -) +static void barrier( test_context *ctx, SMP_barrier_State *state ) { - _SMP_barrier_Wait(&ctx->barrier, state, 2); + _SMP_barrier_Wait( &ctx->barrier, state, 2 ); } -static void barrier_1_handler(void *arg) +static void barrier_1_handler( void *arg ) { - test_context *ctx = arg; - uint32_t cpu_index_self = _SMP_Get_current_processor(); + test_context *ctx = arg; + uint32_t cpu_index_self = _SMP_Get_current_processor(); SMP_barrier_State *bs = &ctx->worker_barrier_state; - ++ctx->counters[cpu_index_self].value; + ++ctx->counters[ cpu_index_self ].value; /* (D) */ - barrier(ctx, bs); + barrier( ctx, bs ); } static const Per_CPU_Job_context barrier_1_job_context = { @@ -87,25 +84,25 @@ static const Per_CPU_Job_context barrier_1_job_context = { .arg = &test_instance }; -static void barrier_0_handler(void *arg) +static void barrier_0_handler( void *arg ) { - test_context *ctx = arg; - uint32_t cpu_index_self = _SMP_Get_current_processor(); + test_context *ctx = arg; + uint32_t cpu_index_self = _SMP_Get_current_processor(); SMP_barrier_State *bs = &ctx->worker_barrier_state; - ++ctx->counters[cpu_index_self].value; + ++ctx->counters[ cpu_index_self ].value; /* (A) */ - barrier(ctx, bs); + barrier( ctx, bs ); /* (B) */ - barrier(ctx, bs); + barrier( ctx, bs ); /* (C) */ - barrier(ctx, bs); + barrier( ctx, bs ); - ctx->jobs[0][1].context = &barrier_1_job_context; - _Per_CPU_Add_job(_Per_CPU_Get(), &ctx->jobs[0][1]); + ctx->jobs[ 0 ][ 1 ].context = &barrier_1_job_context; + _Per_CPU_Add_job( _Per_CPU_Get(), &ctx->jobs[ 0 ][ 1 ] ); } static const Per_CPU_Job_context barrier_0_job_context = { @@ -115,73 +112,79 @@ static const Per_CPU_Job_context barrier_0_job_context = { static void test_send_message_while_processing_a_message( test_context *ctx, - uint32_t cpu_index_self, - uint32_t cpu_count + uint32_t cpu_index_self, + uint32_t cpu_count ) { SMP_barrier_State *bs = &ctx->main_barrier_state; - uint32_t cpu_index; - rtems_status_code sc; - cpu_set_t cpuset; + uint32_t cpu_index; + rtems_status_code sc; + cpu_set_t cpuset; - rtems_test_assert(cpu_index_self < CPU_SETSIZE); - CPU_ZERO(&cpuset); - CPU_SET((int) cpu_index_self, &cpuset); - sc = rtems_task_set_affinity(RTEMS_SELF, sizeof(cpuset), &cpuset); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( cpu_index_self < CPU_SETSIZE ); + CPU_ZERO( &cpuset ); + CPU_SET( (int) cpu_index_self, &cpuset ); + sc = rtems_task_set_affinity( RTEMS_SELF, sizeof( cpuset ), &cpuset ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) { - if (cpu_index != cpu_index_self) { + for ( cpu_index = 0; cpu_index < cpu_count; ++cpu_index ) { + if ( cpu_index != cpu_index_self ) { Per_CPU_Control *cpu_self; - ctx->jobs[0][0].context = &barrier_0_job_context; - _Per_CPU_Submit_job(_Per_CPU_Get_by_index(cpu_index), &ctx->jobs[0][0]); + ctx->jobs[ 0 ][ 0 ].context = &barrier_0_job_context; + _Per_CPU_Submit_job( + _Per_CPU_Get_by_index( cpu_index ), + &ctx->jobs[ 0 ][ 0 ] + ); /* (A) */ - barrier(ctx, bs); + barrier( ctx, bs ); - rtems_test_assert(ctx->counters[cpu_index].value == 1); + rtems_test_assert( ctx->counters[ cpu_index ].value == 1 ); _SMP_Send_message( - _Per_CPU_Get_by_index(cpu_index), + _Per_CPU_Get_by_index( cpu_index ), SMP_MESSAGE_PERFORM_JOBS ); /* (B) */ - barrier(ctx, bs); + barrier( ctx, bs ); - rtems_test_assert(ctx->counters[cpu_index].value == 1); + rtems_test_assert( ctx->counters[ cpu_index ].value == 1 ); /* (C) */ - barrier(ctx, bs); + barrier( ctx, bs ); /* (D) */ - barrier(ctx, bs); + barrier( ctx, bs ); - rtems_test_assert(ctx->counters[cpu_index].value == 2); + rtems_test_assert( ctx->counters[ cpu_index ].value == 2 ); - ctx->counters[cpu_index].value = 0; + ctx->counters[ cpu_index ].value = 0; /* Ensure that the second job is done and can be reused */ cpu_self = _Thread_Dispatch_disable(); - _Per_CPU_Wait_for_job(_Per_CPU_Get_by_index(cpu_index), &ctx->jobs[0][1]); - _Thread_Dispatch_enable(cpu_self); + _Per_CPU_Wait_for_job( + _Per_CPU_Get_by_index( cpu_index ), + &ctx->jobs[ 0 ][ 1 ] + ); + _Thread_Dispatch_enable( cpu_self ); } } } -static void counter_handler(void *arg, size_t next_job) +static void counter_handler( void *arg, size_t next_job ) { - test_context *ctx = arg; + test_context *ctx = arg; Per_CPU_Control *cpu_self = _Per_CPU_Get(); - uint32_t cpu_index_self = _Per_CPU_Get_index(cpu_self); + uint32_t cpu_index_self = _Per_CPU_Get_index( cpu_self ); - ++ctx->counters[cpu_index_self].value; - _Per_CPU_Add_job(cpu_self, &ctx->jobs[cpu_index_self][next_job]); + ++ctx->counters[ cpu_index_self ].value; + _Per_CPU_Add_job( cpu_self, &ctx->jobs[ cpu_index_self ][ next_job ] ); } -static void counter_0_handler(void *arg) +static void counter_0_handler( void *arg ) { - counter_handler(arg, 1); + counter_handler( arg, 1 ); } static const Per_CPU_Job_context counter_0_job_context = { @@ -189,9 +192,9 @@ static const Per_CPU_Job_context counter_0_job_context = { .arg = &test_instance }; -static void counter_1_handler(void *arg) +static void counter_1_handler( void *arg ) { - counter_handler(arg, 0); + counter_handler( arg, 0 ); } static const Per_CPU_Job_context counter_1_job_context = { @@ -199,22 +202,22 @@ static const Per_CPU_Job_context counter_1_job_context = { .arg = &test_instance }; -static void sync_0_handler(void *arg) +static void sync_0_handler( void *arg ) { test_context *ctx = arg; - _Per_CPU_Submit_job(_Per_CPU_Get(), &ctx->sync_jobs[1]); + _Per_CPU_Submit_job( _Per_CPU_Get(), &ctx->sync_jobs[ 1 ] ); /* (E) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); } -static void sync_1_handler(void *arg) +static void sync_1_handler( void *arg ) { test_context *ctx = arg; /* (F) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); } static const Per_CPU_Job_context sync_0_context = { @@ -227,13 +230,13 @@ static const Per_CPU_Job_context sync_1_context = { .arg = &test_instance }; -static void wait_for_ipi_done(test_context *ctx, Per_CPU_Control *cpu) +static void wait_for_ipi_done( test_context *ctx, Per_CPU_Control *cpu ) { unsigned long done; - ctx->sync_jobs[0].context = &sync_0_context; - ctx->sync_jobs[1].context = &sync_1_context; - _Per_CPU_Submit_job(cpu, &ctx->sync_jobs[0]); + ctx->sync_jobs[ 0 ].context = &sync_0_context; + ctx->sync_jobs[ 1 ].context = &sync_1_context; + _Per_CPU_Submit_job( cpu, &ctx->sync_jobs[ 0 ] ); /* * (E) @@ -243,98 +246,100 @@ static void wait_for_ipi_done(test_context *ctx, Per_CPU_Control *cpu) * will no longer make this IPI pending after this point. Let the * sync_0_handler() make it pending again to go to (F). */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); /* (F) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); /* Make sure that a potential counter_handler() finished */ - while (cpu->isr_nest_level != 0) { + while ( cpu->isr_nest_level != 0 ) { RTEMS_COMPILER_MEMORY_BARRIER(); } - done = _Atomic_Load_ulong( &ctx->sync_jobs[1].done, ATOMIC_ORDER_ACQUIRE ); + done = _Atomic_Load_ulong( &ctx->sync_jobs[ 1 ].done, ATOMIC_ORDER_ACQUIRE ); rtems_test_assert( done == PER_CPU_JOB_DONE ); } -static void test_send_message_flood( - test_context *ctx, - uint32_t cpu_count -) +static void test_send_message_flood( test_context *ctx, uint32_t cpu_count ) { uint32_t cpu_index_self = rtems_scheduler_get_processor(); uint32_t cpu_index; - for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) { - Per_CPU_Control *cpu = _Per_CPU_Get_by_index(cpu_index); + for ( cpu_index = 0; cpu_index < cpu_count; ++cpu_index ) { + Per_CPU_Control *cpu = _Per_CPU_Get_by_index( cpu_index ); - ctx->jobs[cpu_index][0].context = &counter_0_job_context; - ctx->jobs[cpu_index][1].context = &counter_1_job_context; - _Per_CPU_Add_job(cpu, &ctx->jobs[cpu_index][0]); + ctx->jobs[ cpu_index ][ 0 ].context = &counter_0_job_context; + ctx->jobs[ cpu_index ][ 1 ].context = &counter_1_job_context; + _Per_CPU_Add_job( cpu, &ctx->jobs[ cpu_index ][ 0 ] ); } - for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) { + for ( cpu_index = 0; cpu_index < cpu_count; ++cpu_index ) { Per_CPU_Control *cpu; - uint32_t i; + uint32_t i; - cpu = _Per_CPU_Get_by_index(cpu_index); + cpu = _Per_CPU_Get_by_index( cpu_index ); - for (i = 0; i < cpu_count; ++i) { - if (i != cpu_index) { - ctx->copy_counters[i] = ctx->counters[i].value; + for ( i = 0; i < cpu_count; ++i ) { + if ( i != cpu_index ) { + ctx->copy_counters[ i ] = ctx->counters[ i ].value; } } - for (i = 0; i < 100000; ++i) { - _SMP_Send_message(cpu, SMP_MESSAGE_PERFORM_JOBS); + for ( i = 0; i < 100000; ++i ) { + _SMP_Send_message( cpu, SMP_MESSAGE_PERFORM_JOBS ); } - if (cpu_index != cpu_index_self) { - wait_for_ipi_done(ctx, cpu); + if ( cpu_index != cpu_index_self ) { + wait_for_ipi_done( ctx, cpu ); } - for (i = 0; i < cpu_count; ++i) { - if (i != cpu_index) { - rtems_test_assert(ctx->copy_counters[i] == ctx->counters[i].value); + for ( i = 0; i < cpu_count; ++i ) { + if ( i != cpu_index ) { + rtems_test_assert( + ctx->copy_counters[ i ] == ctx->counters[ i ].value + ); } } } - for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) { + for ( cpu_index = 0; cpu_index < cpu_count; ++cpu_index ) { rtems_test_assert( - _Processor_mask_Is_set(_SMP_Get_online_processors(), cpu_index) + _Processor_mask_Is_set( _SMP_Get_online_processors(), cpu_index ) ); printf( - "inter-processor interrupts for processor %" - PRIu32 "%s: %" PRIu32 "\n", + "inter-processor interrupts for processor %" PRIu32 "%s: %" PRIu32 "\n", cpu_index, cpu_index == cpu_index_self ? " (main)" : "", - ctx->counters[cpu_index].value + ctx->counters[ cpu_index ].value ); } - for (; cpu_index < CPU_COUNT; ++cpu_index) { + for ( ; cpu_index < CPU_COUNT; ++cpu_index ) { rtems_test_assert( - !_Processor_mask_Is_set(_SMP_Get_online_processors(), cpu_index) + !_Processor_mask_Is_set( _SMP_Get_online_processors(), cpu_index ) ); } } -static void test(void) +static void test( void ) { test_context *ctx = &test_instance; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t cpu_index_self; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t cpu_index_self; - for (cpu_index_self = 0; cpu_index_self < cpu_count; ++cpu_index_self) { - test_send_message_while_processing_a_message(ctx, cpu_index_self, cpu_count); + for ( cpu_index_self = 0; cpu_index_self < cpu_count; ++cpu_index_self ) { + test_send_message_while_processing_a_message( + ctx, + cpu_index_self, + cpu_count + ); } - test_send_message_flood(ctx, cpu_count); + test_send_message_flood( ctx, cpu_count ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -343,7 +348,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER diff --git a/testsuites/smptests/smpirqs01/init.c b/testsuites/smptests/smpirqs01/init.c index 7404c77418..2521f6a662 100644 --- a/testsuites/smptests/smpirqs01/init.c +++ b/testsuites/smptests/smpirqs01/init.c @@ -36,43 +36,43 @@ #include #include -static void ensure_server_termination(void) +static void ensure_server_termination( void ) { - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority prio; - rtems_id id; - uint32_t cpu_self; - uint32_t cpu_other; + rtems_id id; + uint32_t cpu_self; + uint32_t cpu_other; prio = 0; - sc = rtems_task_set_priority(RTEMS_SELF, 124, &prio); - T_rsc_success(sc); + sc = rtems_task_set_priority( RTEMS_SELF, 124, &prio ); + T_rsc_success( sc ); cpu_self = rtems_scheduler_get_processor(); - cpu_other = (cpu_self + 1) % 2; + cpu_other = ( cpu_self + 1 ) % 2; - sc = rtems_scheduler_ident_by_processor(cpu_other, &id); - T_rsc_success(sc); + sc = rtems_scheduler_ident_by_processor( cpu_other, &id ); + T_rsc_success( sc ); - sc = rtems_task_set_scheduler(RTEMS_SELF, id, 124); - T_rsc_success(sc); + sc = rtems_task_set_scheduler( RTEMS_SELF, id, 124 ); + T_rsc_success( sc ); - sc = rtems_scheduler_ident_by_processor(cpu_self, &id); - T_rsc_success(sc); + sc = rtems_scheduler_ident_by_processor( cpu_self, &id ); + T_rsc_success( sc ); - sc = rtems_task_set_scheduler(RTEMS_SELF, id, prio); - T_rsc_success(sc); + sc = rtems_task_set_scheduler( RTEMS_SELF, id, prio ); + T_rsc_success( sc ); } -T_TEST_CASE(InterruptServerSMPInitializeIncorrectState) +T_TEST_CASE( InterruptServerSMPInitializeIncorrectState ) { rtems_status_code sc; - uint32_t server_count; + uint32_t server_count; - T_assert_eq_u32(rtems_scheduler_get_processor_maximum(), 2); + T_assert_eq_u32( rtems_scheduler_get_processor_maximum(), 2 ); - sc = rtems_interrupt_server_delete(0); - T_rsc(sc, RTEMS_INVALID_ID); + sc = rtems_interrupt_server_delete( 0 ); + T_rsc( sc, RTEMS_INVALID_ID ); server_count = 456; sc = rtems_interrupt_server_initialize( @@ -82,8 +82,8 @@ T_TEST_CASE(InterruptServerSMPInitializeIncorrectState) RTEMS_DEFAULT_ATTRIBUTES, &server_count ); - T_rsc_success(sc); - T_eq_u32(server_count, 2); + T_rsc_success( sc ); + T_eq_u32( server_count, 2 ); server_count = 456; sc = rtems_interrupt_server_initialize( @@ -93,24 +93,24 @@ T_TEST_CASE(InterruptServerSMPInitializeIncorrectState) RTEMS_DEFAULT_ATTRIBUTES, &server_count ); - T_rsc(sc, RTEMS_INCORRECT_STATE); - T_eq_u32(server_count, 0); + T_rsc( sc, RTEMS_INCORRECT_STATE ); + T_eq_u32( server_count, 0 ); - sc = rtems_interrupt_server_delete(0); - T_rsc_success(sc); + sc = rtems_interrupt_server_delete( 0 ); + T_rsc_success( sc ); ensure_server_termination(); - sc = rtems_interrupt_server_delete(1); - T_rsc_success(sc); + sc = rtems_interrupt_server_delete( 1 ); + T_rsc_success( sc ); ensure_server_termination(); } -T_TEST_CASE(InterruptServerSMPInitializeInvalidPriority) +T_TEST_CASE( InterruptServerSMPInitializeInvalidPriority ) { rtems_status_code sc; - uint32_t server_count; + uint32_t server_count; - T_assert_eq_u32(rtems_scheduler_get_processor_maximum(), 2); + T_assert_eq_u32( rtems_scheduler_get_processor_maximum(), 2 ); server_count = 456; sc = rtems_interrupt_server_initialize( @@ -120,8 +120,8 @@ T_TEST_CASE(InterruptServerSMPInitializeInvalidPriority) RTEMS_DEFAULT_ATTRIBUTES, &server_count ); - T_rsc(sc, RTEMS_INVALID_PRIORITY); - T_eq_u32(server_count, 0); + T_rsc( sc, RTEMS_INVALID_PRIORITY ); + T_eq_u32( server_count, 0 ); server_count = 456; sc = rtems_interrupt_server_initialize( @@ -131,27 +131,27 @@ T_TEST_CASE(InterruptServerSMPInitializeInvalidPriority) RTEMS_DEFAULT_ATTRIBUTES, &server_count ); - T_rsc_success(sc); - T_eq_u32(server_count, 2); + T_rsc_success( sc ); + T_eq_u32( server_count, 2 ); - sc = rtems_interrupt_server_delete(0); - T_rsc_success(sc); + sc = rtems_interrupt_server_delete( 0 ); + T_rsc_success( sc ); ensure_server_termination(); - sc = rtems_interrupt_server_delete(1); - T_rsc_success(sc); + sc = rtems_interrupt_server_delete( 1 ); + T_rsc_success( sc ); ensure_server_termination(); } -T_TEST_CASE(InterruptServerSMPInitializeNoMemory) +T_TEST_CASE( InterruptServerSMPInitializeNoMemory ) { rtems_status_code sc; - uint32_t server_count; - void *greedy; + uint32_t server_count; + void *greedy; - T_assert_eq_u32(rtems_scheduler_get_processor_maximum(), 2); + T_assert_eq_u32( rtems_scheduler_get_processor_maximum(), 2 ); - greedy = rtems_heap_greedy_allocate(NULL, 0); + greedy = rtems_heap_greedy_allocate( NULL, 0 ); server_count = 456; sc = rtems_interrupt_server_initialize( @@ -161,35 +161,35 @@ T_TEST_CASE(InterruptServerSMPInitializeNoMemory) RTEMS_DEFAULT_ATTRIBUTES, &server_count ); - T_rsc(sc, RTEMS_NO_MEMORY); - T_eq_u32(server_count, 1); + T_rsc( sc, RTEMS_NO_MEMORY ); + T_eq_u32( server_count, 1 ); - rtems_heap_greedy_free(greedy); + rtems_heap_greedy_free( greedy ); - sc = rtems_interrupt_server_delete(0); - T_rsc_success(sc); + sc = rtems_interrupt_server_delete( 0 ); + T_rsc_success( sc ); ensure_server_termination(); - sc = rtems_interrupt_server_delete(1); - T_rsc(sc, RTEMS_INVALID_ID); + sc = rtems_interrupt_server_delete( 1 ); + T_rsc( sc, RTEMS_INVALID_ID ); } -T_TEST_CASE(InterruptServerSMPInitializeNoScheduler) +T_TEST_CASE( InterruptServerSMPInitializeNoScheduler ) { - rtems_status_code sc; - uint32_t server_count; - rtems_id scheduler_id; + rtems_status_code sc; + uint32_t server_count; + rtems_id scheduler_id; rtems_task_priority prio; - T_assert_eq_u32(rtems_scheduler_get_processor_maximum(), 2); + T_assert_eq_u32( rtems_scheduler_get_processor_maximum(), 2 ); scheduler_id = 0; - sc = rtems_scheduler_ident_by_processor(1, &scheduler_id); - T_rsc_success(sc); - T_ne_u32(scheduler_id, 0); + sc = rtems_scheduler_ident_by_processor( 1, &scheduler_id ); + T_rsc_success( sc ); + T_ne_u32( scheduler_id, 0 ); - sc = rtems_scheduler_remove_processor(scheduler_id, 1); - T_rsc_success(sc); + sc = rtems_scheduler_remove_processor( scheduler_id, 1 ); + T_rsc_success( sc ); server_count = 456; sc = rtems_interrupt_server_initialize( @@ -199,31 +199,31 @@ T_TEST_CASE(InterruptServerSMPInitializeNoScheduler) RTEMS_DEFAULT_ATTRIBUTES, &server_count ); - T_rsc_success(sc); - T_eq_u32(server_count, 2); + T_rsc_success( sc ); + T_eq_u32( server_count, 2 ); - sc = rtems_interrupt_server_delete(0); - T_rsc_success(sc); + sc = rtems_interrupt_server_delete( 0 ); + T_rsc_success( sc ); - sc = rtems_interrupt_server_delete(1); - T_rsc_success(sc); + sc = rtems_interrupt_server_delete( 1 ); + T_rsc_success( sc ); prio = 0; - sc = rtems_task_set_priority(RTEMS_SELF, 124, &prio); - T_rsc_success(sc); + sc = rtems_task_set_priority( RTEMS_SELF, 124, &prio ); + T_rsc_success( sc ); - sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio); - T_rsc_success(sc); + sc = rtems_task_set_priority( RTEMS_SELF, prio, &prio ); + T_rsc_success( sc ); - sc = rtems_scheduler_add_processor(scheduler_id, 1); - T_rsc_success(sc); + sc = rtems_scheduler_add_processor( scheduler_id, 1 ); + T_rsc_success( sc ); } const char rtems_test_name[] = "SMPIRQS 1"; -static void Init(rtems_task_argument argument) +static void Init( rtems_task_argument argument ) { - rtems_test_run(argument, TEST_STATE); + rtems_test_run( argument, TEST_STATE ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -241,17 +241,20 @@ static void Init(rtems_task_argument argument) #include -RTEMS_SCHEDULER_EDF_SMP(a); +RTEMS_SCHEDULER_EDF_SMP( a ); -RTEMS_SCHEDULER_EDF_SMP(b); +RTEMS_SCHEDULER_EDF_SMP( b ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(a, rtems_build_name('A', ' ', ' ', ' ')), \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(b, rtems_build_name('B', ' ', ' ', ' ')) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( a, rtems_build_name( 'A', ' ', ' ', ' ' ) ), \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( \ + b, \ + rtems_build_name( 'B', ' ', ' ', ' ' ) \ + ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INIT diff --git a/testsuites/smptests/smpload01/init.c b/testsuites/smptests/smpload01/init.c index f0f4a53ae4..8d1d107c55 100644 --- a/testsuites/smptests/smpload01/init.c +++ b/testsuites/smptests/smpload01/init.c @@ -46,41 +46,42 @@ const char rtems_test_name[] = "SMPLOAD 1"; #define MAX_INHERIT_OBTAIN_COUNT CPU_COUNT -#define SEM_WORKER_COUNT (3 * CPU_COUNT) +#define SEM_WORKER_COUNT ( 3 * CPU_COUNT ) #define INIT_PRIO 1 -#define INHERIT_RELEASE_PRIO_HIGH (INIT_PRIO + 1) +#define INHERIT_RELEASE_PRIO_HIGH ( INIT_PRIO + 1 ) -#define INHERIT_OBTAIN_PRIO_BASE (INHERIT_RELEASE_PRIO_HIGH + 1) +#define INHERIT_OBTAIN_PRIO_BASE ( INHERIT_RELEASE_PRIO_HIGH + 1 ) -#define INHERIT_RELEASE_PRIO_LOW (INHERIT_OBTAIN_PRIO_BASE + MAX_INHERIT_OBTAIN_COUNT) +#define INHERIT_RELEASE_PRIO_LOW \ + ( INHERIT_OBTAIN_PRIO_BASE + MAX_INHERIT_OBTAIN_COUNT ) -#define LOAD_PRIO (INHERIT_RELEASE_PRIO_LOW + 1) +#define LOAD_PRIO ( INHERIT_RELEASE_PRIO_LOW + 1 ) -#define SEM_WORKER_CEILING_PRIO (LOAD_PRIO + 1) +#define SEM_WORKER_CEILING_PRIO ( LOAD_PRIO + 1 ) -#define SEM_WORKER_PRIO_BASE (SEM_WORKER_CEILING_PRIO + 1) +#define SEM_WORKER_PRIO_BASE ( SEM_WORKER_CEILING_PRIO + 1 ) typedef struct { - rtems_id main_task_id; - rtems_id inherit_release_task_id; - rtems_id inherit_main_obtain_task_id; - rtems_id sem_worker_sem_prio_inherit; - rtems_id sem_worker_sem_prio_ceiling; - rtems_id inherit_sem; + rtems_id main_task_id; + rtems_id inherit_release_task_id; + rtems_id inherit_main_obtain_task_id; + rtems_id sem_worker_sem_prio_inherit; + rtems_id sem_worker_sem_prio_ceiling; + rtems_id inherit_sem; rtems_counter_ticks inherit_obtain_delay; SMP_barrier_Control inherit_barrier; - uint64_t inherit_obtain_counter[MAX_INHERIT_OBTAIN_COUNT]; - uint64_t inherit_release_counter; - uint64_t sem_worker_counter[SEM_WORKER_COUNT]; + uint64_t inherit_obtain_counter[ MAX_INHERIT_OBTAIN_COUNT ]; + uint64_t inherit_release_counter; + uint64_t sem_worker_counter[ SEM_WORKER_COUNT ]; } test_context; static test_context test_instance = { .inherit_barrier = SMP_BARRIER_CONTROL_INITIALIZER }; -static uint32_t simple_random(uint32_t v) +static uint32_t simple_random( uint32_t v ) { v *= 1664525; v += 1013904223; @@ -88,48 +89,53 @@ static uint32_t simple_random(uint32_t v) return v; } -static void inherit_obtain_task(rtems_task_argument arg) +static void inherit_obtain_task( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; - rtems_status_code sc; - SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - rtems_counter_ticks delay = (cpu_count - 1 - arg) * ctx->inherit_obtain_delay; + test_context *ctx = &test_instance; + rtems_status_code sc; + SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + rtems_counter_ticks delay = ( cpu_count - 1 - arg ) * + ctx->inherit_obtain_delay; - while (true) { - _SMP_barrier_Wait(&ctx->inherit_barrier, &barrier_state, cpu_count); + while ( true ) { + _SMP_barrier_Wait( &ctx->inherit_barrier, &barrier_state, cpu_count ); - rtems_counter_delay_ticks(delay); + rtems_counter_delay_ticks( delay ); - sc = rtems_semaphore_obtain(ctx->inherit_sem, RTEMS_WAIT, 1); - rtems_test_assert(sc == RTEMS_TIMEOUT); + sc = rtems_semaphore_obtain( ctx->inherit_sem, RTEMS_WAIT, 1 ); + rtems_test_assert( sc == RTEMS_TIMEOUT ); - _SMP_barrier_Wait(&ctx->inherit_barrier, &barrier_state, cpu_count); + _SMP_barrier_Wait( &ctx->inherit_barrier, &barrier_state, cpu_count ); - ++ctx->inherit_obtain_counter[arg]; + ++ctx->inherit_obtain_counter[ arg ]; - if (arg == 0) { + if ( arg == 0 ) { rtems_task_priority prio = INHERIT_RELEASE_PRIO_HIGH; - sc = rtems_task_set_priority(ctx->inherit_release_task_id, prio, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( + ctx->inherit_release_task_id, + prio, + &prio + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(ctx->inherit_release_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( ctx->inherit_release_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } } -static void inherit_release_task(rtems_task_argument arg) +static void inherit_release_task( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; sc = rtems_semaphore_obtain( @@ -137,19 +143,19 @@ static void inherit_release_task(rtems_task_argument arg) RTEMS_WAIT, RTEMS_NO_TIMEOUT ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(ctx->main_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( ctx->main_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (true) { + while ( true ) { rtems_task_priority prio = INHERIT_RELEASE_PRIO_LOW; - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->inherit_sem); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->inherit_sem ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); ++ctx->inherit_release_counter; @@ -158,77 +164,77 @@ static void inherit_release_task(rtems_task_argument arg) RTEMS_WAIT, RTEMS_NO_TIMEOUT ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_priority(RTEMS_SELF, prio, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( RTEMS_SELF, prio, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(ctx->inherit_main_obtain_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( ctx->inherit_main_obtain_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void load_task(rtems_task_argument arg) +static void load_task( rtems_task_argument arg ) { (void) arg; - size_t data_size; + size_t data_size; volatile int *data; - volatile int dummy; - size_t n; + volatile int dummy; + size_t n; - data_size = rtems_cache_get_data_cache_size(0); - if (data_size > 0) { - data = malloc(data_size); - rtems_test_assert(data != NULL); + data_size = rtems_cache_get_data_cache_size( 0 ); + if ( data_size > 0 ) { + data = malloc( data_size ); + rtems_test_assert( data != NULL ); } else { - data_size = sizeof(dummy); + data_size = sizeof( dummy ); data = &dummy; } - n = data_size / sizeof(*data); - while (true) { + n = data_size / sizeof( *data ); + while ( true ) { size_t i; - for (i = 0; i < n; ++i) { - data[i] = i; + for ( i = 0; i < n; ++i ) { + data[ i ] = i; } } } -static void sem_worker_task(rtems_task_argument arg) +static void sem_worker_task( rtems_task_argument arg ) { (void) arg; test_context *ctx = &test_instance; - uint32_t v = arg; + uint32_t v = arg; - while (true) { + while ( true ) { rtems_status_code sc; - rtems_id id; + rtems_id id; - v = simple_random(v); + v = simple_random( v ); - if ((v & 0x80000000) != 0) { + if ( ( v & 0x80000000 ) != 0 ) { id = ctx->sem_worker_sem_prio_inherit; } else { id = ctx->sem_worker_sem_prio_ceiling; } - sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_wake_after(1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - ++ctx->sem_worker_counter[arg]; + ++ctx->sem_worker_counter[ arg ]; } } -static int cmp(const void *ap, const void *bp) +static int cmp( const void *ap, const void *bp ) { const rtems_counter_ticks *a = ap; const rtems_counter_ticks *b = bp; @@ -236,151 +242,151 @@ static int cmp(const void *ap, const void *bp) return *a - *b; } -static void get_obtain_delay_estimate(test_context *ctx) +static void get_obtain_delay_estimate( test_context *ctx ) { - rtems_counter_ticks t[32]; - SMP_lock_Control lock; - ISR_Level level; - size_t n = RTEMS_ARRAY_SIZE(t); - size_t i; + rtems_counter_ticks t[ 32 ]; + SMP_lock_Control lock; + ISR_Level level; + size_t n = RTEMS_ARRAY_SIZE( t ); + size_t i; - _SMP_lock_Initialize(&lock, "test"); + _SMP_lock_Initialize( &lock, "test" ); - _ISR_Local_disable(level); + _ISR_Local_disable( level ); - for (i = 0; i < n; ++i) { - SMP_lock_Context lock_context; + for ( i = 0; i < n; ++i ) { + SMP_lock_Context lock_context; rtems_counter_ticks a; rtems_counter_ticks b; a = rtems_counter_read(); - _SMP_lock_ISR_disable_and_acquire(&lock, &lock_context); + _SMP_lock_ISR_disable_and_acquire( &lock, &lock_context ); b = rtems_counter_read(); - _SMP_lock_Release_and_ISR_enable(&lock, &lock_context); + _SMP_lock_Release_and_ISR_enable( &lock, &lock_context ); - t[i] = rtems_counter_difference(b, a); + t[ i ] = rtems_counter_difference( b, a ); } - _ISR_Local_enable(level); + _ISR_Local_enable( level ); - _SMP_lock_Destroy(&lock); + _SMP_lock_Destroy( &lock ); - qsort(&t[0], n, sizeof(t[0]), cmp); + qsort( &t[ 0 ], n, sizeof( t[ 0 ] ), cmp ); - ctx->inherit_obtain_delay = t[n / 2]; + ctx->inherit_obtain_delay = t[ n / 2 ]; } -static void test(void) +static void test( void ) { - test_context *ctx = &test_instance; - uint32_t i; + test_context *ctx = &test_instance; + uint32_t i; rtems_status_code sc; - rtems_id id; + rtems_id id; ctx->main_task_id = rtems_task_self(); - get_obtain_delay_estimate(ctx); + get_obtain_delay_estimate( ctx ); sc = rtems_semaphore_create( - rtems_build_name('S', 'E', 'M', 'I'), + rtems_build_name( 'S', 'E', 'M', 'I' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0, &ctx->sem_worker_sem_prio_inherit ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name('S', 'E', 'M', 'C'), + rtems_build_name( 'S', 'E', 'M', 'C' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, SEM_WORKER_CEILING_PRIO, &ctx->sem_worker_sem_prio_ceiling ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name('I', 'N', 'H', 'E'), + rtems_build_name( 'I', 'N', 'H', 'E' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0, &ctx->inherit_sem ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < SEM_WORKER_COUNT; ++i) { + for ( i = 0; i < SEM_WORKER_COUNT; ++i ) { sc = rtems_task_create( - rtems_build_name('S', 'E', 'M', 'W'), + rtems_build_name( 'S', 'E', 'M', 'W' ), SEM_WORKER_PRIO_BASE + i, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(id, sem_worker_task, i); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, sem_worker_task, i ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } sc = rtems_task_create( - rtems_build_name('L', 'O', 'A', 'D'), + rtems_build_name( 'L', 'O', 'A', 'D' ), LOAD_PRIO, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(id, load_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, load_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('I', 'N', 'H', 'R'), + rtems_build_name( 'I', 'N', 'H', 'R' ), INHERIT_RELEASE_PRIO_LOW, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); ctx->inherit_release_task_id = id; - sc = rtems_task_start(id, inherit_release_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, inherit_release_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < rtems_scheduler_get_processor_maximum(); ++i) { + for ( i = 0; i < rtems_scheduler_get_processor_maximum(); ++i ) { sc = rtems_task_create( - rtems_build_name('I', 'N', 'H', 'O'), + rtems_build_name( 'I', 'N', 'H', 'O' ), INHERIT_OBTAIN_PRIO_BASE + i, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - if (i == 0) { + if ( i == 0 ) { ctx->inherit_main_obtain_task_id = id; } - sc = rtems_task_start(id, inherit_obtain_task, i); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, inherit_obtain_task, i ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_task_wake_after(30 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 30 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < SEM_WORKER_COUNT; ++i) { + for ( i = 0; i < SEM_WORKER_COUNT; ++i ) { printf( "semaphore worker count %2" PRIu32 ": %" PRIu64 "\n", i, - ctx->sem_worker_counter[i] + ctx->sem_worker_counter[ i ] ); } @@ -389,16 +395,16 @@ static void test(void) ctx->inherit_release_counter ); - for (i = 0; i < rtems_scheduler_get_processor_maximum(); ++i) { + for ( i = 0; i < rtems_scheduler_get_processor_maximum(); ++i ) { printf( "priority inheritance obtain count %2" PRIu32 ": %" PRIu64 "\n", i, - ctx->inherit_obtain_counter[i] + ctx->inherit_obtain_counter[ i ] ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -407,7 +413,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -418,7 +424,7 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT #define CONFIGURE_MAXIMUM_TASKS \ - (1 + MAX_INHERIT_OBTAIN_COUNT + 1 + 1 + SEM_WORKER_COUNT) + ( 1 + MAX_INHERIT_OBTAIN_COUNT + 1 + 1 + SEM_WORKER_COUNT ) #define CONFIGURE_MAXIMUM_SEMAPHORES 3 diff --git a/testsuites/smptests/smplock01/init.c b/testsuites/smptests/smplock01/init.c index 19c1166fca..e8b5c5b74c 100644 --- a/testsuites/smptests/smplock01/init.c +++ b/testsuites/smptests/smplock01/init.c @@ -47,40 +47,40 @@ const char rtems_test_name[] = "SMPLOCK 1"; typedef struct { rtems_test_parallel_context base; - const char *test_sep; - const char *counter_sep; - unsigned long counter[TEST_COUNT]; - unsigned long local_counter[CPU_COUNT][TEST_COUNT][CPU_COUNT]; - SMP_lock_Control lock RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); - Atomic_Uint flag RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); - SMP_MCS_lock_Control mcs_lock RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); -#if defined(RTEMS_PROFILING) + const char *test_sep; + const char *counter_sep; + unsigned long counter[ TEST_COUNT ]; + unsigned long local_counter[ CPU_COUNT ][ TEST_COUNT ][ CPU_COUNT ]; + SMP_lock_Control lock RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); + Atomic_Uint flag RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); + SMP_MCS_lock_Control mcs_lock RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); +#if defined( RTEMS_PROFILING ) SMP_lock_Stats mcs_stats; #endif - SMP_sequence_lock_Control seq_lock RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); - int a RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); - int b RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); + SMP_sequence_lock_Control seq_lock RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); + int a RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); + int b RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); } test_context; static test_context test_instance = { - .lock = SMP_LOCK_INITIALIZER("global ticket"), -#if defined(RTEMS_PROFILING) - .mcs_stats = SMP_LOCK_STATS_INITIALIZER("global MCS"), + .lock = SMP_LOCK_INITIALIZER( "global ticket" ), +#if defined( RTEMS_PROFILING ) + .mcs_stats = SMP_LOCK_STATS_INITIALIZER( "global MCS" ), #endif - .flag = ATOMIC_INITIALIZER_UINT(0), + .flag = ATOMIC_INITIALIZER_UINT( 0 ), .mcs_lock = SMP_MCS_LOCK_INITIALIZER, .seq_lock = SMP_SEQUENCE_LOCK_INITIALIZER }; -static rtems_interval test_duration(void) +static rtems_interval test_duration( void ) { return rtems_clock_get_ticks_per_second(); } static rtems_interval test_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) base; @@ -90,23 +90,23 @@ static rtems_interval test_init( return test_duration(); } -static const rtems_test_parallel_job test_jobs[TEST_COUNT]; +static const rtems_test_parallel_job test_jobs[ TEST_COUNT ]; static void test_fini( test_context *ctx, - const char *lock_type, - bool global_lock, - const char *section_type, - size_t test, - size_t active_workers + const char *lock_type, + bool global_lock, + const char *section_type, + size_t test, + size_t active_workers ) { - bool cascade = test_jobs[test].cascade; + bool cascade = test_jobs[ test ].cascade; unsigned long sum = 0; - const char *value_sep; - size_t i; + const char *value_sep; + size_t i; - if (active_workers == 1 || !cascade) { + if ( active_workers == 1 || !cascade ) { printf( "%s{\n" " \"lock-type\": \"%s\",\n" @@ -124,21 +124,19 @@ static void test_fini( printf( "%s{\n" - " \"counter\": [", ctx->counter_sep); + " \"counter\": [", + ctx->counter_sep + ); ctx->counter_sep = "\n }, "; value_sep = ""; - for (i = 0; i < active_workers; ++i) { - unsigned long local_counter = - ctx->local_counter[active_workers - 1][test][i]; + for ( i = 0; i < active_workers; ++i ) { + unsigned long local_counter = ctx->local_counter[ active_workers - 1 ] + [ test ][ i ]; sum += local_counter; - printf( - "%s%lu", - value_sep, - local_counter - ); + printf( "%s%lu", value_sep, local_counter ); value_sep = ", "; } @@ -146,546 +144,478 @@ static void test_fini( "],\n" " \"global-counter\": %lu,\n" " \"sum-of-local-counter\": %lu", - ctx->counter[test], + ctx->counter[ test ], sum ); - if (active_workers == rtems_scheduler_get_processor_maximum() || !cascade) { - printf("\n }\n ]\n }"); + if ( + active_workers == rtems_scheduler_get_processor_maximum() || !cascade + ) { + printf( "\n }\n ]\n }" ); } } static void test_0_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 0; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 0; + unsigned long counter = 0; SMP_lock_Context lock_context; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_lock_Acquire(&ctx->lock, &lock_context); - _SMP_lock_Release(&ctx->lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_lock_Acquire( &ctx->lock, &lock_context ); + _SMP_lock_Release( &ctx->lock, &lock_context ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_0_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "Ticket Lock", - true, - "local counter", - 0, - active_workers - ); + test_fini( ctx, "Ticket Lock", true, "local counter", 0, active_workers ); } static void test_1_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 1; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 1; + unsigned long counter = 0; SMP_MCS_lock_Context lock_context; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_MCS_lock_Acquire(&ctx->mcs_lock, &lock_context, &ctx->mcs_stats); - _SMP_MCS_lock_Release(&ctx->mcs_lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_MCS_lock_Acquire( &ctx->mcs_lock, &lock_context, &ctx->mcs_stats ); + _SMP_MCS_lock_Release( &ctx->mcs_lock, &lock_context ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_1_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "MCS Lock", - true, - "local counter", - 1, - active_workers - ); + test_fini( ctx, "MCS Lock", true, "local counter", 1, active_workers ); } static void test_2_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 2; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 2; + unsigned long counter = 0; SMP_lock_Context lock_context; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_lock_Acquire(&ctx->lock, &lock_context); - ++ctx->counter[test]; - _SMP_lock_Release(&ctx->lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_lock_Acquire( &ctx->lock, &lock_context ); + ++ctx->counter[ test ]; + _SMP_lock_Release( &ctx->lock, &lock_context ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_2_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "Ticket Lock", - true, - "global counter", - 2, - active_workers - ); + test_fini( ctx, "Ticket Lock", true, "global counter", 2, active_workers ); } static void test_3_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 3; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 3; + unsigned long counter = 0; SMP_MCS_lock_Context lock_context; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_MCS_lock_Acquire(&ctx->mcs_lock, &lock_context, &ctx->mcs_stats); - ++ctx->counter[test]; - _SMP_MCS_lock_Release(&ctx->mcs_lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_MCS_lock_Acquire( &ctx->mcs_lock, &lock_context, &ctx->mcs_stats ); + ++ctx->counter[ test ]; + _SMP_MCS_lock_Release( &ctx->mcs_lock, &lock_context ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_3_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "MCS Lock", - true, - "global counter", - 3, - active_workers - ); + test_fini( ctx, "MCS Lock", true, "global counter", 3, active_workers ); } static void test_4_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 4; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 4; + unsigned long counter = 0; SMP_lock_Control lock; SMP_lock_Context lock_context; - _SMP_lock_Initialize(&lock, "local"); + _SMP_lock_Initialize( &lock, "local" ); - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_lock_Acquire(&lock, &lock_context); - _SMP_lock_Release(&lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_lock_Acquire( &lock, &lock_context ); + _SMP_lock_Release( &lock, &lock_context ); ++counter; } - _SMP_lock_Destroy(&lock); + _SMP_lock_Destroy( &lock ); - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_4_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "Ticket Lock", - false, - "local counter", - 4, - active_workers - ); + test_fini( ctx, "Ticket Lock", false, "local counter", 4, active_workers ); } static void test_5_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; test_context *ctx = (test_context *) base; - size_t test = 5; + size_t test = 5; unsigned long counter = 0; -#if defined(RTEMS_PROFILING) +#if defined( RTEMS_PROFILING ) SMP_lock_Stats stats; #endif SMP_MCS_lock_Control lock; SMP_MCS_lock_Context lock_context; - _SMP_lock_Stats_initialize(&stats, "local"); - _SMP_MCS_lock_Initialize(&lock); + _SMP_lock_Stats_initialize( &stats, "local" ); + _SMP_MCS_lock_Initialize( &lock ); - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_MCS_lock_Acquire(&lock, &lock_context, &stats); - _SMP_MCS_lock_Release(&lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_MCS_lock_Acquire( &lock, &lock_context, &stats ); + _SMP_MCS_lock_Release( &lock, &lock_context ); ++counter; } - _SMP_MCS_lock_Destroy(&lock); - _SMP_lock_Stats_destroy(&stats); + _SMP_MCS_lock_Destroy( &lock ); + _SMP_lock_Stats_destroy( &stats ); - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_5_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "MCS Lock", - false, - "local counter", - 5, - active_workers - ); + test_fini( ctx, "MCS Lock", false, "local counter", 5, active_workers ); } static void test_6_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 6; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 6; + unsigned long counter = 0; SMP_lock_Control lock; SMP_lock_Context lock_context; - _SMP_lock_Initialize(&lock, "local"); + _SMP_lock_Initialize( &lock, "local" ); - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_lock_Acquire(&lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_lock_Acquire( &lock, &lock_context ); /* The counter value is not interesting, only the access to it */ - ++ctx->counter[test]; + ++ctx->counter[ test ]; - _SMP_lock_Release(&lock, &lock_context); + _SMP_lock_Release( &lock, &lock_context ); ++counter; } - _SMP_lock_Destroy(&lock); + _SMP_lock_Destroy( &lock ); - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_6_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "Ticket Lock", - false, - "global counter", - 6, - active_workers - ); + test_fini( ctx, "Ticket Lock", false, "global counter", 6, active_workers ); } static void test_7_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; test_context *ctx = (test_context *) base; - size_t test = 7; + size_t test = 7; unsigned long counter = 0; -#if defined(RTEMS_PROFILING) +#if defined( RTEMS_PROFILING ) SMP_lock_Stats stats; #endif SMP_MCS_lock_Control lock; SMP_MCS_lock_Context lock_context; - _SMP_lock_Stats_initialize(&stats, "local"); - _SMP_MCS_lock_Initialize(&lock); + _SMP_lock_Stats_initialize( &stats, "local" ); + _SMP_MCS_lock_Initialize( &lock ); - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_MCS_lock_Acquire(&lock, &lock_context, &stats); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_MCS_lock_Acquire( &lock, &lock_context, &stats ); /* The counter value is not interesting, only the access to it */ - ++ctx->counter[test]; + ++ctx->counter[ test ]; - _SMP_MCS_lock_Release(&lock, &lock_context); + _SMP_MCS_lock_Release( &lock, &lock_context ); ++counter; } - _SMP_MCS_lock_Destroy(&lock); - _SMP_lock_Stats_destroy(&stats); + _SMP_MCS_lock_Destroy( &lock ); + _SMP_lock_Stats_destroy( &stats ); - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_7_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "MCS Lock", - false, - "global counter", - 7, - active_workers - ); + test_fini( ctx, "MCS Lock", false, "global counter", 7, active_workers ); } -static void busy_section(void) +static void busy_section( void ) { int i; - for (i = 0; i < 101; ++i) { + for ( i = 0; i < 101; ++i ) { RTEMS_COMPILER_MEMORY_BARRIER(); } } static void test_8_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 8; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 8; + unsigned long counter = 0; SMP_lock_Context lock_context; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_lock_Acquire(&ctx->lock, &lock_context); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_lock_Acquire( &ctx->lock, &lock_context ); busy_section(); - _SMP_lock_Release(&ctx->lock, &lock_context); + _SMP_lock_Release( &ctx->lock, &lock_context ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_8_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "Ticket Lock", - true, - "busy loop", - 8, - active_workers - ); + test_fini( ctx, "Ticket Lock", true, "busy loop", 8, active_workers ); } static void test_9_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; - test_context *ctx = (test_context *) base; - size_t test = 9; - unsigned long counter = 0; + test_context *ctx = (test_context *) base; + size_t test = 9; + unsigned long counter = 0; SMP_MCS_lock_Context lock_context; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - _SMP_MCS_lock_Acquire(&ctx->mcs_lock, &lock_context, &ctx->mcs_stats); + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + _SMP_MCS_lock_Acquire( &ctx->mcs_lock, &lock_context, &ctx->mcs_stats ); busy_section(); - _SMP_MCS_lock_Release(&ctx->mcs_lock, &lock_context); + _SMP_MCS_lock_Release( &ctx->mcs_lock, &lock_context ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_9_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "MCS Lock", - true, - "busy loop", - 9, - active_workers - ); + test_fini( ctx, "MCS Lock", true, "busy loop", 9, active_workers ); } static void test_10_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; test_context *ctx = (test_context *) base; - size_t test = 10; + size_t test = 10; unsigned long counter = 0; unsigned long seq; - if (rtems_test_parallel_is_master_worker(worker_index)) { - while (!rtems_test_parallel_stop_job(&ctx->base)) { - seq = _SMP_sequence_lock_Write_begin(&ctx->seq_lock); + if ( rtems_test_parallel_is_master_worker( worker_index ) ) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + seq = _SMP_sequence_lock_Write_begin( &ctx->seq_lock ); ctx->a = counter; ctx->b = counter; - _SMP_sequence_lock_Write_end(&ctx->seq_lock, seq); + _SMP_sequence_lock_Write_end( &ctx->seq_lock, seq ); ++counter; } } else { - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { unsigned long a; unsigned long b; do { - seq = _SMP_sequence_lock_Read_begin(&ctx->seq_lock); + seq = _SMP_sequence_lock_Read_begin( &ctx->seq_lock ); a = ctx->a; b = ctx->b; - } while (_SMP_sequence_lock_Read_retry(&ctx->seq_lock, seq)); + } while ( _SMP_sequence_lock_Read_retry( &ctx->seq_lock, seq ) ); ++counter; - rtems_test_assert(a == b); + rtems_test_assert( a == b ); } } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_10_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; @@ -704,176 +634,152 @@ static void test_10_fini( static void test_11_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; test_context *ctx = (test_context *) base; - size_t test = 11; + size_t test = 11; unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - while (_Atomic_Exchange_uint(&ctx->flag, 1, ATOMIC_ORDER_ACQUIRE) != 0) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + while ( + _Atomic_Exchange_uint( &ctx->flag, 1, ATOMIC_ORDER_ACQUIRE ) != 0 + ) { /* Wait */ } - _Atomic_Store_uint(&ctx->flag, 0, ATOMIC_ORDER_RELEASE); + _Atomic_Store_uint( &ctx->flag, 0, ATOMIC_ORDER_RELEASE ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_11_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "TAS Lock", - true, - "local counter", - 11, - active_workers - ); + test_fini( ctx, "TAS Lock", true, "local counter", 11, active_workers ); } static void test_12_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; test_context *ctx = (test_context *) base; - size_t test = 12; + size_t test = 12; unsigned long counter = 0; - while (!rtems_test_parallel_stop_job(&ctx->base)) { - while (_Atomic_Exchange_uint(&ctx->flag, 1, ATOMIC_ORDER_ACQUIRE) != 0) { - while (_Atomic_Load_uint(&ctx->flag, ATOMIC_ORDER_RELAXED) != 0) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { + while ( + _Atomic_Exchange_uint( &ctx->flag, 1, ATOMIC_ORDER_ACQUIRE ) != 0 + ) { + while ( _Atomic_Load_uint( &ctx->flag, ATOMIC_ORDER_RELAXED ) != 0 ) { /* Wait */ } } - _Atomic_Store_uint(&ctx->flag, 0, ATOMIC_ORDER_RELEASE); + _Atomic_Store_uint( &ctx->flag, 0, ATOMIC_ORDER_RELEASE ); ++counter; } - ctx->local_counter[active_workers - 1][test][worker_index] = counter; + ctx->local_counter[ active_workers - 1 ][ test ][ worker_index ] = counter; } static void test_12_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) arg; test_context *ctx = (test_context *) base; - test_fini( - ctx, - "TTAS Lock", - true, - "local counter", - 12, - active_workers - ); + test_fini( ctx, "TTAS Lock", true, "local counter", 12, active_workers ); } -static const rtems_test_parallel_job test_jobs[TEST_COUNT] = { - { - .init = test_init, +static const rtems_test_parallel_job test_jobs[ TEST_COUNT ] = { + { .init = test_init, .body = test_0_body, .fini = test_0_fini, - .cascade = true - }, { - .init = test_init, + .cascade = true }, + { .init = test_init, .body = test_1_body, .fini = test_1_fini, - .cascade = true - }, { - .init = test_init, + .cascade = true }, + { .init = test_init, .body = test_2_body, .fini = test_2_fini, - .cascade = false - }, { - .init = test_init, + .cascade = false }, + { .init = test_init, .body = test_3_body, .fini = test_3_fini, - .cascade = false - }, { - .init = test_init, + .cascade = false }, + { .init = test_init, .body = test_4_body, .fini = test_4_fini, - .cascade = true - }, { - .init = test_init, + .cascade = true }, + { .init = test_init, .body = test_5_body, .fini = test_5_fini, - .cascade = true - }, { - .init = test_init, + .cascade = true }, + { .init = test_init, .body = test_6_body, .fini = test_6_fini, - .cascade = false - }, { - .init = test_init, + .cascade = false }, + { .init = test_init, .body = test_7_body, .fini = test_7_fini, - .cascade = false - }, { - .init = test_init, + .cascade = false }, + { .init = test_init, .body = test_8_body, .fini = test_8_fini, - .cascade = false - }, { - .init = test_init, + .cascade = false }, + { .init = test_init, .body = test_9_body, .fini = test_9_fini, - .cascade = false - }, { - .init = test_init, + .cascade = false }, + { .init = test_init, .body = test_10_body, .fini = test_10_fini, - .cascade = false - }, { - .init = test_init, + .cascade = false }, + { .init = test_init, .body = test_11_body, .fini = test_11_fini, - .cascade = true - }, { - .init = test_init, + .cascade = true }, + { .init = test_init, .body = test_12_body, .fini = test_12_fini, - .cascade = true - } + .cascade = true } }; -static void test(void) +static void test( void ) { test_context *ctx = &test_instance; - printf("*** BEGIN OF JSON DATA ***\n[\n "); + printf( "*** BEGIN OF JSON DATA ***\n[\n " ); ctx->test_sep = ""; - rtems_test_parallel(&ctx->base, NULL, &test_jobs[0], TEST_COUNT); - printf("\n]\n*** END OF JSON DATA ***\n"); + rtems_test_parallel( &ctx->base, NULL, &test_jobs[ 0 ], TEST_COUNT ); + printf( "\n]\n*** END OF JSON DATA ***\n" ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -882,7 +788,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -896,9 +802,9 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_TIMERS 1 -#define CONFIGURE_INIT_TASK_PRIORITY TASK_PRIORITY +#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_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpmigration01/init.c b/testsuites/smptests/smpmigration01/init.c index 422e719edd..c31075fe17 100644 --- a/testsuites/smptests/smpmigration01/init.c +++ b/testsuites/smptests/smpmigration01/init.c @@ -39,7 +39,7 @@ const char rtems_test_name[] = "SMPMIGRATION 1"; #define CPU_COUNT 2 -#define RUNNER_COUNT (CPU_COUNT + 1) +#define RUNNER_COUNT ( CPU_COUNT + 1 ) #define PRIO_STOP 2 @@ -51,137 +51,143 @@ const char rtems_test_name[] = "SMPMIGRATION 1"; typedef struct { uint32_t counter; - uint32_t unused_space_for_cache_line_alignment[7]; + uint32_t unused_space_for_cache_line_alignment[ 7 ]; } cache_aligned_counter; typedef struct { - cache_aligned_counter tokens_per_cpu[CPU_COUNT]; - volatile cache_aligned_counter cycles_per_cpu[CPU_COUNT]; + cache_aligned_counter tokens_per_cpu[ CPU_COUNT ]; + volatile cache_aligned_counter cycles_per_cpu[ CPU_COUNT ]; } test_counters; typedef struct { - test_counters counters[RUNNER_COUNT]; + test_counters counters[ RUNNER_COUNT ]; volatile rtems_task_argument token; - rtems_id runner_ids[RUNNER_COUNT]; + rtems_id runner_ids[ RUNNER_COUNT ]; } test_context; CPU_STRUCTURE_ALIGNMENT static test_context ctx_instance; -static void change_prio(rtems_id task, rtems_task_priority prio) +static void change_prio( rtems_id task, rtems_task_priority prio ) { - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority unused; - sc = rtems_task_set_priority(task, prio, &unused); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( task, prio, &unused ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void runner(rtems_task_argument self) +static void runner( rtems_task_argument self ) { - test_context *ctx = &ctx_instance; - rtems_task_argument next = (self + 1) % RUNNER_COUNT; - rtems_id next_runner = ctx->runner_ids[next]; - test_counters *counters = &ctx->counters[self]; - test_counters *next_counters = &ctx->counters[next]; + test_context *ctx = &ctx_instance; + rtems_task_argument next = ( self + 1 ) % RUNNER_COUNT; + rtems_id next_runner = ctx->runner_ids[ next ]; + test_counters *counters = &ctx->counters[ self ]; + test_counters *next_counters = &ctx->counters[ next ]; - while (true) { + while ( true ) { uint32_t current_cpu = rtems_scheduler_get_processor(); - ++counters->cycles_per_cpu[current_cpu].counter; + ++counters->cycles_per_cpu[ current_cpu ].counter; - if (ctx->token == self) { - uint32_t other_cpu = (current_cpu + 1) % CPU_COUNT; + if ( ctx->token == self ) { + uint32_t other_cpu = ( current_cpu + 1 ) % CPU_COUNT; uint32_t snapshot; - ++counters->tokens_per_cpu[current_cpu].counter; + ++counters->tokens_per_cpu[ current_cpu ].counter; - change_prio(next_runner, PRIO_HIGH); + change_prio( next_runner, PRIO_HIGH ); - snapshot = next_counters->cycles_per_cpu[other_cpu].counter; - while (next_counters->cycles_per_cpu[other_cpu].counter == snapshot) { + snapshot = next_counters->cycles_per_cpu[ other_cpu ].counter; + while ( + next_counters->cycles_per_cpu[ other_cpu ].counter == snapshot + ) { /* Wait for other thread to resume execution */ } ctx->token = next; - change_prio(RTEMS_SELF, PRIO_NORMAL); + change_prio( RTEMS_SELF, PRIO_NORMAL ); } } } -static void stopper(rtems_task_argument arg) +static void stopper( rtems_task_argument arg ) { (void) arg; - while (true) { + while ( true ) { /* Do nothing */ } } -static uint32_t abs_delta(uint32_t a, uint32_t b) +static uint32_t abs_delta( uint32_t a, uint32_t b ) { - return a > b ? a - b : b - a; + return a > b ? a - b : b - a; } -static void test(void) +static void test( void ) { - test_context *ctx = &ctx_instance; - rtems_status_code sc; + test_context *ctx = &ctx_instance; + rtems_status_code sc; rtems_task_argument runner_index; - rtems_id stopper_id; - uint32_t expected_tokens; - uint32_t total_delta; - uint64_t total_cycles; - uint32_t average_cycles; + rtems_id stopper_id; + uint32_t expected_tokens; + uint32_t total_delta; + uint64_t total_cycles; + uint32_t average_cycles; sc = rtems_task_create( - rtems_build_name('S', 'T', 'O', 'P'), + rtems_build_name( 'S', 'T', 'O', 'P' ), PRIO_STOP, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &stopper_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index) { + for ( runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index ) { sc = rtems_task_create( - rtems_build_name('R', 'U', 'N', (char) ('0' + runner_index)), + rtems_build_name( 'R', 'U', 'N', (char) ( '0' + runner_index ) ), PRIO_HIGH + runner_index, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->runner_ids[runner_index] + &ctx->runner_ids[ runner_index ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index) { - sc = rtems_task_start(ctx->runner_ids[runner_index], runner, runner_index); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index ) { + sc = rtems_task_start( + ctx->runner_ids[ runner_index ], + runner, + runner_index + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_task_wake_after(10 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 10 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(stopper_id, stopper, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( stopper_id, stopper, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index) { - sc = rtems_task_delete(ctx->runner_ids[runner_index]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index ) { + sc = rtems_task_delete( ctx->runner_ids[ runner_index ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } total_cycles = 0; - for (runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index) { - const test_counters *counters = &ctx->counters[runner_index]; - size_t cpu; + for ( runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index ) { + const test_counters *counters = &ctx->counters[ runner_index ]; + size_t cpu; - for (cpu = 0; cpu < CPU_COUNT; ++cpu) { - total_cycles += counters->cycles_per_cpu[cpu].counter; + for ( cpu = 0; cpu < CPU_COUNT; ++cpu ) { + total_cycles += counters->cycles_per_cpu[ cpu ].counter; } } - average_cycles = (uint32_t) (total_cycles / (RUNNER_COUNT * CPU_COUNT)); + average_cycles = (uint32_t) ( total_cycles / ( RUNNER_COUNT * CPU_COUNT ) ); printf( "total cycles %" PRIu64 "\n" @@ -190,17 +196,17 @@ static void test(void) average_cycles ); - for (runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index) { - const test_counters *counters = &ctx->counters[runner_index]; - size_t cpu; + for ( runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index ) { + const test_counters *counters = &ctx->counters[ runner_index ]; + size_t cpu; - printf("runner %" PRIuPTR "\n", runner_index); + printf( "runner %" PRIuPTR "\n", runner_index ); - for (cpu = 0; cpu < CPU_COUNT; ++cpu) { - uint32_t tokens = counters->tokens_per_cpu[cpu].counter; - uint32_t cycles = counters->cycles_per_cpu[cpu].counter; - double cycle_deviation = ((double) cycles - average_cycles) - / average_cycles; + for ( cpu = 0; cpu < CPU_COUNT; ++cpu ) { + uint32_t tokens = counters->tokens_per_cpu[ cpu ].counter; + uint32_t cycles = counters->cycles_per_cpu[ cpu ].counter; + double cycle_deviation = ( (double) cycles - average_cycles ) / + average_cycles; printf( "\tcpu %zu tokens %" PRIu32 "\n" @@ -216,38 +222,38 @@ static void test(void) } } - expected_tokens = ctx->counters[0].tokens_per_cpu[0].counter; + expected_tokens = ctx->counters[ 0 ].tokens_per_cpu[ 0 ].counter; total_delta = 0; - for (runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index) { - test_counters *counters = &ctx->counters[runner_index]; - size_t cpu; + for ( runner_index = 0; runner_index < RUNNER_COUNT; ++runner_index ) { + test_counters *counters = &ctx->counters[ runner_index ]; + size_t cpu; - for (cpu = 0; cpu < CPU_COUNT; ++cpu) { - uint32_t tokens = counters->tokens_per_cpu[cpu].counter; - uint32_t delta = abs_delta(tokens, expected_tokens); + for ( cpu = 0; cpu < CPU_COUNT; ++cpu ) { + uint32_t tokens = counters->tokens_per_cpu[ cpu ].counter; + uint32_t delta = abs_delta( tokens, expected_tokens ); - rtems_test_assert(delta <= 1); + rtems_test_assert( delta <= 1 ); total_delta += delta; } } - rtems_test_assert(total_delta <= (RUNNER_COUNT * CPU_COUNT - 1)); + rtems_test_assert( total_delta <= ( RUNNER_COUNT * CPU_COUNT - 1 ) ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - rtems_print_printer_fprintf_putc(&rtems_test_printer); + rtems_print_printer_fprintf_putc( &rtems_test_printer ); TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() >= 2) { + if ( rtems_scheduler_get_processor_maximum() >= 2 ) { test(); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -255,7 +261,7 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT -#define CONFIGURE_MAXIMUM_TASKS (2 + RUNNER_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 2 + RUNNER_COUNT ) #define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT diff --git a/testsuites/smptests/smpmigration02/init.c b/testsuites/smptests/smpmigration02/init.c index e611963549..5eeb31d96a 100644 --- a/testsuites/smptests/smpmigration02/init.c +++ b/testsuites/smptests/smpmigration02/init.c @@ -40,7 +40,7 @@ const char rtems_test_name[] = "SMPMIGRATION 2"; #define CPU_COUNT 32 -#define TASK_COUNT (CPU_COUNT + 1) +#define TASK_COUNT ( CPU_COUNT + 1 ) #define PRIO_LOW 3 @@ -48,253 +48,253 @@ const char rtems_test_name[] = "SMPMIGRATION 2"; typedef struct { uint32_t value; - uint32_t cache_line_separation[31]; + uint32_t cache_line_separation[ 31 ]; } test_counter; typedef struct { - test_counter counters[TASK_COUNT]; - rtems_id scheduler_ids[CPU_COUNT]; - rtems_id task_ids[TASK_COUNT]; + test_counter counters[ TASK_COUNT ]; + rtems_id scheduler_ids[ CPU_COUNT ]; + rtems_id task_ids[ TASK_COUNT ]; } test_context; static test_context test_instance; -static rtems_task_priority migration_task_prio(uint32_t task_index) +static rtems_task_priority migration_task_prio( uint32_t task_index ) { return task_index > 0 ? PRIO_LOW : PRIO_HIGH; } -static void migration_task(rtems_task_argument arg) +static void migration_task( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; - uint32_t task_index = arg; - rtems_task_priority prio = migration_task_prio(task_index); - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t cpu_index = rtems_scheduler_get_processor(); + test_context *ctx = &test_instance; + uint32_t task_index = arg; + rtems_task_priority prio = migration_task_prio( task_index ); + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t cpu_index = rtems_scheduler_get_processor(); - while (true) { + while ( true ) { rtems_status_code sc; - cpu_index = (cpu_index + 1) % cpu_count; + cpu_index = ( cpu_index + 1 ) % cpu_count; sc = rtems_task_set_scheduler( RTEMS_SELF, - ctx->scheduler_ids[cpu_index], + ctx->scheduler_ids[ cpu_index ], prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - ++ctx->counters[task_index].value; + ++ctx->counters[ task_index ].value; - rtems_test_assert(cpu_index == rtems_scheduler_get_processor()); + rtems_test_assert( cpu_index == rtems_scheduler_get_processor() ); } } -static void test_migrations(test_context *ctx) +static void test_migrations( test_context *ctx ) { rtems_status_code sc; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t task_count = cpu_count + 1; - uint32_t task_index; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t task_count = cpu_count + 1; + uint32_t task_index; - for (task_index = 0; task_index < task_count; ++task_index) { + for ( task_index = 0; task_index < task_count; ++task_index ) { rtems_id task_id; sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_set_scheduler( task_id, - ctx->scheduler_ids[task_index % cpu_count], - migration_task_prio(task_index) + ctx->scheduler_ids[ task_index % cpu_count ], + migration_task_prio( task_index ) ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(task_id, migration_task, task_index); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_id, migration_task, task_index ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - ctx->task_ids[task_index] = task_id; + ctx->task_ids[ task_index ] = task_id; } - sc = rtems_task_wake_after(30 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 30 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (task_index = 0; task_index < task_count; ++task_index) { + for ( task_index = 0; task_index < task_count; ++task_index ) { printf( "task %" PRIu32 " counter: %" PRIu32 "\n", task_index, - ctx->counters[task_index].value + ctx->counters[ task_index ].value ); - sc = rtems_task_delete(ctx->task_ids[task_index]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->task_ids[ task_index ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void busy_loop_task(rtems_task_argument arg) +static void busy_loop_task( rtems_task_argument arg ) { (void) arg; - while (true) { + while ( true ) { /* Do nothing */ } } -static Thread_Control *get_thread_by_id(rtems_id task_id) +static Thread_Control *get_thread_by_id( rtems_id task_id ) { ISR_lock_Context lock_context; - Thread_Control *thread; + Thread_Control *thread; - thread = _Thread_Get(task_id, &lock_context); - rtems_test_assert(thread != NULL); - _ISR_lock_ISR_enable(&lock_context); + thread = _Thread_Get( task_id, &lock_context ); + rtems_test_assert( thread != NULL ); + _ISR_lock_ISR_enable( &lock_context ); return thread; } -static void test_double_migration(test_context *ctx) +static void test_double_migration( test_context *ctx ) { uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - if (cpu_count >= 2) { + if ( cpu_count >= 2 ) { rtems_status_code sc; - rtems_id task_id; - rtems_id scheduler_id; - uint32_t cpu_self_index = 0; - uint32_t cpu_other_index = 1; - Per_CPU_Control *cpu_self = _Per_CPU_Get_by_index(cpu_self_index); - Per_CPU_Control *cpu_other = _Per_CPU_Get_by_index(cpu_other_index); - Per_CPU_Control *cpu_self_dispatch_disabled; - Thread_Control *self; - Thread_Control *other; + rtems_id task_id; + rtems_id scheduler_id; + uint32_t cpu_self_index = 0; + uint32_t cpu_other_index = 1; + Per_CPU_Control *cpu_self = _Per_CPU_Get_by_index( cpu_self_index ); + Per_CPU_Control *cpu_other = _Per_CPU_Get_by_index( cpu_other_index ); + Per_CPU_Control *cpu_self_dispatch_disabled; + Thread_Control *self; + Thread_Control *other; - sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_get_scheduler( RTEMS_SELF, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(scheduler_id == ctx->scheduler_ids[cpu_self_index]); + rtems_test_assert( scheduler_id == ctx->scheduler_ids[ cpu_self_index ] ); sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - other = get_thread_by_id(task_id); + other = get_thread_by_id( task_id ); sc = rtems_task_set_scheduler( task_id, - ctx->scheduler_ids[cpu_other_index], + ctx->scheduler_ids[ cpu_other_index ], 2 ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(task_id, busy_loop_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_id, busy_loop_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (!_Thread_Is_executing_on_a_processor(other)) { + while ( !_Thread_Is_executing_on_a_processor( other ) ) { /* Wait */ } cpu_self_dispatch_disabled = _Thread_Dispatch_disable(); - rtems_test_assert(cpu_self == cpu_self_dispatch_disabled); + rtems_test_assert( cpu_self == cpu_self_dispatch_disabled ); self = _Thread_Executing; - rtems_test_assert(cpu_self->executing == self); - rtems_test_assert(cpu_self->heir == self); - rtems_test_assert(!cpu_self->dispatch_necessary); + rtems_test_assert( cpu_self->executing == self ); + rtems_test_assert( cpu_self->heir == self ); + rtems_test_assert( !cpu_self->dispatch_necessary ); - rtems_test_assert(cpu_other->executing == other); - rtems_test_assert(cpu_other->heir == other); - rtems_test_assert(!cpu_other->dispatch_necessary); + rtems_test_assert( cpu_other->executing == other ); + rtems_test_assert( cpu_other->heir == other ); + rtems_test_assert( !cpu_other->dispatch_necessary ); sc = rtems_task_set_scheduler( RTEMS_SELF, - ctx->scheduler_ids[cpu_other_index], + ctx->scheduler_ids[ cpu_other_index ], 1 ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(cpu_self->executing == self); - rtems_test_assert(cpu_self->heir != self); - rtems_test_assert(cpu_self->dispatch_necessary); + rtems_test_assert( cpu_self->executing == self ); + rtems_test_assert( cpu_self->heir != self ); + rtems_test_assert( cpu_self->dispatch_necessary ); - while (_Thread_Is_executing_on_a_processor(other)) { + while ( _Thread_Is_executing_on_a_processor( other ) ) { /* Wait */ } - rtems_test_assert(cpu_other->executing == self); - rtems_test_assert(cpu_other->heir == self); - rtems_test_assert(!cpu_other->dispatch_necessary); + rtems_test_assert( cpu_other->executing == self ); + rtems_test_assert( cpu_other->heir == self ); + rtems_test_assert( !cpu_other->dispatch_necessary ); sc = rtems_task_set_scheduler( RTEMS_SELF, - ctx->scheduler_ids[cpu_self_index], + ctx->scheduler_ids[ cpu_self_index ], 1 ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(cpu_self->executing == self); - rtems_test_assert(cpu_self->heir == self); - rtems_test_assert(cpu_self->dispatch_necessary); + rtems_test_assert( cpu_self->executing == self ); + rtems_test_assert( cpu_self->heir == self ); + rtems_test_assert( cpu_self->dispatch_necessary ); - rtems_test_assert(cpu_other->heir == other); + rtems_test_assert( cpu_other->heir == other ); - _Thread_Dispatch_enable(cpu_self_dispatch_disabled); + _Thread_Dispatch_enable( cpu_self_dispatch_disabled ); - while (!_Thread_Is_executing_on_a_processor(other)) { + while ( !_Thread_Is_executing_on_a_processor( other ) ) { /* Wait */ } - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void init_scheduler_ids(test_context *ctx) +static void init_scheduler_ids( test_context *ctx ) { rtems_status_code sc; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t cpu_index; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t cpu_index; - for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) { - sc = rtems_scheduler_ident(cpu_index, &ctx->scheduler_ids[cpu_index]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( cpu_index = 0; cpu_index < cpu_count; ++cpu_index ) { + sc = rtems_scheduler_ident( cpu_index, &ctx->scheduler_ids[ cpu_index ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_resource_snapshot snapshot; TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); - init_scheduler_ids(ctx); - test_double_migration(ctx); - test_migrations(ctx); + init_scheduler_ids( ctx ); + test_double_migration( ctx ); + test_migrations( ctx ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -306,108 +306,108 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_SIMPLE_SMP(0); -RTEMS_SCHEDULER_SIMPLE_SMP(1); -RTEMS_SCHEDULER_SIMPLE_SMP(2); -RTEMS_SCHEDULER_SIMPLE_SMP(3); -RTEMS_SCHEDULER_SIMPLE_SMP(4); -RTEMS_SCHEDULER_SIMPLE_SMP(5); -RTEMS_SCHEDULER_SIMPLE_SMP(6); -RTEMS_SCHEDULER_SIMPLE_SMP(7); -RTEMS_SCHEDULER_SIMPLE_SMP(8); -RTEMS_SCHEDULER_SIMPLE_SMP(9); -RTEMS_SCHEDULER_SIMPLE_SMP(10); -RTEMS_SCHEDULER_SIMPLE_SMP(11); -RTEMS_SCHEDULER_SIMPLE_SMP(12); -RTEMS_SCHEDULER_SIMPLE_SMP(13); -RTEMS_SCHEDULER_SIMPLE_SMP(14); -RTEMS_SCHEDULER_SIMPLE_SMP(15); -RTEMS_SCHEDULER_SIMPLE_SMP(16); -RTEMS_SCHEDULER_SIMPLE_SMP(17); -RTEMS_SCHEDULER_SIMPLE_SMP(18); -RTEMS_SCHEDULER_SIMPLE_SMP(19); -RTEMS_SCHEDULER_SIMPLE_SMP(20); -RTEMS_SCHEDULER_SIMPLE_SMP(21); -RTEMS_SCHEDULER_SIMPLE_SMP(22); -RTEMS_SCHEDULER_SIMPLE_SMP(23); -RTEMS_SCHEDULER_SIMPLE_SMP(24); -RTEMS_SCHEDULER_SIMPLE_SMP(25); -RTEMS_SCHEDULER_SIMPLE_SMP(26); -RTEMS_SCHEDULER_SIMPLE_SMP(27); -RTEMS_SCHEDULER_SIMPLE_SMP(28); -RTEMS_SCHEDULER_SIMPLE_SMP(29); -RTEMS_SCHEDULER_SIMPLE_SMP(30); -RTEMS_SCHEDULER_SIMPLE_SMP(31); +RTEMS_SCHEDULER_SIMPLE_SMP( 0 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 1 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 2 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 3 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 4 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 5 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 6 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 7 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 8 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 9 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 10 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 11 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 12 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 13 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 14 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 15 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 16 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 17 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 18 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 19 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 20 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 21 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 22 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 23 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 24 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 25 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 26 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 27 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 28 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 29 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 30 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 31 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(0, 0), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(1, 1), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(2, 2), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(3, 3), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(4, 4), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(5, 5), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(6, 6), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(7, 7), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(8, 8), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(9, 9), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(10, 10), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(11, 11), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(12, 12), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(13, 13), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(14, 14), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(15, 15), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(16, 16), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(17, 17), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(18, 18), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(19, 19), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(20, 20), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(21, 21), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(22, 22), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(23, 23), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(24, 24), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(25, 25), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(26, 26), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(27, 27), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(28, 28), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(29, 29), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(30, 30), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(31, 31) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 0, 0 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 1, 1 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 2, 2 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 3, 3 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 4, 4 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 5, 5 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 6, 6 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 7, 7 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 8, 8 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 9, 9 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 10, 10 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 11, 11 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 12, 12 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 13, 13 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 14, 14 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 15, 15 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 16, 16 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 17, 17 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 18, 18 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 19, 19 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 20, 20 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 21, 21 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 22, 22 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 23, 23 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 24, 24 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 25, 25 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 26, 26 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 27, 27 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 28, 28 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 29, 29 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 30, 30 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 31, 31 ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(17, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(18, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(19, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(20, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(21, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(22, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(23, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(24, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(25, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(26, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(27, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(28, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(29, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(30, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(31, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 17, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 18, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 19, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 20, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 21, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 22, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 23, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 24, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 25, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 26, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 27, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 28, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 29, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 30, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 31, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) -#define CONFIGURE_MAXIMUM_TASKS (1 + TASK_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + TASK_COUNT ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpmrsp01/init.c b/testsuites/smptests/smpmrsp01/init.c index 99294bf163..a068479e8a 100644 --- a/testsuites/smptests/smpmrsp01/init.c +++ b/testsuites/smptests/smpmrsp01/init.c @@ -53,246 +53,248 @@ const char rtems_test_name[] = "SMPMRSP 1"; typedef struct { uint32_t sleep; uint32_t timeout; - uint32_t obtain[MRSP_COUNT]; - uint32_t cpu[CPU_COUNT]; + uint32_t obtain[ MRSP_COUNT ]; + uint32_t cpu[ CPU_COUNT ]; } counter; typedef struct { - uint32_t cpu_index; + uint32_t cpu_index; const Thread_Control *executing; const Thread_Control *heir; const Thread_Control *heir_node; - Priority_Control heir_priority; + Priority_Control heir_priority; } switch_event; typedef struct { - rtems_id main_task_id; - rtems_id migration_task_id; - rtems_id low_task_id[2]; - rtems_id high_task_id[2]; - rtems_id timer_id; - rtems_id counting_sem_id; - rtems_id mrsp_ids[MRSP_COUNT]; - rtems_id scheduler_ids[CPU_COUNT]; - rtems_id worker_ids[2 * CPU_COUNT]; - volatile bool stop_worker[2 * CPU_COUNT]; - counter counters[2 * CPU_COUNT]; - uint32_t migration_counters[CPU_COUNT]; - Thread_Control *worker_task; + rtems_id main_task_id; + rtems_id migration_task_id; + rtems_id low_task_id[ 2 ]; + rtems_id high_task_id[ 2 ]; + rtems_id timer_id; + rtems_id counting_sem_id; + rtems_id mrsp_ids[ MRSP_COUNT ]; + rtems_id scheduler_ids[ CPU_COUNT ]; + rtems_id worker_ids[ 2 * CPU_COUNT ]; + volatile bool stop_worker[ 2 * CPU_COUNT ]; + counter counters[ 2 * CPU_COUNT ]; + uint32_t migration_counters[ CPU_COUNT ]; + Thread_Control *worker_task; SMP_barrier_Control barrier; - SMP_lock_Control switch_lock; - size_t switch_index; - switch_event switch_events[32]; - volatile bool high_run[2]; - volatile bool low_run[2]; + SMP_lock_Control switch_lock; + size_t switch_index; + switch_event switch_events[ 32 ]; + volatile bool high_run[ 2 ]; + volatile bool low_run[ 2 ]; } test_context; static test_context test_instance = { - .switch_lock = SMP_LOCK_INITIALIZER("test instance switch lock") + .switch_lock = SMP_LOCK_INITIALIZER( "test instance switch lock" ) }; -static void busy_wait(void) +static void busy_wait( void ) { - rtems_interval later = rtems_clock_tick_later(2); + rtems_interval later = rtems_clock_tick_later( 2 ); - while (rtems_clock_tick_before(later)) { + while ( rtems_clock_tick_before( later ) ) { /* Wait */ } } -static void barrier_init(test_context *ctx) +static void barrier_init( test_context *ctx ) { - _SMP_barrier_Control_initialize(&ctx->barrier); + _SMP_barrier_Control_initialize( &ctx->barrier ); } -static void barrier(test_context *ctx, SMP_barrier_State *bs) +static void barrier( test_context *ctx, SMP_barrier_State *bs ) { - _SMP_barrier_Wait(&ctx->barrier, bs, 2); + _SMP_barrier_Wait( &ctx->barrier, bs, 2 ); } -static void barrier_and_delay(test_context *ctx, SMP_barrier_State *bs) +static void barrier_and_delay( test_context *ctx, SMP_barrier_State *bs ) { - barrier(ctx, bs); + barrier( ctx, bs ); busy_wait(); } -static rtems_task_priority get_prio(rtems_id task_id) +static rtems_task_priority get_prio( rtems_id task_id ) { - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority prio; - sc = rtems_task_set_priority(task_id, RTEMS_CURRENT_PRIORITY, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( task_id, RTEMS_CURRENT_PRIORITY, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); return prio; } -static void wait_for_prio(rtems_id task_id, rtems_task_priority prio) +static void wait_for_prio( rtems_id task_id, rtems_task_priority prio ) { - while (get_prio(task_id) != prio) { + while ( get_prio( task_id ) != prio ) { /* Wait */ } } -static void assert_prio(rtems_id task_id, rtems_task_priority expected_prio) +static void assert_prio( rtems_id task_id, rtems_task_priority expected_prio ) { - rtems_test_assert(get_prio(task_id) == expected_prio); + rtems_test_assert( get_prio( task_id ) == expected_prio ); } -static void change_prio(rtems_id task_id, rtems_task_priority prio) +static void change_prio( rtems_id task_id, rtems_task_priority prio ) { rtems_status_code sc; - sc = rtems_task_set_priority(task_id, prio, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( task_id, prio, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void assert_executing_worker(test_context *ctx) +static void assert_executing_worker( test_context *ctx ) { rtems_test_assert( - _CPU_Context_Get_is_executing(&ctx->worker_task->Registers) + _CPU_Context_Get_is_executing( &ctx->worker_task->Registers ) ); } -static void switch_extension(Thread_Control *executing, Thread_Control *heir) +static void switch_extension( Thread_Control *executing, Thread_Control *heir ) { - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; SMP_lock_Context lock_context; - size_t i; + size_t i; - _SMP_lock_ISR_disable_and_acquire(&ctx->switch_lock, &lock_context); + _SMP_lock_ISR_disable_and_acquire( &ctx->switch_lock, &lock_context ); i = ctx->switch_index; - if (i < SWITCH_EVENT_COUNT) { - switch_event *e = &ctx->switch_events[i]; - Scheduler_SMP_Node *node = _Scheduler_SMP_Thread_get_node(heir); + if ( i < SWITCH_EVENT_COUNT ) { + switch_event *e = &ctx->switch_events[ i ]; + Scheduler_SMP_Node *node = _Scheduler_SMP_Thread_get_node( heir ); e->cpu_index = rtems_scheduler_get_processor(); e->executing = executing; e->heir = heir; - e->heir_node = _Scheduler_Node_get_owner(&node->Base); + e->heir_node = _Scheduler_Node_get_owner( &node->Base ); e->heir_priority = node->priority; ctx->switch_index = i + 1; } - _SMP_lock_Release_and_ISR_enable(&ctx->switch_lock, &lock_context); + _SMP_lock_Release_and_ISR_enable( &ctx->switch_lock, &lock_context ); } -static void reset_switch_events(test_context *ctx) +static void reset_switch_events( test_context *ctx ) { SMP_lock_Context lock_context; - _SMP_lock_ISR_disable_and_acquire(&ctx->switch_lock, &lock_context); + _SMP_lock_ISR_disable_and_acquire( &ctx->switch_lock, &lock_context ); ctx->switch_index = 0; - _SMP_lock_Release_and_ISR_enable(&ctx->switch_lock, &lock_context); + _SMP_lock_Release_and_ISR_enable( &ctx->switch_lock, &lock_context ); } -static size_t get_switch_events(test_context *ctx) +static size_t get_switch_events( test_context *ctx ) { SMP_lock_Context lock_context; - size_t events; + size_t events; - _SMP_lock_ISR_disable_and_acquire(&ctx->switch_lock, &lock_context); + _SMP_lock_ISR_disable_and_acquire( &ctx->switch_lock, &lock_context ); events = ctx->switch_index; - _SMP_lock_Release_and_ISR_enable(&ctx->switch_lock, &lock_context); + _SMP_lock_Release_and_ISR_enable( &ctx->switch_lock, &lock_context ); return events; } -static void print_switch_events(test_context *ctx) +static void print_switch_events( test_context *ctx ) { - size_t n = get_switch_events(ctx); + size_t n = get_switch_events( ctx ); size_t i; - for (i = 0; i < n; ++i) { - switch_event *e = &ctx->switch_events[i]; - char ex[5]; - char hr[5]; - char hn[5]; + for ( i = 0; i < n; ++i ) { + switch_event *e = &ctx->switch_events[ i ]; + char ex[ 5 ]; + char hr[ 5 ]; + char hn[ 5 ]; - rtems_object_get_name(e->executing->Object.id, sizeof(ex), &ex[0]); - rtems_object_get_name(e->heir->Object.id, sizeof(hr), &hr[0]); - rtems_object_get_name(e->heir_node->Object.id, sizeof(hn), &hn[0]); + rtems_object_get_name( e->executing->Object.id, sizeof( ex ), &ex[ 0 ] ); + rtems_object_get_name( e->heir->Object.id, sizeof( hr ), &hr[ 0 ] ); + rtems_object_get_name( e->heir_node->Object.id, sizeof( hn ), &hn[ 0 ] ); printf( "[%" PRIu32 "] %4s -> %4s (prio %3" PRIu64 ", node %4s)\n", e->cpu_index, - &ex[0], - &hr[0], + &ex[ 0 ], + &hr[ 0 ], e->heir_priority, - &hn[0] + &hn[ 0 ] ); } } -static void create_timer(test_context *ctx) +static void create_timer( test_context *ctx ) { rtems_status_code sc; sc = rtems_timer_create( - rtems_build_name('T', 'I', 'M', 'R'), + rtems_build_name( 'T', 'I', 'M', 'R' ), &ctx->timer_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void delete_timer(test_context *ctx) +static void delete_timer( test_context *ctx ) { rtems_status_code sc; - sc = rtems_timer_delete(ctx->timer_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_delete( ctx->timer_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void fire_timer( - test_context *ctx, - rtems_interval interval, + test_context *ctx, + rtems_interval interval, rtems_timer_service_routine_entry routine ) { rtems_status_code sc; - sc = rtems_timer_fire_after(ctx->timer_id, interval, routine, ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_fire_after( ctx->timer_id, interval, routine, ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void create_mrsp_sema( - test_context *ctx, - rtems_id *id, + test_context *ctx, + rtems_id *id, rtems_task_priority prio ) { - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t index; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t index; rtems_status_code sc; sc = rtems_semaphore_create( - rtems_build_name('M', 'R', 'S', 'P'), + rtems_build_name( 'M', 'R', 'S', 'P' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING, prio, id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (index = 1; index < cpu_count; index = ((index + 2) & ~UINT32_C(1))) { + for ( + index = 1; index < cpu_count; index = ( ( index + 2 ) & ~UINT32_C( 1 ) ) + ) { rtems_task_priority old_prio; old_prio = 1; sc = rtems_semaphore_set_priority( *id, - ctx->scheduler_ids[index], + ctx->scheduler_ids[ index ], prio, &old_prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(old_prio == 0); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( old_prio == 0 ); } } -static void run_task(rtems_task_argument arg) +static void run_task( rtems_task_argument arg ) { (void) arg; @@ -300,117 +302,125 @@ static void run_task(rtems_task_argument arg) *run = true; - while (true) { + while ( true ) { /* Do nothing */ } } -static void obtain_and_release_worker(rtems_task_argument arg) +static void obtain_and_release_worker( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; ctx->worker_task = _Thread_Get_executing(); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); /* Obtain with timeout (A) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, 4); - rtems_test_assert(sc == RTEMS_TIMEOUT); + sc = rtems_semaphore_obtain( ctx->mrsp_ids[ 0 ], RTEMS_WAIT, 4 ); + rtems_test_assert( sc == RTEMS_TIMEOUT ); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); /* Obtain with priority change and timeout (B) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, 4); - rtems_test_assert(sc == RTEMS_TIMEOUT); + sc = rtems_semaphore_obtain( ctx->mrsp_ids[ 0 ], RTEMS_WAIT, 4 ); + rtems_test_assert( sc == RTEMS_TIMEOUT ); - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); /* Restore priority (C) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); /* Obtain without timeout (D) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); /* Obtain and help with timeout (E) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, 4); - rtems_test_assert(sc == RTEMS_TIMEOUT); + sc = rtems_semaphore_obtain( ctx->mrsp_ids[ 0 ], RTEMS_WAIT, 4 ); + rtems_test_assert( sc == RTEMS_TIMEOUT ); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); - sc = rtems_task_suspend(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Worker done (H) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - while (true) { + while ( true ) { /* Wait for termination */ } } -static void test_mrsp_obtain_and_release(test_context *ctx) +static void test_mrsp_obtain_and_release( test_context *ctx ) { - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority prio; - rtems_id scheduler_id; - SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; + rtems_id scheduler_id; + SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; - puts("test MrsP obtain and release"); + puts( "test MrsP obtain and release" ); - change_prio(RTEMS_SELF, 3); + change_prio( RTEMS_SELF, 3 ); - barrier_init(ctx); - reset_switch_events(ctx); + barrier_init( ctx ); + reset_switch_events( ctx ); - ctx->high_run[0] = false; + ctx->high_run[ 0 ] = false; sc = rtems_task_create( - rtems_build_name('H', 'I', 'G', '0'), + rtems_build_name( 'H', 'I', 'G', '0' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->high_task_id[0] + &ctx->high_task_id[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Check executing task parameters */ - sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_get_scheduler( RTEMS_SELF, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(ctx->scheduler_ids[0] == scheduler_id); + rtems_test_assert( ctx->scheduler_ids[ 0 ] == scheduler_id ); /* Create a MrsP semaphore object and lock it */ - create_mrsp_sema(ctx, &ctx->mrsp_ids[0], 2); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 0 ], 2 ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); /* * The ceiling priority values per scheduler are equal to the value specified @@ -419,1091 +429,1167 @@ static void test_mrsp_obtain_and_release(test_context *ctx) prio = RTEMS_CURRENT_PRIORITY; sc = rtems_semaphore_set_priority( - ctx->mrsp_ids[0], - ctx->scheduler_ids[0], + ctx->mrsp_ids[ 0 ], + ctx->scheduler_ids[ 0 ], prio, &prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(prio == 2); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( prio == 2 ); /* Check the old value and set a new ceiling priority for scheduler B */ prio = 3; sc = rtems_semaphore_set_priority( - ctx->mrsp_ids[0], - ctx->scheduler_ids[1], + ctx->mrsp_ids[ 0 ], + ctx->scheduler_ids[ 1 ], prio, &prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(prio == 2); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( prio == 2 ); /* Check the ceiling priority values */ prio = RTEMS_CURRENT_PRIORITY; sc = rtems_semaphore_set_priority( - ctx->mrsp_ids[0], - ctx->scheduler_ids[0], + ctx->mrsp_ids[ 0 ], + ctx->scheduler_ids[ 0 ], prio, &prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(prio == 2); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( prio == 2 ); prio = RTEMS_CURRENT_PRIORITY; sc = rtems_semaphore_set_priority( - ctx->mrsp_ids[0], - ctx->scheduler_ids[1], + ctx->mrsp_ids[ 0 ], + ctx->scheduler_ids[ 1 ], prio, &prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(prio == 3); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( prio == 3 ); /* Check that a thread waiting to get ownership remains executing */ sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->worker_ids[0] + &ctx->worker_ids[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(ctx->worker_ids[0], ctx->scheduler_ids[1], 4); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( + ctx->worker_ids[ 0 ], + ctx->scheduler_ids[ 1 ], + 4 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->worker_ids[0], obtain_and_release_worker, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->worker_ids[ 0 ], obtain_and_release_worker, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Obtain with timeout (A) */ - barrier_and_delay(ctx, &barrier_state); + barrier_and_delay( ctx, &barrier_state ); - assert_prio(ctx->worker_ids[0], 3); - assert_executing_worker(ctx); + assert_prio( ctx->worker_ids[ 0 ], 3 ); + assert_executing_worker( ctx ); /* Obtain with priority change and timeout (B) */ - barrier_and_delay(ctx, &barrier_state); + barrier_and_delay( ctx, &barrier_state ); - assert_prio(ctx->worker_ids[0], 3); - change_prio(ctx->worker_ids[0], 2); - assert_executing_worker(ctx); + assert_prio( ctx->worker_ids[ 0 ], 3 ); + change_prio( ctx->worker_ids[ 0 ], 2 ); + assert_executing_worker( ctx ); /* Restore priority (C) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - assert_prio(ctx->worker_ids[0], 2); - change_prio(ctx->worker_ids[0], 4); + assert_prio( ctx->worker_ids[ 0 ], 2 ); + change_prio( ctx->worker_ids[ 0 ], 4 ); /* Obtain without timeout (D) */ - barrier_and_delay(ctx, &barrier_state); + barrier_and_delay( ctx, &barrier_state ); - assert_prio(ctx->worker_ids[0], 3); - assert_executing_worker(ctx); + assert_prio( ctx->worker_ids[ 0 ], 3 ); + assert_executing_worker( ctx ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Check that a timeout works in case the waiting thread actually helps */ - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Obtain and help with timeout (E) */ - barrier_and_delay(ctx, &barrier_state); + barrier_and_delay( ctx, &barrier_state ); sc = rtems_task_start( - ctx->high_task_id[0], + ctx->high_task_id[ 0 ], run_task, - (rtems_task_argument) &ctx->high_run[0] + (rtems_task_argument) &ctx->high_run[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - while (rtems_scheduler_get_processor() != 0) { + while ( rtems_scheduler_get_processor() != 0 ) { /* Wait */ } - rtems_test_assert(ctx->high_run[0]); + rtems_test_assert( ctx->high_run[ 0 ] ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - print_switch_events(ctx); + print_switch_events( ctx ); /* Worker done (H) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_task_delete(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void obtain_after_migration_worker(rtems_task_argument arg) +static void obtain_after_migration_worker( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Worker done (K) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - while (true) { + while ( true ) { /* Wait for termination */ } } -static void obtain_after_migration_high(rtems_task_argument arg) +static void obtain_after_migration_high( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[1], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 1 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Obtain done (I) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); /* Ready to release (J) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_semaphore_release(ctx->mrsp_ids[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(0); + rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( 0 ); } -static void test_mrsp_obtain_after_migration(test_context *ctx) +static void test_mrsp_obtain_after_migration( test_context *ctx ) { - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority prio; - rtems_id scheduler_id; - SMP_barrier_State barrier_state; + rtems_id scheduler_id; + SMP_barrier_State barrier_state; - puts("test MrsP obtain after migration"); + puts( "test MrsP obtain after migration" ); - change_prio(RTEMS_SELF, 3); + change_prio( RTEMS_SELF, 3 ); - barrier_init(ctx); - reset_switch_events(ctx); + barrier_init( ctx ); + reset_switch_events( ctx ); /* Create tasks */ sc = rtems_task_create( - rtems_build_name('H', 'I', 'G', '0'), + rtems_build_name( 'H', 'I', 'G', '0' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->high_task_id[0] + &ctx->high_task_id[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->worker_ids[0] + &ctx->worker_ids[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(ctx->worker_ids[0], ctx->scheduler_ids[1], 3); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( + ctx->worker_ids[ 0 ], + ctx->scheduler_ids[ 1 ], + 3 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Create a MrsP semaphore objects */ - create_mrsp_sema(ctx, &ctx->mrsp_ids[0], 3); - create_mrsp_sema(ctx, &ctx->mrsp_ids[1], 2); - create_mrsp_sema(ctx, &ctx->mrsp_ids[2], 1); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 0 ], 3 ); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 1 ], 2 ); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 2 ], 1 ); prio = 4; sc = rtems_semaphore_set_priority( - ctx->mrsp_ids[2], - ctx->scheduler_ids[1], + ctx->mrsp_ids[ 2 ], + ctx->scheduler_ids[ 1 ], prio, &prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(prio == 1); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( prio == 1 ); /* Check executing task parameters */ - sc = rtems_task_get_scheduler(RTEMS_SELF, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_get_scheduler( RTEMS_SELF, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(ctx->scheduler_ids[0] == scheduler_id); + rtems_test_assert( ctx->scheduler_ids[ 0 ] == scheduler_id ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); /* Start other tasks */ - sc = rtems_task_start(ctx->worker_ids[0], obtain_after_migration_worker, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( + ctx->worker_ids[ 0 ], + obtain_after_migration_worker, + 0 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->high_task_id[0], obtain_after_migration_high, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( + ctx->high_task_id[ 0 ], + obtain_after_migration_high, + 0 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); /* Obtain done (I) */ - _SMP_barrier_State_initialize(&barrier_state); - barrier(ctx, &barrier_state); + _SMP_barrier_State_initialize( &barrier_state ); + barrier( ctx, &barrier_state ); - sc = rtems_task_suspend(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); /* * Obtain second MrsP semaphore and ensure that we change the priority of our * own scheduler node and not the one we are currently using. */ - sc = rtems_semaphore_obtain(ctx->mrsp_ids[2], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 2 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 1); + assert_prio( RTEMS_SELF, 1 ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - sc = rtems_semaphore_release(ctx->mrsp_ids[2]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 2 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_resume(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Ready to release (J) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); /* Prepare barrier for worker */ - barrier_init(ctx); - _SMP_barrier_State_initialize(&barrier_state); + barrier_init( ctx ); + _SMP_barrier_State_initialize( &barrier_state ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - print_switch_events(ctx); + print_switch_events( ctx ); /* Worker done (K) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_task_delete(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[2]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 2 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test_mrsp_flush_error(test_context *ctx) +static void test_mrsp_flush_error( test_context *ctx ) { rtems_status_code sc; - rtems_id id; + rtems_id id; - puts("test MrsP flush error"); + puts( "test MrsP flush error" ); - create_mrsp_sema(ctx, &id, 1); + create_mrsp_sema( ctx, &id, 1 ); - sc = rtems_semaphore_flush(id); - rtems_test_assert(sc == RTEMS_NOT_DEFINED); + sc = rtems_semaphore_flush( id ); + rtems_test_assert( sc == RTEMS_NOT_DEFINED ); - sc = rtems_semaphore_delete(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test_mrsp_initially_locked(void) +static void test_mrsp_initially_locked( void ) { rtems_status_code sc; - rtems_id id; + rtems_id id; - puts("test MrsP initially locked"); + puts( "test MrsP initially locked" ); sc = rtems_semaphore_create( - rtems_build_name('M', 'R', 'S', 'P'), + rtems_build_name( 'M', 'R', 'S', 'P' ), 0, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING, 1, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test_mrsp_nested_obtain_error(test_context *ctx) +static void test_mrsp_nested_obtain_error( test_context *ctx ) { rtems_status_code sc; - rtems_id id; + rtems_id id; - puts("test MrsP nested obtain error"); + puts( "test MrsP nested obtain error" ); - create_mrsp_sema(ctx, &id, 1); + create_mrsp_sema( ctx, &id, 1 ); - sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_obtain(id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_INCORRECT_STATE); + sc = rtems_semaphore_obtain( id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_INCORRECT_STATE ); - sc = rtems_semaphore_release(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void deadlock_timer(rtems_id timer_id, void *arg) +static void deadlock_timer( rtems_id timer_id, void *arg ) { (void) timer_id; test_context *ctx = arg; - change_prio(ctx->main_task_id, 1); + change_prio( ctx->main_task_id, 1 ); } -static void deadlock_worker(rtems_task_argument arg) +static void deadlock_worker( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->mrsp_ids[1], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 1 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - fire_timer(ctx, 2, deadlock_timer); + fire_timer( ctx, 2, deadlock_timer ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->mrsp_ids[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(ctx->main_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( ctx->main_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(0); + rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( 0 ); } -static void test_mrsp_deadlock_error(test_context *ctx) +static void test_mrsp_deadlock_error( test_context *ctx ) { - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority prio = 2; - puts("test MrsP deadlock error"); + puts( "test MrsP deadlock error" ); - change_prio(RTEMS_SELF, prio); + change_prio( RTEMS_SELF, prio ); - create_timer(ctx); - create_mrsp_sema(ctx, &ctx->mrsp_ids[0], prio); - create_mrsp_sema(ctx, &ctx->mrsp_ids[1], prio); + create_timer( ctx ); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 0 ], prio ); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 1 ], prio ); sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), prio, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->worker_ids[0] + &ctx->worker_ids[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->worker_ids[0], deadlock_worker, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->worker_ids[ 0 ], deadlock_worker, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_wake_after(RTEMS_YIELD_PROCESSOR); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); prio = 1; sc = rtems_semaphore_set_priority( - ctx->mrsp_ids[1], - ctx->scheduler_ids[0], + ctx->mrsp_ids[ 1 ], + ctx->scheduler_ids[ 0 ], prio, &prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(prio == 2); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( prio == 2 ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[1], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_INCORRECT_STATE); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 1 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_INCORRECT_STATE ); sc = rtems_semaphore_set_priority( - ctx->mrsp_ids[1], - ctx->scheduler_ids[0], + ctx->mrsp_ids[ 1 ], + ctx->scheduler_ids[ 0 ], prio, &prio ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - delete_timer(ctx); + delete_timer( ctx ); } -static void test_mrsp_multiple_obtain(test_context *ctx) +static void test_mrsp_multiple_obtain( test_context *ctx ) { rtems_status_code sc; - rtems_id sem_a_id; - rtems_id sem_b_id; - rtems_id sem_c_id; + rtems_id sem_a_id; + rtems_id sem_b_id; + rtems_id sem_c_id; - puts("test MrsP multiple obtain"); + puts( "test MrsP multiple obtain" ); - change_prio(RTEMS_SELF, 4); + change_prio( RTEMS_SELF, 4 ); - create_mrsp_sema(ctx, &sem_a_id, 3); - create_mrsp_sema(ctx, &sem_b_id, 2); - create_mrsp_sema(ctx, &sem_c_id, 1); + create_mrsp_sema( ctx, &sem_a_id, 3 ); + create_mrsp_sema( ctx, &sem_b_id, 2 ); + create_mrsp_sema( ctx, &sem_c_id, 1 ); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); - sc = rtems_semaphore_obtain(sem_a_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( sem_a_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_obtain(sem_b_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( sem_b_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); - sc = rtems_semaphore_obtain(sem_c_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( sem_c_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 1); + assert_prio( RTEMS_SELF, 1 ); - sc = rtems_semaphore_release(sem_c_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( sem_c_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); - sc = rtems_semaphore_release(sem_b_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( sem_b_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_release(sem_a_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( sem_a_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); - sc = rtems_semaphore_obtain(sem_a_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( sem_a_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_obtain(sem_b_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( sem_b_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); - sc = rtems_semaphore_obtain(sem_c_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( sem_c_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 1); - change_prio(RTEMS_SELF, 3); - assert_prio(RTEMS_SELF, 1); + assert_prio( RTEMS_SELF, 1 ); + change_prio( RTEMS_SELF, 3 ); + assert_prio( RTEMS_SELF, 1 ); - sc = rtems_semaphore_release(sem_c_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( sem_c_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); - sc = rtems_semaphore_release(sem_b_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( sem_b_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_release(sem_a_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( sem_a_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_delete(sem_a_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( sem_a_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(sem_b_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( sem_b_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(sem_c_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( sem_c_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void ready_unlock_worker(rtems_task_argument arg) +static void ready_unlock_worker( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); /* Obtain (F) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); /* Done (G) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); - while (true) { + while ( true ) { /* Do nothing */ } } -static void unblock_ready_timer(rtems_id timer_id, void *arg) +static void unblock_ready_timer( rtems_id timer_id, void *arg ) { (void) timer_id; - test_context *ctx = arg; + test_context *ctx = arg; rtems_status_code sc; sc = rtems_task_start( - ctx->high_task_id[0], + ctx->high_task_id[ 0 ], run_task, - (rtems_task_argument) &ctx->high_run[0] + (rtems_task_argument) &ctx->high_run[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_suspend(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_resume(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* * At this point the scheduler node of the main thread is in the * SCHEDULER_SMP_NODE_READY state and a _Scheduler_SMP_Unblock() operation is * performed. */ - sc = rtems_event_transient_send(ctx->main_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( ctx->main_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_suspend(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void unblock_ready_owner(test_context *ctx) +static void unblock_ready_owner( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - fire_timer(ctx, 2, unblock_ready_timer); + fire_timer( ctx, 2, unblock_ready_timer ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(!ctx->high_run[0]); + rtems_test_assert( !ctx->high_run[ 0 ] ); } -static void unblock_owner_before_rival_timer(rtems_id timer_id, void *arg) +static void unblock_owner_before_rival_timer( rtems_id timer_id, void *arg ) { (void) timer_id; - test_context *ctx = arg; + test_context *ctx = arg; rtems_status_code sc; - sc = rtems_task_suspend(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_suspend(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void unblock_owner_after_rival_timer(rtems_id timer_id, void *arg) +static void unblock_owner_after_rival_timer( rtems_id timer_id, void *arg ) { (void) timer_id; - test_context *ctx = arg; + test_context *ctx = arg; rtems_status_code sc; - sc = rtems_task_suspend(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_suspend(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void various_block_unblock(test_context *ctx) +static void various_block_unblock( test_context *ctx ) { rtems_status_code sc; SMP_barrier_State barrier_state = SMP_BARRIER_STATE_INITIALIZER; /* Worker obtain (F) */ - barrier_and_delay(ctx, &barrier_state); + barrier_and_delay( ctx, &barrier_state ); - sc = rtems_task_suspend(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); busy_wait(); sc = rtems_task_start( - ctx->high_task_id[1], + ctx->high_task_id[ 1 ], run_task, - (rtems_task_argument) &ctx->high_run[1] + (rtems_task_argument) &ctx->high_run[ 1 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (!ctx->high_run[1]) { + while ( !ctx->high_run[ 1 ] ) { /* Do noting */ } - sc = rtems_task_resume(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Try to schedule a blocked active rival */ - sc = rtems_task_suspend(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_suspend(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_resume(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_resume(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); /* Use node of the active rival */ - sc = rtems_task_suspend(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_resume(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - sc = rtems_task_suspend(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_resume(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* * Try to schedule an active rival with an already scheduled active owner * user. */ - fire_timer(ctx, 2, unblock_owner_before_rival_timer); + fire_timer( ctx, 2, unblock_owner_before_rival_timer ); /* This will take the processor away from us, the timer will help later */ - sc = rtems_task_resume(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* * Try to schedule an active owner with an already scheduled active rival * user. */ - sc = rtems_task_resume(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - fire_timer(ctx, 2, unblock_owner_after_rival_timer); + fire_timer( ctx, 2, unblock_owner_after_rival_timer ); /* This will take the processor away from us, the timer will help later */ - sc = rtems_task_resume(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - assert_prio(RTEMS_SELF, 4); + assert_prio( RTEMS_SELF, 4 ); /* Worker done (G) */ - barrier(ctx, &barrier_state); + barrier( ctx, &barrier_state ); } -static void start_low_task(test_context *ctx, size_t i) +static void start_low_task( test_context *ctx, size_t i ) { rtems_status_code sc; sc = rtems_task_create( - rtems_build_name('L', 'O', 'W', '0' + i), + rtems_build_name( 'L', 'O', 'W', '0' + i ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->low_task_id[i] + &ctx->low_task_id[ i ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(ctx->low_task_id[i], ctx->scheduler_ids[i], 5); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( + ctx->low_task_id[ i ], + ctx->scheduler_ids[ i ], + 5 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_start( - ctx->low_task_id[i], + ctx->low_task_id[ i ], run_task, - (rtems_task_argument) &ctx->low_run[i] + (rtems_task_argument) &ctx->low_run[ i ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test_mrsp_various_block_and_unblock(test_context *ctx) +static void test_mrsp_various_block_and_unblock( test_context *ctx ) { rtems_status_code sc; - puts("test MrsP various block and unblock"); + puts( "test MrsP various block and unblock" ); - change_prio(RTEMS_SELF, 4); + change_prio( RTEMS_SELF, 4 ); - barrier_init(ctx); - reset_switch_events(ctx); + barrier_init( ctx ); + reset_switch_events( ctx ); - ctx->low_run[0] = false; - ctx->low_run[1] = false; - ctx->high_run[0] = false; - ctx->high_run[1] = false; + ctx->low_run[ 0 ] = false; + ctx->low_run[ 1 ] = false; + ctx->high_run[ 0 ] = false; + ctx->high_run[ 1 ] = false; - create_mrsp_sema(ctx, &ctx->mrsp_ids[0], 3); - assert_prio(RTEMS_SELF, 4); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 0 ], 3 ); + assert_prio( RTEMS_SELF, 4 ); sc = rtems_task_create( - rtems_build_name('H', 'I', 'G', '0'), + rtems_build_name( 'H', 'I', 'G', '0' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->high_task_id[0] + &ctx->high_task_id[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('H', 'I', 'G', '1'), + rtems_build_name( 'H', 'I', 'G', '1' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->high_task_id[1] + &ctx->high_task_id[ 1 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(ctx->high_task_id[1], ctx->scheduler_ids[1], 2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( + ctx->high_task_id[ 1 ], + ctx->scheduler_ids[ 1 ], + 2 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->worker_ids[0] + &ctx->worker_ids[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(ctx->worker_ids[0], ctx->scheduler_ids[1], 4); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( + ctx->worker_ids[ 0 ], + ctx->scheduler_ids[ 1 ], + 4 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->worker_ids[0], ready_unlock_worker, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->worker_ids[ 0 ], ready_unlock_worker, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - create_timer(ctx); + create_timer( ctx ); /* In case these tasks run, then we have a MrsP protocol violation */ - start_low_task(ctx, 0); - start_low_task(ctx, 1); + start_low_task( ctx, 0 ); + start_low_task( ctx, 1 ); - unblock_ready_owner(ctx); - various_block_unblock(ctx); + unblock_ready_owner( ctx ); + various_block_unblock( ctx ); - rtems_test_assert(!ctx->low_run[0]); - rtems_test_assert(!ctx->low_run[1]); + rtems_test_assert( !ctx->low_run[ 0 ] ); + rtems_test_assert( !ctx->low_run[ 1 ] ); - print_switch_events(ctx); - delete_timer(ctx); + print_switch_events( ctx ); + delete_timer( ctx ); - sc = rtems_task_delete(ctx->high_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->high_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->high_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->high_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->worker_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->worker_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->low_task_id[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->low_task_id[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->low_task_id[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->low_task_id[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test_mrsp_obtain_and_sleep_and_release(test_context *ctx) +static void test_mrsp_obtain_and_sleep_and_release( test_context *ctx ) { rtems_status_code sc; - rtems_id sem_id; - rtems_id run_task_id; - volatile bool run = false; + rtems_id sem_id; + rtems_id run_task_id; + volatile bool run = false; - puts("test MrsP obtain and sleep and release"); + puts( "test MrsP obtain and sleep and release" ); - change_prio(RTEMS_SELF, 1); + change_prio( RTEMS_SELF, 1 ); - reset_switch_events(ctx); + reset_switch_events( ctx ); sc = rtems_task_create( - rtems_build_name(' ', 'R', 'U', 'N'), + rtems_build_name( ' ', 'R', 'U', 'N' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &run_task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(run_task_id, run_task, (rtems_task_argument) &run); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( run_task_id, run_task, (rtems_task_argument) &run ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - create_mrsp_sema(ctx, &sem_id, 1); + create_mrsp_sema( ctx, &sem_id, 1 ); - rtems_test_assert(!run); + rtems_test_assert( !run ); - sc = rtems_task_wake_after(2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 2 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(run); + rtems_test_assert( run ); run = false; - sc = rtems_semaphore_obtain(sem_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( sem_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(!run); + rtems_test_assert( !run ); - sc = rtems_task_wake_after(2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 2 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(!run); + rtems_test_assert( !run ); - sc = rtems_semaphore_release(sem_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( sem_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - print_switch_events(ctx); + print_switch_events( ctx ); - sc = rtems_semaphore_delete(sem_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( sem_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(run_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( run_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void help_task(rtems_task_argument arg) +static void help_task( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (true) { + while ( true ) { /* Do nothing */ } } -static void test_mrsp_obtain_and_release_with_help(test_context *ctx) +static void test_mrsp_obtain_and_release_with_help( test_context *ctx ) { rtems_status_code sc; - rtems_id help_task_id; - rtems_id run_task_id; - volatile bool run = false; + rtems_id help_task_id; + rtems_id run_task_id; + volatile bool run = false; - puts("test MrsP obtain and release with help"); + puts( "test MrsP obtain and release with help" ); - change_prio(RTEMS_SELF, 3); + change_prio( RTEMS_SELF, 3 ); - reset_switch_events(ctx); + reset_switch_events( ctx ); - create_mrsp_sema(ctx, &ctx->mrsp_ids[0], 2); + create_mrsp_sema( ctx, &ctx->mrsp_ids[ 0 ], 2 ); - sc = rtems_semaphore_obtain(ctx->mrsp_ids[0], RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ 0 ], + RTEMS_WAIT, + RTEMS_NO_TIMEOUT + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - assert_prio(RTEMS_SELF, 2); + assert_prio( RTEMS_SELF, 2 ); sc = rtems_task_create( - rtems_build_name('H', 'E', 'L', 'P'), + rtems_build_name( 'H', 'E', 'L', 'P' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &help_task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler( - help_task_id, - ctx->scheduler_ids[1], - 3 - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( help_task_id, ctx->scheduler_ids[ 1 ], 3 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(help_task_id, help_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( help_task_id, help_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name(' ', 'R', 'U', 'N'), + rtems_build_name( ' ', 'R', 'U', 'N' ), 4, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &run_task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(run_task_id, run_task, (rtems_task_argument) &run); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( run_task_id, run_task, (rtems_task_argument) &run ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - wait_for_prio(help_task_id, 2); + wait_for_prio( help_task_id, 2 ); - sc = rtems_task_wake_after(2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 2 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 0); - rtems_test_assert(!run); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); + rtems_test_assert( !run ); - change_prio(run_task_id, 1); + change_prio( run_task_id, 1 ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - while (!run) { + while ( !run ) { /* Wait */ } - sc = rtems_task_wake_after(2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 2 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - change_prio(run_task_id, 4); + change_prio( run_task_id, 4 ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); /* * With this operation the scheduler instance 0 has now only the main and the * idle threads in the ready set. */ - sc = rtems_task_suspend(run_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( run_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - change_prio(RTEMS_SELF, 1); - change_prio(RTEMS_SELF, 3); + change_prio( RTEMS_SELF, 1 ); + change_prio( RTEMS_SELF, 3 ); - sc = rtems_semaphore_release(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - assert_prio(RTEMS_SELF, 3); + assert_prio( RTEMS_SELF, 3 ); - wait_for_prio(help_task_id, 3); + wait_for_prio( help_task_id, 3 ); - print_switch_events(ctx); + print_switch_events( ctx ); - sc = rtems_semaphore_delete(ctx->mrsp_ids[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->mrsp_ids[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(help_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( help_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(run_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( run_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static uint32_t simple_random(uint32_t v) +static uint32_t simple_random( uint32_t v ) { v *= 1664525; v += 1013904223; @@ -1511,137 +1597,145 @@ static uint32_t simple_random(uint32_t v) return v; } -static rtems_interval timeout(uint32_t v) +static rtems_interval timeout( uint32_t v ) { - return (v >> 23) % 4; + return ( v >> 23 ) % 4; } -static void load_worker(rtems_task_argument index) +static void load_worker( rtems_task_argument index ) { - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; - uint32_t v = index; + uint32_t v = index; - while (!ctx->stop_worker[index]) { - uint32_t i = (v >> 13) % MRSP_COUNT; + while ( !ctx->stop_worker[ index ] ) { + uint32_t i = ( v >> 13 ) % MRSP_COUNT; - assert_prio(RTEMS_SELF, 3 + CPU_COUNT + index); + assert_prio( RTEMS_SELF, 3 + CPU_COUNT + index ); - if ((v >> 7) % 1024 == 0) { + if ( ( v >> 7 ) % 1024 == 0 ) { /* Give some time to the lower priority tasks */ - ++ctx->counters[index].sleep; + ++ctx->counters[ index ].sleep; - sc = rtems_task_wake_after(1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - ++ctx->counters[index].cpu[rtems_scheduler_get_processor()]; + ++ctx->counters[ index ].cpu[ rtems_scheduler_get_processor() ]; } else { - uint32_t n = (v >> 17) % (i + 1); + uint32_t n = ( v >> 17 ) % ( i + 1 ); uint32_t s; uint32_t t; /* Nested obtain */ - for (s = 0; s <= n; ++s) { + for ( s = 0; s <= n; ++s ) { uint32_t k = i - s; - sc = rtems_semaphore_obtain(ctx->mrsp_ids[k], RTEMS_WAIT, timeout(v)); - if (sc == RTEMS_SUCCESSFUL) { - ++ctx->counters[index].obtain[n]; + sc = rtems_semaphore_obtain( + ctx->mrsp_ids[ k ], + RTEMS_WAIT, + timeout( v ) + ); + if ( sc == RTEMS_SUCCESSFUL ) { + ++ctx->counters[ index ].obtain[ n ]; - assert_prio(RTEMS_SELF, 3 + k); + assert_prio( RTEMS_SELF, 3 + k ); } else { - rtems_test_assert(sc == RTEMS_TIMEOUT); + rtems_test_assert( sc == RTEMS_TIMEOUT ); - ++ctx->counters[index].timeout; + ++ctx->counters[ index ].timeout; break; } - ++ctx->counters[index].cpu[rtems_scheduler_get_processor()]; + ++ctx->counters[ index ].cpu[ rtems_scheduler_get_processor() ]; - v = simple_random(v); + v = simple_random( v ); } /* Release in reverse obtain order */ - for (t = 0; t < s; ++t) { + for ( t = 0; t < s; ++t ) { uint32_t k = i + t - s + 1; - sc = rtems_semaphore_release(ctx->mrsp_ids[k]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mrsp_ids[ k ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - ++ctx->counters[index].cpu[rtems_scheduler_get_processor()]; + ++ctx->counters[ index ].cpu[ rtems_scheduler_get_processor() ]; } } - v = simple_random(v); + v = simple_random( v ); } - sc = rtems_semaphore_release(ctx->counting_sem_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->counting_sem_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(0); + rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( 0 ); } -static void migration_task(rtems_task_argument arg) +static void migration_task( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; + test_context *ctx = &test_instance; rtems_status_code sc; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t v = 0xdeadbeef; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t v = 0xdeadbeef; - while (true) { - uint32_t cpu_index = (v >> 5) % cpu_count; + while ( true ) { + uint32_t cpu_index = ( v >> 5 ) % cpu_count; - sc = rtems_task_set_scheduler(RTEMS_SELF, ctx->scheduler_ids[cpu_index], 2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( + RTEMS_SELF, + ctx->scheduler_ids[ cpu_index ], + 2 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - ++ctx->migration_counters[rtems_scheduler_get_processor()]; + ++ctx->migration_counters[ rtems_scheduler_get_processor() ]; - v = simple_random(v); + v = simple_random( v ); } } -static void test_mrsp_load(test_context *ctx) +static void test_mrsp_load( test_context *ctx ) { rtems_status_code sc; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t index; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t index; - puts("test MrsP load"); + puts( "test MrsP load" ); - change_prio(RTEMS_SELF, 2); + change_prio( RTEMS_SELF, 2 ); sc = rtems_task_create( - rtems_build_name('M', 'I', 'G', 'R'), + rtems_build_name( 'M', 'I', 'G', 'R' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->migration_task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->migration_task_id, migration_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->migration_task_id, migration_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name('S', 'Y', 'N', 'C'), + rtems_build_name( 'S', 'Y', 'N', 'C' ), 0, RTEMS_COUNTING_SEMAPHORE, 0, &ctx->counting_sem_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (index = 0; index < MRSP_COUNT; ++index) { - create_mrsp_sema(ctx, &ctx->mrsp_ids[index], 3 + index); + for ( index = 0; index < MRSP_COUNT; ++index ) { + create_mrsp_sema( ctx, &ctx->mrsp_ids[ index ], 3 + index ); } - for (index = 0; index < cpu_count; ++index) { + for ( index = 0; index < cpu_count; ++index ) { uint32_t a = 2 * index; uint32_t b = a + 1; @@ -1651,23 +1745,23 @@ static void test_mrsp_load(test_context *ctx) RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->worker_ids[a] + &ctx->worker_ids[ a ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_set_scheduler( - ctx->worker_ids[a], - ctx->scheduler_ids[index], + ctx->worker_ids[ a ], + ctx->scheduler_ids[ index ], 3 + MRSP_COUNT + a ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_start( - ctx->worker_ids[a], + ctx->worker_ids[ a ], load_worker, (rtems_task_argument) a ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( 'A' + b, @@ -1675,144 +1769,144 @@ static void test_mrsp_load(test_context *ctx) RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->worker_ids[b] + &ctx->worker_ids[ b ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_set_scheduler( - ctx->worker_ids[b], - ctx->scheduler_ids[index], + ctx->worker_ids[ b ], + ctx->scheduler_ids[ index ], 3 + MRSP_COUNT + b ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_start( - ctx->worker_ids[b], + ctx->worker_ids[ b ], load_worker, (rtems_task_argument) b ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_task_wake_after(30 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 30 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (index = 0; index < 2 * cpu_count; ++index) { - ctx->stop_worker[index] = true; + for ( index = 0; index < 2 * cpu_count; ++index ) { + ctx->stop_worker[ index ] = true; } - for (index = 0; index < 2 * cpu_count; ++index) { + for ( index = 0; index < 2 * cpu_count; ++index ) { sc = rtems_semaphore_obtain( ctx->counting_sem_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (index = 0; index < 2 * cpu_count; ++index) { - sc = rtems_task_delete(ctx->worker_ids[index]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( index = 0; index < 2 * cpu_count; ++index ) { + sc = rtems_task_delete( ctx->worker_ids[ index ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (index = 0; index < MRSP_COUNT; ++index) { - sc = rtems_semaphore_delete(ctx->mrsp_ids[index]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( index = 0; index < MRSP_COUNT; ++index ) { + sc = rtems_semaphore_delete( ctx->mrsp_ids[ index ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_semaphore_delete(ctx->counting_sem_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->counting_sem_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->migration_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->migration_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (index = 0; index < 2 * cpu_count; ++index) { + for ( index = 0; index < 2 * cpu_count; ++index ) { uint32_t nest_level; uint32_t cpu_index; printf( "worker[%" PRIu32 "]\n" - " sleep = %" PRIu32 "\n" - " timeout = %" PRIu32 "\n", + " sleep = %" PRIu32 "\n" + " timeout = %" PRIu32 "\n", index, - ctx->counters[index].sleep, - ctx->counters[index].timeout + ctx->counters[ index ].sleep, + ctx->counters[ index ].timeout ); - for (nest_level = 0; nest_level < MRSP_COUNT; ++nest_level) { + for ( nest_level = 0; nest_level < MRSP_COUNT; ++nest_level ) { printf( " obtain[%" PRIu32 "] = %" PRIu32 "\n", nest_level, - ctx->counters[index].obtain[nest_level] + ctx->counters[ index ].obtain[ nest_level ] ); } - for (cpu_index = 0; cpu_index < cpu_count; ++cpu_index) { + for ( cpu_index = 0; cpu_index < cpu_count; ++cpu_index ) { printf( " cpu[%" PRIu32 "] = %" PRIu32 "\n", cpu_index, - ctx->counters[index].cpu[cpu_index] + ctx->counters[ index ].cpu[ cpu_index ] ); } } - for (index = 0; index < cpu_count; ++index) { + for ( index = 0; index < cpu_count; ++index ) { printf( "migrations[%" PRIu32 "] = %" PRIu32 "\n", index, - ctx->migration_counters[index] + ctx->migration_counters[ index ] ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - test_context *ctx = &test_instance; - rtems_status_code sc; + test_context *ctx = &test_instance; + rtems_status_code sc; rtems_resource_snapshot snapshot; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t cpu_index; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t cpu_index; TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); ctx->main_task_id = rtems_task_self(); - for (cpu_index = 0; cpu_index < MIN(2, cpu_count); ++cpu_index) { - sc = rtems_scheduler_ident(cpu_index, &ctx->scheduler_ids[cpu_index]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( cpu_index = 0; cpu_index < MIN( 2, cpu_count ); ++cpu_index ) { + sc = rtems_scheduler_ident( cpu_index, &ctx->scheduler_ids[ cpu_index ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (cpu_index = 2; cpu_index < cpu_count; ++cpu_index) { + for ( cpu_index = 2; cpu_index < cpu_count; ++cpu_index ) { sc = rtems_scheduler_ident( cpu_index / 2 + 1, - &ctx->scheduler_ids[cpu_index] + &ctx->scheduler_ids[ cpu_index ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - test_mrsp_flush_error(ctx); + test_mrsp_flush_error( ctx ); test_mrsp_initially_locked(); - test_mrsp_nested_obtain_error(ctx); - test_mrsp_deadlock_error(ctx); - test_mrsp_multiple_obtain(ctx); + test_mrsp_nested_obtain_error( ctx ); + test_mrsp_deadlock_error( ctx ); + test_mrsp_multiple_obtain( ctx ); - if (cpu_count > 1) { - test_mrsp_various_block_and_unblock(ctx); - test_mrsp_obtain_after_migration(ctx); - test_mrsp_obtain_and_sleep_and_release(ctx); - test_mrsp_obtain_and_release_with_help(ctx); - test_mrsp_obtain_and_release(ctx); - test_mrsp_load(ctx); + if ( cpu_count > 1 ) { + test_mrsp_various_block_and_unblock( ctx ); + test_mrsp_obtain_after_migration( ctx ); + test_mrsp_obtain_and_sleep_and_release( ctx ); + test_mrsp_obtain_and_release_with_help( ctx ); + test_mrsp_obtain_and_release( ctx ); + test_mrsp_load( ctx ); } - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_MICROSECONDS_PER_TICK 1000 @@ -1820,9 +1914,9 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS (2 * CPU_COUNT + 2) -#define CONFIGURE_MAXIMUM_SEMAPHORES (MRSP_COUNT + 1) -#define CONFIGURE_MAXIMUM_TIMERS 1 +#define CONFIGURE_MAXIMUM_TASKS ( 2 * CPU_COUNT + 2 ) +#define CONFIGURE_MAXIMUM_SEMAPHORES ( MRSP_COUNT + 1 ) +#define CONFIGURE_MAXIMUM_TIMERS 1 #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT @@ -1830,82 +1924,81 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_SIMPLE_SMP(0); -RTEMS_SCHEDULER_SIMPLE_SMP(1); -RTEMS_SCHEDULER_SIMPLE_SMP(2); -RTEMS_SCHEDULER_SIMPLE_SMP(3); -RTEMS_SCHEDULER_SIMPLE_SMP(4); -RTEMS_SCHEDULER_SIMPLE_SMP(5); -RTEMS_SCHEDULER_SIMPLE_SMP(6); -RTEMS_SCHEDULER_SIMPLE_SMP(7); -RTEMS_SCHEDULER_SIMPLE_SMP(8); -RTEMS_SCHEDULER_SIMPLE_SMP(9); -RTEMS_SCHEDULER_SIMPLE_SMP(10); -RTEMS_SCHEDULER_SIMPLE_SMP(11); -RTEMS_SCHEDULER_SIMPLE_SMP(12); -RTEMS_SCHEDULER_SIMPLE_SMP(13); -RTEMS_SCHEDULER_SIMPLE_SMP(14); -RTEMS_SCHEDULER_SIMPLE_SMP(15); -RTEMS_SCHEDULER_SIMPLE_SMP(16); +RTEMS_SCHEDULER_SIMPLE_SMP( 0 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 1 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 2 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 3 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 4 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 5 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 6 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 7 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 8 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 9 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 10 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 11 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 12 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 13 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 14 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 15 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 16 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(0, 0), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(1, 1), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(2, 2), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(3, 3), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(4, 4), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(5, 5), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(6, 6), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(7, 7), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(8, 8), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(9, 9), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(10, 10), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(11, 11), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(12, 12), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(13, 13), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(14, 14), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(15, 15), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(16, 16) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 0, 0 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 1, 1 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 2, 2 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 3, 3 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 4, 4 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 5, 5 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 6, 6 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 7, 7 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 8, 8 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 9, 9 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 10, 10 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 11, 11 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 12, 12 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 13, 13 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 14, 14 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 15, 15 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 16, 16 ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INITIAL_EXTENSIONS \ - { .thread_switch = switch_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .thread_switch = switch_extension }, RTEMS_TEST_INITIAL_EXTENSION -#define CONFIGURE_INIT_TASK_NAME rtems_build_name('M', 'A', 'I', 'N') +#define CONFIGURE_INIT_TASK_NAME rtems_build_name( 'M', 'A', 'I', 'N' ) #define CONFIGURE_INIT_TASK_PRIORITY 2 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE diff --git a/testsuites/smptests/smpmulticast01/init.c b/testsuites/smptests/smpmulticast01/init.c index 4458b762e7..c2417f7cc3 100644 --- a/testsuites/smptests/smpmulticast01/init.c +++ b/testsuites/smptests/smpmulticast01/init.c @@ -50,230 +50,238 @@ static const T_config config = { typedef struct { rtems_test_parallel_context base; - Atomic_Uint id[CPU_COUNT][CPU_COUNT]; + Atomic_Uint id[ CPU_COUNT ][ CPU_COUNT ]; } test_context; static test_context test_instance; -static void clear_ids_by_worker(test_context *ctx, size_t worker_index) +static void clear_ids_by_worker( test_context *ctx, size_t worker_index ) { - memset(&ctx->id[worker_index][0], 0, sizeof(ctx->id[worker_index])); + memset( + &ctx->id[ worker_index ][ 0 ], + 0, + sizeof( ctx->id[ worker_index ] ) + ); } static void unicast_action_irq_disabled( - uint32_t cpu_index, + uint32_t cpu_index, SMP_Action_handler handler, - void *arg + void *arg ) { rtems_interrupt_level level; - rtems_interrupt_local_disable(level); - _SMP_Unicast_action(cpu_index, handler, arg); - rtems_interrupt_local_enable(level); + rtems_interrupt_local_disable( level ); + _SMP_Unicast_action( cpu_index, handler, arg ); + rtems_interrupt_local_enable( level ); } static void unicast_action_dispatch_disabled( - uint32_t cpu_index, + uint32_t cpu_index, SMP_Action_handler handler, - void *arg + void *arg ) { Per_CPU_Control *cpu_self; cpu_self = _Thread_Dispatch_disable(); - _SMP_Unicast_action(cpu_index, handler, arg); - _Thread_Dispatch_enable(cpu_self); + _SMP_Unicast_action( cpu_index, handler, arg ); + _Thread_Dispatch_enable( cpu_self ); } static void multicast_action_irq_disabled( const Processor_mask *targets, - SMP_Action_handler handler, - void *arg + 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); + 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 + 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); + _SMP_Multicast_action( targets, handler, arg ); + _Thread_Dispatch_enable( cpu_self ); } static void broadcast_action_irq_disabled( SMP_Action_handler handler, - void *arg + void *arg ) { rtems_interrupt_level level; - rtems_interrupt_local_disable(level); - _SMP_Broadcast_action(handler, arg); - rtems_interrupt_local_enable(level); + rtems_interrupt_local_disable( level ); + _SMP_Broadcast_action( handler, arg ); + rtems_interrupt_local_enable( level ); } static void broadcast_action_dispatch_disabled( SMP_Action_handler handler, - void *arg + void *arg ) { Per_CPU_Control *cpu_self; cpu_self = _Thread_Dispatch_disable(); - _SMP_Broadcast_action(handler, arg); - _Thread_Dispatch_enable(cpu_self); + _SMP_Broadcast_action( handler, arg ); + _Thread_Dispatch_enable( cpu_self ); } -static void action(void *arg) +static void action( void *arg ) { Atomic_Uint *id; - uint32_t self; - unsigned expected; - bool success; + uint32_t self; + unsigned expected; + bool success; id = arg; self = rtems_scheduler_get_processor(); expected = 0; success = _Atomic_Compare_exchange_uint( - &id[self], + &id[ self ], &expected, self + 1, ATOMIC_ORDER_RELAXED, ATOMIC_ORDER_RELAXED ); - T_quiet_true(success, "set CPU identifier failed"); + T_quiet_true( success, "set CPU identifier failed" ); } static void test_unicast( test_context *ctx, - void (*unicast_action)(uint32_t, SMP_Action_handler, void *) + void ( *unicast_action )( uint32_t, SMP_Action_handler, void * ) ) { uint32_t step; uint32_t i; uint32_t n; - T_plan(1); + T_plan( 1 ); step = 0; n = rtems_scheduler_get_processor_maximum(); - for (i = 0; i < n; ++i) { + for ( i = 0; i < n; ++i ) { uint32_t j; - clear_ids_by_worker(ctx, 0); + clear_ids_by_worker( ctx, 0 ); - (*unicast_action)(i, action, &ctx->id[0][0]); + ( *unicast_action )( i, action, &ctx->id[ 0 ][ 0 ] ); - for (j = 0; j < n; ++j) { + for ( j = 0; j < n; ++j ) { unsigned id; ++step; - id = _Atomic_Load_uint(&ctx->id[0][j], ATOMIC_ORDER_RELAXED); + id = _Atomic_Load_uint( &ctx->id[ 0 ][ j ], ATOMIC_ORDER_RELAXED ); - if (j == i) { - T_quiet_eq_uint(j + 1, id); + if ( j == i ) { + T_quiet_eq_uint( j + 1, id ); } else { - T_quiet_eq_uint(0, id); + T_quiet_eq_uint( 0, id ); } } } - T_step_eq_u32(0, step, n * n); + T_step_eq_u32( 0, step, n * n ); } static void test_multicast( test_context *ctx, - void (*multicast_action)(const Processor_mask *, SMP_Action_handler, void *) + void ( *multicast_action )( + const Processor_mask *, + SMP_Action_handler, + void * + ) ) { uint32_t step; uint32_t i; uint32_t n; - T_plan(1); + T_plan( 1 ); step = 0; n = rtems_scheduler_get_processor_maximum(); - for (i = 0; i < n; ++i) { + for ( i = 0; i < n; ++i ) { Processor_mask cpus; - uint32_t j; + uint32_t j; - clear_ids_by_worker(ctx, 0); + clear_ids_by_worker( ctx, 0 ); - _Processor_mask_Zero(&cpus); - _Processor_mask_Set(&cpus, i); - (*multicast_action)(&cpus, action, &ctx->id[0][0]); + _Processor_mask_Zero( &cpus ); + _Processor_mask_Set( &cpus, i ); + ( *multicast_action )( &cpus, action, &ctx->id[ 0 ][ 0 ] ); - for (j = 0; j < n; ++j) { + for ( j = 0; j < n; ++j ) { unsigned id; ++step; - id = _Atomic_Load_uint(&ctx->id[0][j], ATOMIC_ORDER_RELAXED); + id = _Atomic_Load_uint( &ctx->id[ 0 ][ j ], ATOMIC_ORDER_RELAXED ); - if (j == i) { - T_quiet_eq_uint(j + 1, id); + if ( j == i ) { + T_quiet_eq_uint( j + 1, id ); } else { - T_quiet_eq_uint(0, id); + T_quiet_eq_uint( 0, id ); } } } - T_step_eq_u32(0, step, n * n); + T_step_eq_u32( 0, step, n * n ); } static void test_broadcast( test_context *ctx, - void (*broadcast_action)(SMP_Action_handler, void *) + void ( *broadcast_action )( SMP_Action_handler, void * ) ) { uint32_t step; uint32_t i; uint32_t n; - T_plan(1); + T_plan( 1 ); step = 0; n = rtems_scheduler_get_processor_maximum(); - for (i = 0; i < n; ++i) { + for ( i = 0; i < n; ++i ) { uint32_t j; - clear_ids_by_worker(ctx, 0); + clear_ids_by_worker( ctx, 0 ); - (*broadcast_action)(action, &ctx->id[0][0]); + ( *broadcast_action )( action, &ctx->id[ 0 ][ 0 ] ); - for (j = 0; j < n; ++j) { + for ( j = 0; j < n; ++j ) { unsigned id; ++step; - id = _Atomic_Load_uint(&ctx->id[0][j], ATOMIC_ORDER_RELAXED); - T_quiet_eq_uint(j + 1, id); + id = _Atomic_Load_uint( &ctx->id[ 0 ][ j ], ATOMIC_ORDER_RELAXED ); + T_quiet_eq_uint( j + 1, id ); } } - T_step_eq_u32(0, step, n * n); + T_step_eq_u32( 0, step, n * n ); } -static rtems_interval test_duration(void) +static rtems_interval test_duration( void ) { return rtems_clock_get_ticks_per_second(); } static rtems_interval test_broadcast_init( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) base; @@ -285,9 +293,9 @@ static rtems_interval test_broadcast_init( static void test_broadcast_body( rtems_test_parallel_context *base, - void *arg, - size_t active_workers, - size_t worker_index + void *arg, + size_t active_workers, + size_t worker_index ) { (void) arg; @@ -297,20 +305,20 @@ static void test_broadcast_body( ctx = (test_context *) base; - while (!rtems_test_parallel_stop_job(&ctx->base)) { + while ( !rtems_test_parallel_stop_job( &ctx->base ) ) { Per_CPU_Control *cpu_self; - clear_ids_by_worker(ctx, worker_index); + clear_ids_by_worker( ctx, worker_index ); cpu_self = _Thread_Dispatch_disable(); - _SMP_Broadcast_action(action, &ctx->id[worker_index][0]); - _Thread_Dispatch_enable(cpu_self); + _SMP_Broadcast_action( action, &ctx->id[ worker_index ][ 0 ] ); + _Thread_Dispatch_enable( cpu_self ); } } static void test_broadcast_fini( rtems_test_parallel_context *base, - void *arg, - size_t active_workers + void *arg, + size_t active_workers ) { (void) base; @@ -321,71 +329,69 @@ static void test_broadcast_fini( } static const rtems_test_parallel_job test_jobs[] = { - { - .init = test_broadcast_init, + { .init = test_broadcast_init, .body = test_broadcast_body, .fini = test_broadcast_fini, - .cascade = true - } + .cascade = true } }; -T_TEST_CASE(ParallelBroadcast) +T_TEST_CASE( ParallelBroadcast ) { rtems_test_parallel( &test_instance.base, NULL, - &test_jobs[0], - RTEMS_ARRAY_SIZE(test_jobs) + &test_jobs[ 0 ], + RTEMS_ARRAY_SIZE( test_jobs ) ); } -static void test_before_multitasking(void) +static void test_before_multitasking( void ) { test_context *ctx; ctx = &test_instance; - T_case_begin("UnicastBeforeMultitasking", NULL); - test_unicast(ctx, _SMP_Unicast_action); + T_case_begin( "UnicastBeforeMultitasking", NULL ); + test_unicast( ctx, _SMP_Unicast_action ); T_case_end(); - T_case_begin("UnicastBeforeMultitaskingIRQDisabled", NULL); - test_unicast(ctx, unicast_action_irq_disabled); + T_case_begin( "UnicastBeforeMultitaskingIRQDisabled", NULL ); + test_unicast( ctx, unicast_action_irq_disabled ); T_case_end(); - T_case_begin("UnicastBeforeMultitaskingDispatchDisabled", NULL); - test_unicast(ctx, unicast_action_dispatch_disabled); + T_case_begin( "UnicastBeforeMultitaskingDispatchDisabled", NULL ); + test_unicast( ctx, unicast_action_dispatch_disabled ); T_case_end(); - T_case_begin("MulticastBeforeMultitasking", NULL); - test_multicast(ctx, _SMP_Multicast_action); + T_case_begin( "MulticastBeforeMultitasking", NULL ); + test_multicast( ctx, _SMP_Multicast_action ); T_case_end(); - T_case_begin("MulticastBeforeMultitaskingIRQDisabled", NULL); - test_multicast(ctx, multicast_action_irq_disabled); + T_case_begin( "MulticastBeforeMultitaskingIRQDisabled", NULL ); + test_multicast( ctx, multicast_action_irq_disabled ); T_case_end(); - T_case_begin("MulticastBeforeMultitaskingDispatchDisabled", NULL); - test_multicast(ctx, multicast_action_dispatch_disabled); + T_case_begin( "MulticastBeforeMultitaskingDispatchDisabled", NULL ); + test_multicast( ctx, multicast_action_dispatch_disabled ); T_case_end(); - T_case_begin("BroadcastBeforeMultitasking", NULL); - test_broadcast(ctx, _SMP_Broadcast_action); + T_case_begin( "BroadcastBeforeMultitasking", NULL ); + test_broadcast( ctx, _SMP_Broadcast_action ); T_case_end(); - T_case_begin("BroadcastBeforeMultitaskingIRQDisabled", NULL); - test_broadcast(ctx, broadcast_action_irq_disabled); + T_case_begin( "BroadcastBeforeMultitaskingIRQDisabled", NULL ); + test_broadcast( ctx, broadcast_action_irq_disabled ); T_case_end(); - T_case_begin("BroadcastBeforeMultitaskingDispatchDisabled", NULL); - test_broadcast(ctx, broadcast_action_dispatch_disabled); + T_case_begin( "BroadcastBeforeMultitaskingDispatchDisabled", NULL ); + test_broadcast( ctx, broadcast_action_dispatch_disabled ); T_case_end(); } -static void after_drivers(void) +static void after_drivers( void ) { TEST_BEGIN(); - T_run_initialize(&config); + T_run_initialize( &config ); test_before_multitasking(); } @@ -395,210 +401,210 @@ RTEMS_SYSINIT_ITEM( RTEMS_SYSINIT_ORDER_LAST ); -static void set_wrong_cpu_state(void *arg) +static void set_wrong_cpu_state( void *arg ) { Per_CPU_Control *cpu_self; cpu_self = arg; - T_step_eq_ptr(0, cpu_self, _Per_CPU_Get()); - _Per_CPU_Set_state(cpu_self, 123); + T_step_eq_ptr( 0, cpu_self, _Per_CPU_Get() ); + _Per_CPU_Set_state( cpu_self, 123 ); - while (true) { + while ( true ) { /* Do nothing */ } } -static void test_wrong_cpu_state_to_perform_jobs(void) +static void test_wrong_cpu_state_to_perform_jobs( void ) { - Per_CPU_Control *cpu_self; + Per_CPU_Control *cpu_self; rtems_interrupt_level level; - Processor_mask targets; - uint32_t cpu_index; + Processor_mask targets; + uint32_t cpu_index; - T_case_begin("WrongCPUStateToPerformJobs", NULL); - T_plan(4); + T_case_begin( "WrongCPUStateToPerformJobs", NULL ); + T_plan( 4 ); cpu_self = _Thread_Dispatch_disable(); - cpu_index = _Per_CPU_Get_index(cpu_self); - cpu_index = (cpu_index + 1) % rtems_scheduler_get_processor_maximum(); - _Processor_mask_Zero(&targets); - _Processor_mask_Set(&targets, cpu_index); + cpu_index = _Per_CPU_Get_index( cpu_self ); + cpu_index = ( cpu_index + 1 ) % rtems_scheduler_get_processor_maximum(); + _Processor_mask_Zero( &targets ); + _Processor_mask_Set( &targets, cpu_index ); - rtems_interrupt_local_disable(level); + rtems_interrupt_local_disable( level ); _SMP_Multicast_action( &targets, set_wrong_cpu_state, - _Per_CPU_Get_by_index(cpu_index) + _Per_CPU_Get_by_index( cpu_index ) ); /* If everything is all right, we don't end up here */ - rtems_interrupt_local_enable(level); - _Thread_Dispatch_enable(cpu_self); - rtems_fatal(RTEMS_FATAL_SOURCE_APPLICATION, 0); + rtems_interrupt_local_enable( level ); + _Thread_Dispatch_enable( cpu_self ); + rtems_fatal( RTEMS_FATAL_SOURCE_APPLICATION, 0 ); } #define TEST_JOB_ORDER_JOBS 3 -static Per_CPU_Job job_order_jobs[TEST_JOB_ORDER_JOBS]; +static Per_CPU_Job job_order_jobs[ TEST_JOB_ORDER_JOBS ]; -static void job_order_handler_0(void *arg) +static void job_order_handler_0( void *arg ) { (void) arg; - T_step(1); + T_step( 1 ); } -static void job_order_handler_1(void *arg) +static void job_order_handler_1( void *arg ) { (void) arg; - T_step(2); + T_step( 2 ); } -static void job_order_handler_2(void *arg) +static void job_order_handler_2( void *arg ) { (void) arg; - T_step(3); + T_step( 3 ); } -static const Per_CPU_Job_context job_order_contexts[TEST_JOB_ORDER_JOBS] = { +static const Per_CPU_Job_context job_order_contexts[ TEST_JOB_ORDER_JOBS ] = { { .handler = job_order_handler_0 }, { .handler = job_order_handler_1 }, { .handler = job_order_handler_2 } }; -T_TEST_CASE(JobOrder) +T_TEST_CASE( JobOrder ) { Per_CPU_Control *cpu_self; - size_t i; + size_t i; - T_plan(4); + T_plan( 4 ); cpu_self = _Thread_Dispatch_disable(); - for (i = 0; i < TEST_JOB_ORDER_JOBS; ++i) { - job_order_jobs[i].context = &job_order_contexts[i]; - _Per_CPU_Add_job(cpu_self, &job_order_jobs[i]); + for ( i = 0; i < TEST_JOB_ORDER_JOBS; ++i ) { + job_order_jobs[ i ].context = &job_order_contexts[ i ]; + _Per_CPU_Add_job( cpu_self, &job_order_jobs[ i ] ); } - T_step(0); - _SMP_Send_message(cpu_self, SMP_MESSAGE_PERFORM_JOBS); - _Thread_Dispatch_enable(cpu_self); + T_step( 0 ); + _SMP_Send_message( cpu_self, SMP_MESSAGE_PERFORM_JOBS ); + _Thread_Dispatch_enable( cpu_self ); } #define TEST_ADD_JOB_IN_JOB_JOBS 3 -static Per_CPU_Job add_job_in_job_jobs[TEST_ADD_JOB_IN_JOB_JOBS]; +static Per_CPU_Job add_job_in_job_jobs[ TEST_ADD_JOB_IN_JOB_JOBS ]; -static void add_job_in_job_handler_0(void *arg) +static void add_job_in_job_handler_0( void *arg ) { (void) arg; - T_step(1); - _Per_CPU_Add_job(_Per_CPU_Get(), &add_job_in_job_jobs[1]); + T_step( 1 ); + _Per_CPU_Add_job( _Per_CPU_Get(), &add_job_in_job_jobs[ 1 ] ); } -static void add_job_in_job_handler_1(void *arg) +static void add_job_in_job_handler_1( void *arg ) { (void) arg; - T_step(3); + T_step( 3 ); } static const Per_CPU_Job_context -add_job_in_job_contexts[TEST_ADD_JOB_IN_JOB_JOBS] = { - { .handler = add_job_in_job_handler_0 }, - { .handler = add_job_in_job_handler_1 } + add_job_in_job_contexts[ TEST_ADD_JOB_IN_JOB_JOBS ] = { + { .handler = add_job_in_job_handler_0 }, + { .handler = add_job_in_job_handler_1 } }; -T_TEST_CASE(AddJobInJob) +T_TEST_CASE( AddJobInJob ) { Per_CPU_Control *cpu_self; - size_t i; + size_t i; - T_plan(4); + T_plan( 4 ); cpu_self = _Thread_Dispatch_disable(); - for (i = 0; i < TEST_ADD_JOB_IN_JOB_JOBS; ++i) { - add_job_in_job_jobs[i].context = &add_job_in_job_contexts[i]; + for ( i = 0; i < TEST_ADD_JOB_IN_JOB_JOBS; ++i ) { + add_job_in_job_jobs[ i ].context = &add_job_in_job_contexts[ i ]; } - _Per_CPU_Add_job(cpu_self, &add_job_in_job_jobs[0]); - T_step(0); - _SMP_Send_message(cpu_self, SMP_MESSAGE_PERFORM_JOBS); - _Per_CPU_Wait_for_job(cpu_self, &add_job_in_job_jobs[0]); - T_step(2); - _SMP_Send_message(cpu_self, SMP_MESSAGE_PERFORM_JOBS); - _Thread_Dispatch_enable(cpu_self); + _Per_CPU_Add_job( cpu_self, &add_job_in_job_jobs[ 0 ] ); + T_step( 0 ); + _SMP_Send_message( cpu_self, SMP_MESSAGE_PERFORM_JOBS ); + _Per_CPU_Wait_for_job( cpu_self, &add_job_in_job_jobs[ 0 ] ); + T_step( 2 ); + _SMP_Send_message( cpu_self, SMP_MESSAGE_PERFORM_JOBS ); + _Thread_Dispatch_enable( cpu_self ); } -T_TEST_CASE(UnicastDuringMultitaskingIRQDisabled) +T_TEST_CASE( UnicastDuringMultitaskingIRQDisabled ) { - test_unicast(&test_instance, unicast_action_irq_disabled); + test_unicast( &test_instance, unicast_action_irq_disabled ); } -T_TEST_CASE(UnicastDuringMultitaskingDispatchDisabled) +T_TEST_CASE( UnicastDuringMultitaskingDispatchDisabled ) { - test_unicast(&test_instance, unicast_action_dispatch_disabled); + test_unicast( &test_instance, unicast_action_dispatch_disabled ); } -T_TEST_CASE(MulticastDuringMultitaskingIRQDisabled) +T_TEST_CASE( MulticastDuringMultitaskingIRQDisabled ) { - test_multicast(&test_instance, multicast_action_irq_disabled); + test_multicast( &test_instance, multicast_action_irq_disabled ); } -T_TEST_CASE(MulticastDuringMultitaskingDispatchDisabled) +T_TEST_CASE( MulticastDuringMultitaskingDispatchDisabled ) { - test_multicast(&test_instance, multicast_action_dispatch_disabled); + test_multicast( &test_instance, multicast_action_dispatch_disabled ); } -T_TEST_CASE(BroadcastDuringMultitaskingIRQDisabled) +T_TEST_CASE( BroadcastDuringMultitaskingIRQDisabled ) { - test_broadcast(&test_instance, broadcast_action_irq_disabled); + test_broadcast( &test_instance, broadcast_action_irq_disabled ); } -T_TEST_CASE(BroadcastDuringMultitaskingDispatchDisabled) +T_TEST_CASE( BroadcastDuringMultitaskingDispatchDisabled ) { - test_broadcast(&test_instance, broadcast_action_dispatch_disabled); + test_broadcast( &test_instance, broadcast_action_dispatch_disabled ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; T_register(); T_run_all(); - if (rtems_scheduler_get_processor_maximum() > 1) { + if ( rtems_scheduler_get_processor_maximum() > 1 ) { test_wrong_cpu_state_to_perform_jobs(); } else { - rtems_fatal(RTEMS_FATAL_SOURCE_APPLICATION, 0); + rtems_fatal( RTEMS_FATAL_SOURCE_APPLICATION, 0 ); } } static void fatal_extension( rtems_fatal_source source, - bool always_set_to_false, - rtems_fatal_code code + bool always_set_to_false, + rtems_fatal_code code ) { bool ok; - if (source == RTEMS_FATAL_SOURCE_SMP) { - if (code != SMP_FATAL_SHUTDOWN_RESPONSE) { - T_step_eq_int(1, source, RTEMS_FATAL_SOURCE_SMP); - T_step_false(2, always_set_to_false, "unexpected argument value"); - T_step_eq_int(3, code, SMP_FATAL_WRONG_CPU_STATE_TO_PERFORM_JOBS); + if ( source == RTEMS_FATAL_SOURCE_SMP ) { + if ( code != SMP_FATAL_SHUTDOWN_RESPONSE ) { + T_step_eq_int( 1, source, RTEMS_FATAL_SOURCE_SMP ); + T_step_false( 2, always_set_to_false, "unexpected argument value" ); + T_step_eq_int( 3, code, SMP_FATAL_WRONG_CPU_STATE_TO_PERFORM_JOBS ); T_case_end(); ok = T_run_finalize(); - rtems_test_assert(ok); + rtems_test_assert( ok ); TEST_END(); } - } else if (source == RTEMS_FATAL_SOURCE_APPLICATION) { + } else if ( source == RTEMS_FATAL_SOURCE_APPLICATION ) { ok = T_run_finalize(); - rtems_test_assert(ok); + rtems_test_assert( ok ); TEST_END(); } } @@ -612,8 +618,7 @@ static void fatal_extension( #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT #define CONFIGURE_INITIAL_EXTENSIONS \ - { .fatal = fatal_extension }, \ - RTEMS_TEST_INITIAL_EXTENSION + { .fatal = fatal_extension }, RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_RTEMS_INIT_TASKS_TABLE diff --git a/testsuites/smptests/smpmutex01/init.c b/testsuites/smptests/smpmutex01/init.c index abc4caf197..24eeee2c0a 100644 --- a/testsuites/smptests/smpmutex01/init.c +++ b/testsuites/smptests/smpmutex01/init.c @@ -33,9 +33,9 @@ const char rtems_test_name[] = "SMPMUTEX 1"; -#define SCHED_A rtems_build_name(' ', ' ', ' ', 'A') +#define SCHED_A rtems_build_name( ' ', ' ', ' ', 'A' ) -#define SCHED_B rtems_build_name(' ', ' ', ' ', 'B') +#define SCHED_B rtems_build_name( ' ', ' ', ' ', 'B' ) #define PART_COUNT 2 @@ -79,86 +79,86 @@ typedef enum { } task_id; typedef struct { - rtems_id mtx; - rtems_id mtx_2; - rtems_id sem; - rtems_id ceil; - rtems_id tasks[TASK_COUNT]; - Atomic_Uint done; - task_id id_2; + rtems_id mtx; + rtems_id mtx_2; + rtems_id sem; + rtems_id ceil; + rtems_id tasks[ TASK_COUNT ]; + Atomic_Uint done; + task_id id_2; rtems_event_set events_2; - task_id id_3; + task_id id_3; rtems_event_set events_3; - int generation[TASK_COUNT]; - int expected_generation[TASK_COUNT]; + int generation[ TASK_COUNT ]; + int expected_generation[ TASK_COUNT ]; } test_context; static test_context test_instance; -static void assert_cpu(uint32_t expected_cpu) +static void assert_cpu( uint32_t expected_cpu ) { - rtems_test_assert(rtems_scheduler_get_processor() == expected_cpu); + rtems_test_assert( rtems_scheduler_get_processor() == expected_cpu ); } -static void test_task_get_priority_not_defined(test_context *ctx) +static void test_task_get_priority_not_defined( test_context *ctx ) { (void) ctx; - rtems_status_code sc; - rtems_id scheduler_id; + rtems_status_code sc; + rtems_id scheduler_id; rtems_task_priority priority; - sc = rtems_scheduler_ident(SCHED_B, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_B, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); priority = 0; - sc = rtems_task_get_priority(RTEMS_SELF, scheduler_id, &priority); - rtems_test_assert(sc == RTEMS_NOT_DEFINED); - rtems_test_assert(priority == 0); + sc = rtems_task_get_priority( RTEMS_SELF, scheduler_id, &priority ); + rtems_test_assert( sc == RTEMS_NOT_DEFINED ); + rtems_test_assert( priority == 0 ); } static void start_task( - test_context *ctx, - task_id id, - rtems_task_entry entry, + test_context *ctx, + task_id id, + rtems_task_entry entry, rtems_task_priority prio, - rtems_name scheduler + rtems_name scheduler ) { rtems_status_code sc; - rtems_id scheduler_id; + rtems_id scheduler_id; sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), prio, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->tasks[id] + &ctx->tasks[ id ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_ident(scheduler, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( scheduler, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(ctx->tasks[id], scheduler_id, prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( ctx->tasks[ id ], scheduler_id, prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->tasks[id], entry, id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->tasks[ id ], entry, id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void send_event(test_context *ctx, task_id id, rtems_event_set events) +static void send_event( test_context *ctx, task_id id, rtems_event_set events ) { rtems_status_code sc; - sc = rtems_event_send(ctx->tasks[id], events); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_send( ctx->tasks[ id ], events ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void set_event_2( - test_context *ctx, - task_id id_2, + test_context *ctx, + task_id id_2, rtems_event_set events_2 ) { @@ -167,8 +167,8 @@ static void set_event_2( } static void set_event_3( - test_context *ctx, - task_id id_3, + test_context *ctx, + task_id id_3, rtems_event_set events_3 ) { @@ -176,38 +176,38 @@ static void set_event_3( ctx->events_3 = events_3; } -static void clear_done(test_context *ctx) +static void clear_done( test_context *ctx ) { - _Atomic_Store_uint(&ctx->done, 0, ATOMIC_ORDER_RELAXED); + _Atomic_Store_uint( &ctx->done, 0, ATOMIC_ORDER_RELAXED ); } -static void set_done(test_context *ctx) +static void set_done( test_context *ctx ) { - _Atomic_Store_uint(&ctx->done, 1, ATOMIC_ORDER_RELEASE); + _Atomic_Store_uint( &ctx->done, 1, ATOMIC_ORDER_RELEASE ); } -static bool is_done(test_context *ctx) +static bool is_done( test_context *ctx ) { - return _Atomic_Load_uint(&ctx->done, ATOMIC_ORDER_ACQUIRE) != 0; + return _Atomic_Load_uint( &ctx->done, ATOMIC_ORDER_ACQUIRE ) != 0; } -static void wait_for_done(test_context *ctx) +static void wait_for_done( test_context *ctx ) { - while (!is_done(ctx)) { + while ( !is_done( ctx ) ) { /* Wait */ } } -static void request_pre_emption(test_context *ctx, task_id id) +static void request_pre_emption( test_context *ctx, task_id id ) { - clear_done(ctx); - send_event(ctx, id, REQ_SET_DONE); - wait_for_done(ctx); + clear_done( ctx ); + send_event( ctx, id, REQ_SET_DONE ); + wait_for_done( ctx ); } -static rtems_event_set wait_for_events(void) +static rtems_event_set wait_for_events( void ) { - rtems_event_set events; + rtems_event_set events; rtems_status_code sc; sc = rtems_event_receive( @@ -216,453 +216,449 @@ static rtems_event_set wait_for_events(void) RTEMS_NO_TIMEOUT, &events ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); return events; } -static void sync_with_helper_by_id(test_context *ctx, task_id id) +static void sync_with_helper_by_id( test_context *ctx, task_id id ) { rtems_event_set events; - send_event(ctx, id, REQ_WAKE_UP_HELPER); + send_event( ctx, id, REQ_WAKE_UP_HELPER ); events = wait_for_events(); - rtems_test_assert(events == REQ_WAKE_UP_MASTER); + rtems_test_assert( events == REQ_WAKE_UP_MASTER ); } -static void sync_with_helper(test_context *ctx) +static void sync_with_helper( test_context *ctx ) { - sync_with_helper_by_id(ctx, H_A); - sync_with_helper_by_id(ctx, H_B); + sync_with_helper_by_id( ctx, H_A ); + sync_with_helper_by_id( ctx, H_B ); } -static void request(test_context *ctx, task_id id, request_id req) +static void request( test_context *ctx, task_id id, request_id req ) { - send_event(ctx, id, req); - clear_done(ctx); + send_event( ctx, id, req ); + clear_done( ctx ); - if (rtems_scheduler_get_processor() == 0) { + if ( rtems_scheduler_get_processor() == 0 ) { id = H_B; } else { id = H_A; } - send_event(ctx, id, REQ_SET_DONE); - wait_for_done(ctx); + send_event( ctx, id, REQ_SET_DONE ); + wait_for_done( ctx ); } -static void obtain(test_context *ctx) +static void obtain( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->mtx, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( ctx->mtx, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void obtain_timeout(test_context *ctx) +static void obtain_timeout( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->mtx, RTEMS_WAIT, TIMEOUT_IN_TICKS); - rtems_test_assert(sc == RTEMS_TIMEOUT); + sc = rtems_semaphore_obtain( ctx->mtx, RTEMS_WAIT, TIMEOUT_IN_TICKS ); + rtems_test_assert( sc == RTEMS_TIMEOUT ); } -static void obtain_unsatisfied(test_context *ctx) +static void obtain_unsatisfied( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->mtx, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_UNSATISFIED); + sc = rtems_semaphore_obtain( ctx->mtx, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_UNSATISFIED ); } -static void release(test_context *ctx) +static void release( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_release(ctx->mtx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mtx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void flush(test_context *ctx) +static void flush( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_flush(ctx->mtx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_flush( ctx->mtx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void obtain_2(test_context *ctx) +static void obtain_2( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->mtx_2, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( ctx->mtx_2, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void release_2(test_context *ctx) +static void release_2( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_release(ctx->mtx_2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mtx_2 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void sem_obtain(test_context *ctx) +static void sem_obtain( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( ctx->sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void sem_release(test_context *ctx) +static void sem_release( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_release(ctx->sem); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->sem ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void ceil_obtain(test_context *ctx) +static void ceil_obtain( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_obtain(ctx->ceil, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( ctx->ceil, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void ceil_release(test_context *ctx) +static void ceil_release( test_context *ctx ) { rtems_status_code sc; - sc = rtems_semaphore_release(ctx->ceil); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->ceil ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void wait(void) +static void wait( void ) { rtems_status_code sc; - sc = rtems_task_wake_after(TIMEOUT_IN_TICKS + 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( TIMEOUT_IN_TICKS + 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void check_generations(test_context *ctx, task_id a, task_id b) +static void check_generations( test_context *ctx, task_id a, task_id b ) { size_t i; - if (a != NONE) { - ++ctx->expected_generation[a]; + if ( a != NONE ) { + ++ctx->expected_generation[ a ]; } - if (b != NONE) { - ++ctx->expected_generation[b]; + if ( b != NONE ) { + ++ctx->expected_generation[ b ]; } - for (i = 0; i < TASK_COUNT; ++i) { - rtems_test_assert(ctx->generation[i] == ctx->expected_generation[i]); + for ( i = 0; i < TASK_COUNT; ++i ) { + rtems_test_assert( ctx->generation[ i ] == ctx->expected_generation[ i ] ); } } -static void yield(void) +static void yield( void ) { rtems_status_code sc; - sc = rtems_task_wake_after(RTEMS_YIELD_PROCESSOR); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void set_prio(test_context *ctx, task_id id, rtems_task_priority prio) +static void set_prio( test_context *ctx, task_id id, rtems_task_priority prio ) { rtems_status_code sc; - sc = rtems_task_set_priority(ctx->tasks[id], prio, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( ctx->tasks[ id ], prio, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void assert_prio( - test_context *ctx, - task_id id, + test_context *ctx, + task_id id, rtems_task_priority expected ) { rtems_task_priority actual; - rtems_status_code sc; + rtems_status_code sc; sc = rtems_task_set_priority( - ctx->tasks[id], + ctx->tasks[ id ], RTEMS_CURRENT_PRIORITY, &actual ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(expected == actual); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( expected == actual ); } static void assert_prio_by_scheduler( - test_context *ctx, - task_id id, - rtems_name scheduler, + test_context *ctx, + task_id id, + rtems_name scheduler, rtems_task_priority expected ) { rtems_task_priority actual; - rtems_status_code sc; - rtems_id scheduler_id; + rtems_status_code sc; + rtems_id scheduler_id; - sc = rtems_scheduler_ident(scheduler, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( scheduler, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); actual = PRIO_NONE; - sc = rtems_task_get_priority( - ctx->tasks[id], - scheduler_id, - &actual - ); + sc = rtems_task_get_priority( ctx->tasks[ id ], scheduler_id, &actual ); - if (expected == PRIO_NONE) { - rtems_test_assert(sc == RTEMS_NOT_DEFINED); + if ( expected == PRIO_NONE ) { + rtems_test_assert( sc == RTEMS_NOT_DEFINED ); } else { - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - rtems_test_assert(actual == expected); + rtems_test_assert( actual == expected ); } -static void helper(rtems_task_argument arg) +static void helper( rtems_task_argument arg ) { (void) arg; test_context *ctx = &test_instance; - while (true) { + while ( true ) { rtems_event_set events = wait_for_events(); - if ((events & REQ_WAKE_UP_HELPER) != 0) { - send_event(ctx, M, REQ_WAKE_UP_MASTER); + if ( ( events & REQ_WAKE_UP_HELPER ) != 0 ) { + send_event( ctx, M, REQ_WAKE_UP_MASTER ); } - if ((events & REQ_SEM_RELEASE) != 0) { - sem_release(ctx); + if ( ( events & REQ_SEM_RELEASE ) != 0 ) { + sem_release( ctx ); } - if ((events & REQ_SET_DONE) != 0) { - set_done(ctx); + if ( ( events & REQ_SET_DONE ) != 0 ) { + set_done( ctx ); } } } -static void worker(rtems_task_argument arg) +static void worker( rtems_task_argument arg ) { (void) arg; test_context *ctx = &test_instance; - task_id id = arg; + task_id id = arg; - while (true) { + while ( true ) { rtems_event_set events = wait_for_events(); - if ((events & REQ_MTX_OBTAIN) != 0) { - obtain(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_MTX_OBTAIN ) != 0 ) { + obtain( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_MTX_OBTAIN_TIMEOUT) != 0) { - obtain_timeout(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_MTX_OBTAIN_TIMEOUT ) != 0 ) { + obtain_timeout( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_MTX_OBTAIN_UNSATISFIED) != 0) { - obtain_unsatisfied(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_MTX_OBTAIN_UNSATISFIED ) != 0 ) { + obtain_unsatisfied( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_MTX_RELEASE) != 0) { - release(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_MTX_RELEASE ) != 0 ) { + release( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_MTX_2_OBTAIN) != 0) { - obtain_2(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_MTX_2_OBTAIN ) != 0 ) { + obtain_2( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_MTX_2_RELEASE) != 0) { - release_2(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_MTX_2_RELEASE ) != 0 ) { + release_2( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_SEM_OBTAIN_RELEASE) != 0) { - sem_obtain(ctx); - ++ctx->generation[id]; - sem_release(ctx); + if ( ( events & REQ_SEM_OBTAIN_RELEASE ) != 0 ) { + sem_obtain( ctx ); + ++ctx->generation[ id ]; + sem_release( ctx ); } - if ((events & REQ_SEND_EVENT_2) != 0) { - send_event(ctx, ctx->id_2, ctx->events_2); + if ( ( events & REQ_SEND_EVENT_2 ) != 0 ) { + send_event( ctx, ctx->id_2, ctx->events_2 ); } - if ((events & REQ_SEND_EVENT_3) != 0) { - send_event(ctx, ctx->id_3, ctx->events_3); + if ( ( events & REQ_SEND_EVENT_3 ) != 0 ) { + send_event( ctx, ctx->id_3, ctx->events_3 ); } - if ((events & REQ_CEIL_OBTAIN) != 0) { - ceil_obtain(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_CEIL_OBTAIN ) != 0 ) { + ceil_obtain( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_CEIL_RELEASE) != 0) { - ceil_release(ctx); - ++ctx->generation[id]; + if ( ( events & REQ_CEIL_RELEASE ) != 0 ) { + ceil_release( ctx ); + ++ctx->generation[ id ]; } - if ((events & REQ_SET_DONE) != 0) { - set_done(ctx); + if ( ( events & REQ_SET_DONE ) != 0 ) { + set_done( ctx ); } - if ((events & REQ_WAIT_FOR_DONE) != 0) { - wait_for_done(ctx); + if ( ( events & REQ_WAIT_FOR_DONE ) != 0 ) { + wait_for_done( ctx ); } } } -static void test_init(test_context *ctx) +static void test_init( test_context *ctx ) { rtems_status_code sc; - ctx->tasks[M] = rtems_task_self(); - start_task(ctx, A_1, worker, 1, SCHED_A); - start_task(ctx, A_2_0, worker, 2, SCHED_A); - start_task(ctx, A_2_1, worker, 2, SCHED_A); - start_task(ctx, H_A, helper, 3, SCHED_A); + ctx->tasks[ M ] = rtems_task_self(); + start_task( ctx, A_1, worker, 1, SCHED_A ); + start_task( ctx, A_2_0, worker, 2, SCHED_A ); + start_task( ctx, A_2_1, worker, 2, SCHED_A ); + start_task( ctx, H_A, helper, 3, SCHED_A ); - if (rtems_scheduler_get_processor_maximum() >= PART_COUNT) { - start_task(ctx, B_4, worker, 4, SCHED_B); - start_task(ctx, B_5_0, worker, 5, SCHED_B); - start_task(ctx, B_5_1, worker, 5, SCHED_B); - start_task(ctx, H_B, helper, 6, SCHED_B); + if ( rtems_scheduler_get_processor_maximum() >= PART_COUNT ) { + start_task( ctx, B_4, worker, 4, SCHED_B ); + start_task( ctx, B_5_0, worker, 5, SCHED_B ); + start_task( ctx, B_5_1, worker, 5, SCHED_B ); + start_task( ctx, H_B, helper, 6, SCHED_B ); } sc = rtems_semaphore_create( - rtems_build_name('M', 'T', 'X', '1'), + rtems_build_name( 'M', 'T', 'X', '1' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0, &ctx->mtx ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name('M', 'T', 'X', '2'), + rtems_build_name( 'M', 'T', 'X', '2' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0, &ctx->mtx_2 ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name(' ', 'S', 'E', 'M'), + rtems_build_name( ' ', 'S', 'E', 'M' ), 0, RTEMS_COUNTING_SEMAPHORE | RTEMS_PRIORITY, 0, &ctx->sem ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name('C', 'E', 'I', 'L'), + rtems_build_name( 'C', 'E', 'I', 'L' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, 1, &ctx->ceil ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test_simple_inheritance(test_context *ctx) +static void test_simple_inheritance( test_context *ctx ) { - obtain(ctx); - request(ctx, A_1, REQ_MTX_OBTAIN); - check_generations(ctx, NONE, NONE); - assert_prio(ctx, M, 1); - release(ctx); - check_generations(ctx, A_1, NONE); - assert_prio(ctx, M, 3); - request(ctx, A_1, REQ_MTX_RELEASE); - check_generations(ctx, A_1, NONE); + obtain( ctx ); + request( ctx, A_1, REQ_MTX_OBTAIN ); + check_generations( ctx, NONE, NONE ); + assert_prio( ctx, M, 1 ); + release( ctx ); + check_generations( ctx, A_1, NONE ); + assert_prio( ctx, M, 3 ); + request( ctx, A_1, REQ_MTX_RELEASE ); + check_generations( ctx, A_1, NONE ); } -static void test_flush_inheritance(test_context *ctx) +static void test_flush_inheritance( test_context *ctx ) { - assert_prio(ctx, M, 3); - obtain(ctx); - send_event(ctx, A_1, REQ_MTX_OBTAIN_UNSATISFIED); - check_generations(ctx, NONE, NONE); - assert_prio(ctx, M, 1); - flush(ctx); - check_generations(ctx, A_1, NONE); - assert_prio(ctx, M, 3); - release(ctx); + assert_prio( ctx, M, 3 ); + obtain( ctx ); + send_event( ctx, A_1, REQ_MTX_OBTAIN_UNSATISFIED ); + check_generations( ctx, NONE, NONE ); + assert_prio( ctx, M, 1 ); + flush( ctx ); + check_generations( ctx, A_1, NONE ); + assert_prio( ctx, M, 3 ); + release( ctx ); } -static void test_ceiling_mutex(test_context *ctx) +static void test_ceiling_mutex( test_context *ctx ) { - assert_prio(ctx, M, 3); - ceil_obtain(ctx); - assert_prio(ctx, M, 1); - send_event(ctx, A_1, REQ_CEIL_OBTAIN); + assert_prio( ctx, M, 3 ); + ceil_obtain( ctx ); + assert_prio( ctx, M, 1 ); + send_event( ctx, A_1, REQ_CEIL_OBTAIN ); yield(); - check_generations(ctx, NONE, NONE); - ceil_release(ctx); - check_generations(ctx, A_1, NONE); - assert_prio(ctx, M, 3); - send_event(ctx, A_1, REQ_CEIL_RELEASE); - check_generations(ctx, A_1, NONE); + check_generations( ctx, NONE, NONE ); + ceil_release( ctx ); + check_generations( ctx, A_1, NONE ); + assert_prio( ctx, M, 3 ); + send_event( ctx, A_1, REQ_CEIL_RELEASE ); + check_generations( ctx, A_1, NONE ); } -static void test_dequeue_order_one_scheduler_instance(test_context *ctx) +static void test_dequeue_order_one_scheduler_instance( test_context *ctx ) { - obtain(ctx); - request(ctx, A_2_0, REQ_MTX_OBTAIN); - request(ctx, A_1, REQ_MTX_OBTAIN); - request(ctx, A_2_1, REQ_MTX_OBTAIN); - check_generations(ctx, NONE, NONE); - assert_prio(ctx, M, 1); - release(ctx); - check_generations(ctx, A_1, NONE); - assert_prio(ctx, M, 3); - assert_prio(ctx, A_1, 1); - request(ctx, A_1, REQ_MTX_RELEASE); - check_generations(ctx, A_1, A_2_0); - request(ctx, A_2_0, REQ_MTX_RELEASE); - check_generations(ctx, A_2_0, A_2_1); - request(ctx, A_2_1, REQ_MTX_RELEASE); - check_generations(ctx, A_2_1, NONE); + obtain( ctx ); + request( ctx, A_2_0, REQ_MTX_OBTAIN ); + request( ctx, A_1, REQ_MTX_OBTAIN ); + request( ctx, A_2_1, REQ_MTX_OBTAIN ); + check_generations( ctx, NONE, NONE ); + assert_prio( ctx, M, 1 ); + release( ctx ); + check_generations( ctx, A_1, NONE ); + assert_prio( ctx, M, 3 ); + assert_prio( ctx, A_1, 1 ); + request( ctx, A_1, REQ_MTX_RELEASE ); + check_generations( ctx, A_1, A_2_0 ); + request( ctx, A_2_0, REQ_MTX_RELEASE ); + check_generations( ctx, A_2_0, A_2_1 ); + request( ctx, A_2_1, REQ_MTX_RELEASE ); + check_generations( ctx, A_2_1, NONE ); } -static void test_mixed_queue_two_scheduler_instances(test_context *ctx) +static void test_mixed_queue_two_scheduler_instances( test_context *ctx ) { - obtain(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + obtain( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - request(ctx, B_4, REQ_MTX_OBTAIN_TIMEOUT); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); - check_generations(ctx, NONE, NONE); + request( ctx, B_4, REQ_MTX_OBTAIN_TIMEOUT ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); + check_generations( ctx, NONE, NONE ); wait(); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - check_generations(ctx, B_4, NONE); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + check_generations( ctx, B_4, NONE ); - request(ctx, B_4, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); - check_generations(ctx, NONE, NONE); + request( ctx, B_4, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); + check_generations( ctx, NONE, NONE ); - request(ctx, B_5_0, REQ_SEM_OBTAIN_RELEASE); - send_event(ctx, H_A, REQ_SEM_RELEASE); - check_generations(ctx, NONE, NONE); + request( ctx, B_5_0, REQ_SEM_OBTAIN_RELEASE ); + send_event( ctx, H_A, REQ_SEM_RELEASE ); + check_generations( ctx, NONE, NONE ); /* * We are in scheduler instance A. Task B_5_0 of scheduler instance B issued @@ -670,449 +666,459 @@ static void test_mixed_queue_two_scheduler_instances(test_context *ctx) * priority of B_4, so we get the semaphore before B_5_0 (priority order * within scheduler instance B). */ - sem_obtain(ctx); - check_generations(ctx, NONE, NONE); + sem_obtain( ctx ); + check_generations( ctx, NONE, NONE ); - release(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - sync_with_helper(ctx); - check_generations(ctx, B_4, NONE); + release( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + sync_with_helper( ctx ); + check_generations( ctx, B_4, NONE ); - request(ctx, B_4, REQ_MTX_RELEASE); - check_generations(ctx, B_4, NONE); + request( ctx, B_4, REQ_MTX_RELEASE ); + check_generations( ctx, B_4, NONE ); - sem_release(ctx); - sync_with_helper(ctx); - check_generations(ctx, B_5_0, NONE); + sem_release( ctx ); + sync_with_helper( ctx ); + check_generations( ctx, B_5_0, NONE ); - sem_obtain(ctx); + sem_obtain( ctx ); } -static void test_mixed_queue_two_scheduler_instances_sem_only(test_context *ctx) +static void test_mixed_queue_two_scheduler_instances_sem_only( + test_context *ctx +) { - request(ctx, B_5_0, REQ_SEM_OBTAIN_RELEASE); - send_event(ctx, H_A, REQ_SEM_RELEASE); - check_generations(ctx, NONE, NONE); + request( ctx, B_5_0, REQ_SEM_OBTAIN_RELEASE ); + send_event( ctx, H_A, REQ_SEM_RELEASE ); + check_generations( ctx, NONE, NONE ); /* * We are in scheduler instance A. Task B_5_0 of scheduler instance B issued * the counting semaphore obtain before us. No priority inheritance is * involved, so task B_5_0 gets the counting semaphore first. */ - sem_obtain(ctx); - check_generations(ctx, B_5_0, NONE); + sem_obtain( ctx ); + check_generations( ctx, B_5_0, NONE ); - sem_release(ctx); + sem_release( ctx ); } -static void test_two_scheduler_instances_sem_with_inheritance(test_context *ctx) +static void test_two_scheduler_instances_sem_with_inheritance( + test_context *ctx +) { - sem_obtain(ctx); + sem_obtain( ctx ); - request(ctx, B_4, REQ_MTX_OBTAIN); - check_generations(ctx, B_4, NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_OBTAIN ); + check_generations( ctx, B_4, NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); - request(ctx, B_4, REQ_SEM_OBTAIN_RELEASE); - check_generations(ctx, NONE, NONE); + request( ctx, B_4, REQ_SEM_OBTAIN_RELEASE ); + check_generations( ctx, NONE, NONE ); - request(ctx, A_1, REQ_MTX_OBTAIN); - check_generations(ctx, NONE, NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, 1); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); + request( ctx, A_1, REQ_MTX_OBTAIN ); + check_generations( ctx, NONE, NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, 1 ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); - sem_release(ctx); - sync_with_helper(ctx); - check_generations(ctx, B_4, NONE); + sem_release( ctx ); + sync_with_helper( ctx ); + check_generations( ctx, B_4, NONE ); - request(ctx, B_4, REQ_MTX_RELEASE); - check_generations(ctx, B_4, A_1); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_RELEASE ); + check_generations( ctx, B_4, A_1 ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); - request(ctx, A_1, REQ_MTX_RELEASE); - check_generations(ctx, A_1, NONE); + request( ctx, A_1, REQ_MTX_RELEASE ); + check_generations( ctx, A_1, NONE ); } -static void test_two_scheduler_instances_sem_with_inheritance_timeout(test_context *ctx) +static void test_two_scheduler_instances_sem_with_inheritance_timeout( + test_context *ctx +) { - sem_obtain(ctx); + sem_obtain( ctx ); - request(ctx, B_4, REQ_MTX_OBTAIN); - check_generations(ctx, B_4, NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_OBTAIN ); + check_generations( ctx, B_4, NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); - request(ctx, B_4, REQ_SEM_OBTAIN_RELEASE); - check_generations(ctx, NONE, NONE); + request( ctx, B_4, REQ_SEM_OBTAIN_RELEASE ); + check_generations( ctx, NONE, NONE ); - request(ctx, A_1, REQ_MTX_OBTAIN_TIMEOUT); - check_generations(ctx, NONE, NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, 1); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); + request( ctx, A_1, REQ_MTX_OBTAIN_TIMEOUT ); + check_generations( ctx, NONE, NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, 1 ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); wait(); - check_generations(ctx, A_1, NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); + check_generations( ctx, A_1, NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); - sem_release(ctx); - sync_with_helper(ctx); - check_generations(ctx, B_4, NONE); + sem_release( ctx ); + sync_with_helper( ctx ); + check_generations( ctx, B_4, NONE ); - request(ctx, B_4, REQ_MTX_RELEASE); - check_generations(ctx, B_4, NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_RELEASE ); + check_generations( ctx, B_4, NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); } -static void test_simple_inheritance_two_scheduler_instances(test_context *ctx) +static void test_simple_inheritance_two_scheduler_instances( + test_context *ctx +) { - obtain(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + obtain( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - request(ctx, B_5_0, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); + request( ctx, B_5_0, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); - request(ctx, B_4, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); - request(ctx, B_5_1, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); - check_generations(ctx, NONE, NONE); + request( ctx, B_5_1, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); + check_generations( ctx, NONE, NONE ); - release(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - sync_with_helper(ctx); - check_generations(ctx, B_4, NONE); + release( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + sync_with_helper( ctx ); + check_generations( ctx, B_4, NONE ); - request(ctx, B_4, REQ_MTX_RELEASE); - check_generations(ctx, B_4, B_5_0); + request( ctx, B_4, REQ_MTX_RELEASE ); + check_generations( ctx, B_4, B_5_0 ); - request(ctx, B_5_0, REQ_MTX_RELEASE); - check_generations(ctx, B_5_0, B_5_1); + request( ctx, B_5_0, REQ_MTX_RELEASE ); + check_generations( ctx, B_5_0, B_5_1 ); - request(ctx, B_5_1, REQ_MTX_RELEASE); - check_generations(ctx, B_5_1, NONE); + request( ctx, B_5_1, REQ_MTX_RELEASE ); + check_generations( ctx, B_5_1, NONE ); } -static void test_nested_inheritance_two_scheduler_instances(test_context *ctx) +static void test_nested_inheritance_two_scheduler_instances( + test_context *ctx +) { - obtain_2(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + obtain_2( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - request(ctx, B_5_0, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - check_generations(ctx, B_5_0, NONE); + request( ctx, B_5_0, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + check_generations( ctx, B_5_0, NONE ); - request(ctx, B_5_0, REQ_MTX_2_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); + request( ctx, B_5_0, REQ_MTX_2_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); - request(ctx, B_4, REQ_MTX_OBTAIN_TIMEOUT); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_OBTAIN_TIMEOUT ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 4 ); wait(); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - check_generations(ctx, B_4, NONE); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + check_generations( ctx, B_4, NONE ); - request(ctx, B_4, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 4 ); - request(ctx, B_5_1, REQ_MTX_2_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4); - check_generations(ctx, NONE, NONE); + request( ctx, B_5_1, REQ_MTX_2_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 4 ); + check_generations( ctx, NONE, NONE ); - release_2(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 4); - sync_with_helper(ctx); - check_generations(ctx, B_5_0, NONE); + release_2( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 4 ); + sync_with_helper( ctx ); + check_generations( ctx, B_5_0, NONE ); - request(ctx, B_5_0, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - check_generations(ctx, B_4, B_5_0); + request( ctx, B_5_0, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + check_generations( ctx, B_4, B_5_0 ); - request(ctx, B_4, REQ_MTX_RELEASE); - check_generations(ctx, B_4, NONE); + request( ctx, B_4, REQ_MTX_RELEASE ); + check_generations( ctx, B_4, NONE ); - request(ctx, B_5_0, REQ_MTX_2_RELEASE); - check_generations(ctx, B_5_0, B_5_1); + request( ctx, B_5_0, REQ_MTX_2_RELEASE ); + check_generations( ctx, B_5_0, B_5_1 ); - request(ctx, B_5_1, REQ_MTX_2_RELEASE); - check_generations(ctx, B_5_1, NONE); + request( ctx, B_5_1, REQ_MTX_2_RELEASE ); + check_generations( ctx, B_5_1, NONE ); } -static void test_dequeue_order_two_scheduler_instances(test_context *ctx) +static void test_dequeue_order_two_scheduler_instances( test_context *ctx ) { - obtain(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + obtain( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - request(ctx, A_2_0, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 2); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - check_generations(ctx, NONE, NONE); + request( ctx, A_2_0, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + check_generations( ctx, NONE, NONE ); - request(ctx, B_5_0, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 2); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); - check_generations(ctx, NONE, NONE); + request( ctx, B_5_0, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); + check_generations( ctx, NONE, NONE ); - request(ctx, B_5_1, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 2); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); + request( ctx, B_5_1, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); - request(ctx, B_4, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 2); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); + request( ctx, B_4, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); - request(ctx, A_2_1, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 2); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); + request( ctx, A_2_1, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); - request(ctx, A_1, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 1); - assert_prio_by_scheduler(ctx, M, SCHED_B, 4); - check_generations(ctx, NONE, NONE); + request( ctx, A_1, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 1 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 4 ); + check_generations( ctx, NONE, NONE ); - release(ctx); - sync_with_helper(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - assert_prio_by_scheduler(ctx, A_1, SCHED_A, 1); - assert_prio_by_scheduler(ctx, A_1, SCHED_B, 4); - check_generations(ctx, A_1, NONE); + release( ctx ); + sync_with_helper( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + assert_prio_by_scheduler( ctx, A_1, SCHED_A, 1 ); + assert_prio_by_scheduler( ctx, A_1, SCHED_B, 4 ); + check_generations( ctx, A_1, NONE ); - request(ctx, A_1, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, A_1, SCHED_A, 1); - assert_prio_by_scheduler(ctx, A_1, SCHED_B, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, 2); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); - check_generations(ctx, A_1, B_4); + request( ctx, A_1, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, A_1, SCHED_A, 1 ); + assert_prio_by_scheduler( ctx, A_1, SCHED_B, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); + check_generations( ctx, A_1, B_4 ); - request(ctx, B_4, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, B_4, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_4, SCHED_B, 4); - assert_prio_by_scheduler(ctx, A_2_0, SCHED_A, 2); - assert_prio_by_scheduler(ctx, A_2_0, SCHED_B, 5); - check_generations(ctx, B_4, A_2_0); + request( ctx, B_4, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_4, SCHED_B, 4 ); + assert_prio_by_scheduler( ctx, A_2_0, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, A_2_0, SCHED_B, 5 ); + check_generations( ctx, B_4, A_2_0 ); - request(ctx, A_2_0, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, A_2_0, SCHED_A, 2); - assert_prio_by_scheduler(ctx, A_2_0, SCHED_B, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, 2); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - check_generations(ctx, A_2_0, B_5_0); + request( ctx, A_2_0, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, A_2_0, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, A_2_0, SCHED_B, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + check_generations( ctx, A_2_0, B_5_0 ); - request(ctx, B_5_0, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - assert_prio_by_scheduler(ctx, A_2_1, SCHED_A, 2); - assert_prio_by_scheduler(ctx, A_2_1, SCHED_B, 5); - check_generations(ctx, B_5_0, A_2_1); + request( ctx, B_5_0, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + assert_prio_by_scheduler( ctx, A_2_1, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, A_2_1, SCHED_B, 5 ); + check_generations( ctx, B_5_0, A_2_1 ); - request(ctx, A_2_1, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, A_2_1, SCHED_A, 2); - assert_prio_by_scheduler(ctx, A_2_1, SCHED_B, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_1, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_1, SCHED_B, 5); - check_generations(ctx, A_2_1, B_5_1); + request( ctx, A_2_1, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, A_2_1, SCHED_A, 2 ); + assert_prio_by_scheduler( ctx, A_2_1, SCHED_B, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_1, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_1, SCHED_B, 5 ); + check_generations( ctx, A_2_1, B_5_1 ); - request(ctx, B_5_1, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, B_5_1, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_1, SCHED_B, 5); - check_generations(ctx, B_5_1, NONE); + request( ctx, B_5_1, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, B_5_1, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_1, SCHED_B, 5 ); + check_generations( ctx, B_5_1, NONE ); } -static void test_omip_pre_emption(test_context *ctx) +static void test_omip_pre_emption( test_context *ctx ) { - assert_cpu(0); - obtain(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + assert_cpu( 0 ); + obtain( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - request(ctx, B_5_0, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); - check_generations(ctx, NONE, NONE); + request( ctx, B_5_0, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); + check_generations( ctx, NONE, NONE ); - request_pre_emption(ctx, A_1); - assert_cpu(1); + request_pre_emption( ctx, A_1 ); + assert_cpu( 1 ); - request_pre_emption(ctx, B_4); - assert_cpu(0); + request_pre_emption( ctx, B_4 ); + assert_cpu( 0 ); - request_pre_emption(ctx, A_1); - assert_cpu(1); + request_pre_emption( ctx, A_1 ); + assert_cpu( 1 ); - release(ctx); - assert_cpu(0); - sync_with_helper(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - check_generations(ctx, B_5_0, NONE); + release( ctx ); + assert_cpu( 0 ); + sync_with_helper( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + check_generations( ctx, B_5_0, NONE ); - request(ctx, B_5_0, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - check_generations(ctx, B_5_0, NONE); + request( ctx, B_5_0, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + check_generations( ctx, B_5_0, NONE ); } -static void test_omip_rescue(test_context *ctx) +static void test_omip_rescue( test_context *ctx ) { - assert_cpu(0); - obtain(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + assert_cpu( 0 ); + obtain( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - clear_done(ctx); - set_event_3(ctx, H_B, REQ_SET_DONE); - set_event_2(ctx, B_5_0, REQ_SEND_EVENT_3 | REQ_MTX_OBTAIN); - send_event(ctx, A_1, REQ_SEND_EVENT_2 | REQ_WAIT_FOR_DONE); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); - assert_cpu(1); + clear_done( ctx ); + set_event_3( ctx, H_B, REQ_SET_DONE ); + set_event_2( ctx, B_5_0, REQ_SEND_EVENT_3 | REQ_MTX_OBTAIN ); + send_event( ctx, A_1, REQ_SEND_EVENT_2 | REQ_WAIT_FOR_DONE ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); + assert_cpu( 1 ); - release(ctx); - assert_cpu(0); - sync_with_helper(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - check_generations(ctx, B_5_0, NONE); + release( ctx ); + assert_cpu( 0 ); + sync_with_helper( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + check_generations( ctx, B_5_0, NONE ); - request(ctx, B_5_0, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - check_generations(ctx, B_5_0, NONE); + request( ctx, B_5_0, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + check_generations( ctx, B_5_0, NONE ); } -static void test_omip_timeout(test_context *ctx) +static void test_omip_timeout( test_context *ctx ) { - assert_cpu(0); - obtain(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + assert_cpu( 0 ); + obtain( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - clear_done(ctx); - set_event_3(ctx, H_B, REQ_SET_DONE); - set_event_2(ctx, B_5_0, REQ_SEND_EVENT_3 | REQ_MTX_OBTAIN_TIMEOUT); - send_event(ctx, A_1, REQ_SEND_EVENT_2 | REQ_WAIT_FOR_DONE); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); - assert_cpu(1); + clear_done( ctx ); + set_event_3( ctx, H_B, REQ_SET_DONE ); + set_event_2( ctx, B_5_0, REQ_SEND_EVENT_3 | REQ_MTX_OBTAIN_TIMEOUT ); + send_event( ctx, A_1, REQ_SEND_EVENT_2 | REQ_WAIT_FOR_DONE ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); + assert_cpu( 1 ); wait(); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - check_generations(ctx, B_5_0, NONE); - assert_cpu(0); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + check_generations( ctx, B_5_0, NONE ); + assert_cpu( 0 ); - release(ctx); + release( ctx ); } -static void test_omip_yield(test_context *ctx) +static void test_omip_yield( test_context *ctx ) { - assert_cpu(0); - obtain(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); + assert_cpu( 0 ); + obtain( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); - request(ctx, B_5_0, REQ_MTX_OBTAIN); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, 5); - check_generations(ctx, NONE, NONE); + request( ctx, B_5_0, REQ_MTX_OBTAIN ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, 5 ); + check_generations( ctx, NONE, NONE ); - clear_done(ctx); - send_event(ctx, H_A, REQ_SET_DONE); + clear_done( ctx ); + send_event( ctx, H_A, REQ_SET_DONE ); yield(); - assert_cpu(1); - wait_for_done(ctx); + assert_cpu( 1 ); + wait_for_done( ctx ); - clear_done(ctx); - send_event(ctx, H_B, REQ_SET_DONE); - set_prio(ctx, H_B, 5); + clear_done( ctx ); + send_event( ctx, H_B, REQ_SET_DONE ); + set_prio( ctx, H_B, 5 ); yield(); - assert_cpu(1); - rtems_test_assert(!is_done(ctx)); + assert_cpu( 1 ); + rtems_test_assert( !is_done( ctx ) ); - set_prio(ctx, H_B, 4); - assert_cpu(0); + set_prio( ctx, H_B, 4 ); + assert_cpu( 0 ); - wait_for_done(ctx); - set_prio(ctx, H_B, 6); + wait_for_done( ctx ); + set_prio( ctx, H_B, 6 ); - release(ctx); - sync_with_helper(ctx); - assert_prio_by_scheduler(ctx, M, SCHED_A, 3); - assert_prio_by_scheduler(ctx, M, SCHED_B, PRIO_NONE); - check_generations(ctx, B_5_0, NONE); + release( ctx ); + sync_with_helper( ctx ); + assert_prio_by_scheduler( ctx, M, SCHED_A, 3 ); + assert_prio_by_scheduler( ctx, M, SCHED_B, PRIO_NONE ); + check_generations( ctx, B_5_0, NONE ); - request(ctx, B_5_0, REQ_MTX_RELEASE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_A, PRIO_NONE); - assert_prio_by_scheduler(ctx, B_5_0, SCHED_B, 5); - check_generations(ctx, B_5_0, NONE); + request( ctx, B_5_0, REQ_MTX_RELEASE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_A, PRIO_NONE ); + assert_prio_by_scheduler( ctx, B_5_0, SCHED_B, 5 ); + check_generations( ctx, B_5_0, NONE ); } -static void test(test_context *ctx) +static void test( test_context *ctx ) { - test_init(ctx); + test_init( ctx ); - if (rtems_scheduler_get_processor_maximum() >= PART_COUNT) { - test_task_get_priority_not_defined(ctx); - test_simple_inheritance(ctx); - test_dequeue_order_one_scheduler_instance(ctx); - test_mixed_queue_two_scheduler_instances(ctx); - test_mixed_queue_two_scheduler_instances_sem_only(ctx); - test_two_scheduler_instances_sem_with_inheritance(ctx); - test_two_scheduler_instances_sem_with_inheritance_timeout(ctx); - test_simple_inheritance_two_scheduler_instances(ctx); - test_nested_inheritance_two_scheduler_instances(ctx); - test_dequeue_order_two_scheduler_instances(ctx); - test_omip_pre_emption(ctx); - test_omip_rescue(ctx); - test_omip_timeout(ctx); - test_omip_yield(ctx); + if ( rtems_scheduler_get_processor_maximum() >= PART_COUNT ) { + test_task_get_priority_not_defined( ctx ); + test_simple_inheritance( ctx ); + test_dequeue_order_one_scheduler_instance( ctx ); + test_mixed_queue_two_scheduler_instances( ctx ); + test_mixed_queue_two_scheduler_instances_sem_only( ctx ); + test_two_scheduler_instances_sem_with_inheritance( ctx ); + test_two_scheduler_instances_sem_with_inheritance_timeout( ctx ); + test_simple_inheritance_two_scheduler_instances( ctx ); + test_nested_inheritance_two_scheduler_instances( ctx ); + test_dequeue_order_two_scheduler_instances( ctx ); + test_omip_pre_emption( ctx ); + test_omip_rescue( ctx ); + test_omip_timeout( ctx ); + test_omip_yield( ctx ); } - test_flush_inheritance(ctx); - test_ceiling_mutex(ctx); + test_flush_inheritance( ctx ); + test_ceiling_mutex( ctx ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - test(&test_instance); + test( &test_instance ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -1124,17 +1130,17 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_SIMPLE_SMP(a); +RTEMS_SCHEDULER_SIMPLE_SMP( a ); -RTEMS_SCHEDULER_SIMPLE_SMP(b); +RTEMS_SCHEDULER_SIMPLE_SMP( b ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(a, SCHED_A), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(b, SCHED_B) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( a, SCHED_A ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( b, SCHED_B ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_MAXIMUM_TASKS TASK_COUNT diff --git a/testsuites/smptests/smpmutex02/init.c b/testsuites/smptests/smpmutex02/init.c index 95c3f833a9..92bfd23db3 100644 --- a/testsuites/smptests/smpmutex02/init.c +++ b/testsuites/smptests/smpmutex02/init.c @@ -46,9 +46,9 @@ const char rtems_test_name[] = "SMPMUTEX 2"; #define CPU_COUNT 32 -#define MTX_COUNT (CPU_COUNT * MTX_PER_CPU) +#define MTX_COUNT ( CPU_COUNT * MTX_PER_CPU ) -#define WORKER_COUNT (CPU_COUNT * WORKER_PER_CPU) +#define WORKER_COUNT ( CPU_COUNT * WORKER_PER_CPU ) typedef struct { uint32_t obtain_counter; @@ -59,19 +59,19 @@ typedef struct { } test_stats; typedef struct { - uint32_t cpu_count; - uint32_t mtx_count; - rtems_id worker_ids[CPU_COUNT][WORKER_PER_CPU]; - rtems_id scheduler_ids[CPU_COUNT]; - rtems_id mtx_ids[MTX_COUNT]; - rtems_id counting_sem_id; - volatile bool stop_worker[WORKER_COUNT]; - test_stats stats[WORKER_COUNT]; + uint32_t cpu_count; + uint32_t mtx_count; + rtems_id worker_ids[ CPU_COUNT ][ WORKER_PER_CPU ]; + rtems_id scheduler_ids[ CPU_COUNT ]; + rtems_id mtx_ids[ MTX_COUNT ]; + rtems_id counting_sem_id; + volatile bool stop_worker[ WORKER_COUNT ]; + test_stats stats[ WORKER_COUNT ]; } test_context; static test_context test_instance; -static uint32_t simple_random(uint32_t v) +static uint32_t simple_random( uint32_t v ) { v *= 1664525; v += 1013904223; @@ -80,221 +80,220 @@ static uint32_t simple_random(uint32_t v) } typedef struct { - uint32_t guide; - size_t mtx_stack[MTX_COUNT]; - bool mtx_owned[MTX_COUNT]; - size_t nest_level; + uint32_t guide; + size_t mtx_stack[ MTX_COUNT ]; + bool mtx_owned[ MTX_COUNT ]; + size_t nest_level; test_stats stats; } worker_context; -static void release(test_context *ctx, worker_context *wc, size_t nest_level) +static void release( test_context *ctx, worker_context *wc, size_t nest_level ) { (void) nest_level; rtems_status_code sc; - size_t i; + size_t i; --wc->nest_level; ++wc->stats.release_counter; - i = wc->mtx_stack[wc->nest_level]; - wc->mtx_owned[i] = false; + i = wc->mtx_stack[ wc->nest_level ]; + wc->mtx_owned[ i ] = false; - sc = rtems_semaphore_release(ctx->mtx_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->mtx_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void release_all(test_context *ctx, worker_context *wc) +static void release_all( test_context *ctx, worker_context *wc ) { - while (wc->nest_level > 0) { - release(ctx, wc, wc->nest_level); + while ( wc->nest_level > 0 ) { + release( ctx, wc, wc->nest_level ); } } -static void worker(rtems_task_argument index) +static void worker( rtems_task_argument index ) { - test_context *ctx; - worker_context wc; + test_context *ctx; + worker_context wc; rtems_status_code sc; ctx = &test_instance; - memset(&wc, 0, sizeof(wc)); + memset( &wc, 0, sizeof( wc ) ); wc.guide = index; - while (!ctx->stop_worker[index]) { + while ( !ctx->stop_worker[ index ] ) { uint32_t action; uint32_t i; - if (wc.nest_level < ctx->mtx_count) { - action = (wc.guide >> 23) % 2; + if ( wc.nest_level < ctx->mtx_count ) { + action = ( wc.guide >> 23 ) % 2; } else { action = UINT32_MAX; } - i = (wc.guide >> 13) % ctx->mtx_count; + i = ( wc.guide >> 13 ) % ctx->mtx_count; - switch (action) { + switch ( action ) { case 0: - if ( !wc.mtx_owned[i] ) { - sc = rtems_semaphore_obtain(ctx->mtx_ids[i], RTEMS_WAIT, 1); + if ( !wc.mtx_owned[ i ] ) { + sc = rtems_semaphore_obtain( ctx->mtx_ids[ i ], RTEMS_WAIT, 1 ); - if (sc == RTEMS_SUCCESSFUL) { - wc.mtx_owned[i] = true; - wc.mtx_stack[wc.nest_level] = i; + if ( sc == RTEMS_SUCCESSFUL ) { + wc.mtx_owned[ i ] = true; + wc.mtx_stack[ wc.nest_level ] = i; ++wc.nest_level; ++wc.stats.obtain_counter; - if (wc.nest_level > wc.stats.max_nest_level) { + if ( wc.nest_level > wc.stats.max_nest_level ) { wc.stats.max_nest_level = wc.nest_level; } - } else if (sc == RTEMS_INCORRECT_STATE) { + } else if ( sc == RTEMS_INCORRECT_STATE ) { ++wc.stats.deadlock_counter; - release_all(ctx, &wc); - } else if (sc == RTEMS_TIMEOUT) { + release_all( ctx, &wc ); + } else if ( sc == RTEMS_TIMEOUT ) { ++wc.stats.timeout_counter; - release_all(ctx, &wc); + release_all( ctx, &wc ); } else { - rtems_test_assert(0); + rtems_test_assert( 0 ); } } break; default: - if (wc.nest_level > 0) { - release(ctx, &wc, wc.nest_level); + if ( wc.nest_level > 0 ) { + release( ctx, &wc, wc.nest_level ); } break; } - wc.guide = simple_random(wc.guide); + wc.guide = simple_random( wc.guide ); } - release_all(ctx, &wc); + release_all( ctx, &wc ); - ctx->stats[index] = wc.stats; + ctx->stats[ index ] = wc.stats; - sc = rtems_semaphore_release(ctx->counting_sem_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( ctx->counting_sem_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(0); + rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( 0 ); } -static void set_up(test_context *ctx) +static void set_up( test_context *ctx ) { rtems_status_code sc; - uint32_t i; + uint32_t i; ctx->cpu_count = rtems_scheduler_get_processor_maximum(); ctx->mtx_count = MTX_PER_CPU * ctx->cpu_count; sc = rtems_semaphore_create( - rtems_build_name('S', 'Y', 'N', 'C'), + rtems_build_name( 'S', 'Y', 'N', 'C' ), 0, RTEMS_COUNTING_SEMAPHORE, 0, &ctx->counting_sem_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < ctx->mtx_count; ++i) { + for ( i = 0; i < ctx->mtx_count; ++i ) { sc = rtems_semaphore_create( - rtems_build_name('M', 'U', 'T', 'X'), + rtems_build_name( 'M', 'U', 'T', 'X' ), 1, - RTEMS_BINARY_SEMAPHORE - | RTEMS_PRIORITY - | RTEMS_INHERIT_PRIORITY, + RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 0, - &ctx->mtx_ids[i] + &ctx->mtx_ids[ i ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (i = 0; i < ctx->cpu_count; ++i) { + for ( i = 0; i < ctx->cpu_count; ++i ) { size_t j; - sc = rtems_scheduler_ident(i, &ctx->scheduler_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( i, &ctx->scheduler_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (j = 0; j < WORKER_PER_CPU; ++j) { + for ( j = 0; j < WORKER_PER_CPU; ++j ) { sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->worker_ids[i][j] + &ctx->worker_ids[ i ][ j ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_set_scheduler( - ctx->worker_ids[i][j], - ctx->scheduler_ids[i], + ctx->worker_ids[ i ][ j ], + ctx->scheduler_ids[ i ], 2 + j ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_start( - ctx->worker_ids[i][j], + ctx->worker_ids[ i ][ j ], worker, i * WORKER_PER_CPU + j ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } } -static void run(test_context *ctx) +static void run( test_context *ctx ) { rtems_status_code sc; - uint32_t i; + uint32_t i; - sc = rtems_task_wake_after(10 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 10 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < WORKER_PER_CPU * ctx->cpu_count; ++i) { - ctx->stop_worker[i] = true; + for ( i = 0; i < WORKER_PER_CPU * ctx->cpu_count; ++i ) { + ctx->stop_worker[ i ] = true; } - for (i = 0; i < WORKER_PER_CPU * ctx->cpu_count; ++i) { + for ( i = 0; i < WORKER_PER_CPU * ctx->cpu_count; ++i ) { sc = rtems_semaphore_obtain( ctx->counting_sem_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void tear_down(test_context *ctx) +static void tear_down( test_context *ctx ) { rtems_status_code sc; - uint32_t i; + uint32_t i; - for (i = 0; i < ctx->cpu_count; ++i) { + for ( i = 0; i < ctx->cpu_count; ++i ) { size_t j; - for (j = 0; j < WORKER_PER_CPU; ++j) { - sc = rtems_task_delete(ctx->worker_ids[i][j]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( j = 0; j < WORKER_PER_CPU; ++j ) { + sc = rtems_task_delete( ctx->worker_ids[ i ][ j ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } - for (i = 0; i < ctx->mtx_count; ++i) { - sc = rtems_semaphore_delete(ctx->mtx_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( i = 0; i < ctx->mtx_count; ++i ) { + sc = rtems_semaphore_delete( ctx->mtx_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_semaphore_delete(ctx->counting_sem_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( ctx->counting_sem_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < WORKER_PER_CPU * ctx->cpu_count; ++i) { + for ( i = 0; i < WORKER_PER_CPU * ctx->cpu_count; ++i ) { const test_stats *stats; - stats = &ctx->stats[i]; + stats = &ctx->stats[ i ]; - printf("worker[%" PRIu32 "][%" PRIu32 "]\n" + printf( + "worker[%" PRIu32 "][%" PRIu32 "]\n" "\tobtain counter = %" PRIu32 "\n" "\tdeadlock counter = %" PRIu32 "\n" "\ttimeout counter = %" PRIu32 "\n" @@ -311,24 +310,24 @@ static void tear_down(test_context *ctx) } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; - test_context *ctx; + test_context *ctx; rtems_resource_snapshot snapshot; TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); ctx = &test_instance; - set_up(ctx); - run(ctx); - tear_down(ctx); + set_up( ctx ); + run( ctx ); + tear_down( ctx ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_MICROSECONDS_PER_TICK 1000 @@ -336,8 +335,8 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS (1 + WORKER_COUNT) -#define CONFIGURE_MAXIMUM_SEMAPHORES (1 + MTX_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + WORKER_COUNT ) +#define CONFIGURE_MAXIMUM_SEMAPHORES ( 1 + MTX_COUNT ) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT @@ -345,106 +344,106 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_SIMPLE_SMP(0); -RTEMS_SCHEDULER_SIMPLE_SMP(1); -RTEMS_SCHEDULER_SIMPLE_SMP(2); -RTEMS_SCHEDULER_SIMPLE_SMP(3); -RTEMS_SCHEDULER_SIMPLE_SMP(4); -RTEMS_SCHEDULER_SIMPLE_SMP(5); -RTEMS_SCHEDULER_SIMPLE_SMP(6); -RTEMS_SCHEDULER_SIMPLE_SMP(7); -RTEMS_SCHEDULER_SIMPLE_SMP(8); -RTEMS_SCHEDULER_SIMPLE_SMP(9); -RTEMS_SCHEDULER_SIMPLE_SMP(10); -RTEMS_SCHEDULER_SIMPLE_SMP(11); -RTEMS_SCHEDULER_SIMPLE_SMP(12); -RTEMS_SCHEDULER_SIMPLE_SMP(13); -RTEMS_SCHEDULER_SIMPLE_SMP(14); -RTEMS_SCHEDULER_SIMPLE_SMP(15); -RTEMS_SCHEDULER_SIMPLE_SMP(16); -RTEMS_SCHEDULER_SIMPLE_SMP(17); -RTEMS_SCHEDULER_SIMPLE_SMP(18); -RTEMS_SCHEDULER_SIMPLE_SMP(19); -RTEMS_SCHEDULER_SIMPLE_SMP(20); -RTEMS_SCHEDULER_SIMPLE_SMP(21); -RTEMS_SCHEDULER_SIMPLE_SMP(22); -RTEMS_SCHEDULER_SIMPLE_SMP(23); -RTEMS_SCHEDULER_SIMPLE_SMP(24); -RTEMS_SCHEDULER_SIMPLE_SMP(25); -RTEMS_SCHEDULER_SIMPLE_SMP(26); -RTEMS_SCHEDULER_SIMPLE_SMP(27); -RTEMS_SCHEDULER_SIMPLE_SMP(28); -RTEMS_SCHEDULER_SIMPLE_SMP(29); -RTEMS_SCHEDULER_SIMPLE_SMP(30); -RTEMS_SCHEDULER_SIMPLE_SMP(31); +RTEMS_SCHEDULER_SIMPLE_SMP( 0 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 1 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 2 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 3 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 4 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 5 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 6 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 7 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 8 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 9 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 10 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 11 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 12 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 13 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 14 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 15 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 16 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 17 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 18 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 19 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 20 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 21 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 22 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 23 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 24 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 25 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 26 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 27 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 28 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 29 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 30 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 31 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(0, 0), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(1, 1), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(2, 2), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(3, 3), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(4, 4), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(5, 5), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(6, 6), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(7, 7), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(8, 8), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(9, 9), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(10, 10), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(11, 11), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(12, 12), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(13, 13), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(14, 14), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(15, 15), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(16, 16), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(17, 17), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(18, 18), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(19, 19), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(20, 20), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(21, 21), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(22, 22), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(23, 23), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(24, 24), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(25, 25), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(26, 26), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(27, 27), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(28, 28), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(29, 29), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(30, 30), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(31, 31) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 0, 0 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 1, 1 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 2, 2 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 3, 3 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 4, 4 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 5, 5 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 6, 6 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 7, 7 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 8, 8 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 9, 9 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 10, 10 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 11, 11 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 12, 12 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 13, 13 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 14, 14 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 15, 15 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 16, 16 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 17, 17 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 18, 18 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 19, 19 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 20, 20 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 21, 21 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 22, 22 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 23, 23 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 24, 24 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 25, 25 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 26, 26 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 27, 27 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 28, 28 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 29, 29 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 30, 30 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 31, 31 ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(17, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(18, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(19, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(20, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(21, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(22, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(23, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(24, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(25, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(26, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(27, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(28, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(29, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(30, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(31, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 17, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 18, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 19, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 20, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 21, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 22, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 23, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 24, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 25, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 26, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 27, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 28, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 29, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 30, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 31, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpopenmp01/init.c b/testsuites/smptests/smpopenmp01/init.c index 813448f736..b161a537d3 100644 --- a/testsuites/smptests/smpopenmp01/init.c +++ b/testsuites/smptests/smpopenmp01/init.c @@ -37,15 +37,18 @@ const char rtems_test_name[] = "SMPOPENMP 1"; #define CPU_COUNT_MAX 32 #endif /* __rtems__ */ -static void work(void) +static void work( void ) { - __asm__ volatile ("" : : : "memory"); + __asm__ volatile( "" + : + : + : "memory" ); } -static void barrier_bench(void) +static void barrier_bench( void ) { #pragma omp parallel - for (int i = 0; i < 10000; ++i) { + for ( int i = 0; i < 10000; ++i ) { work(); #pragma omp barrier work(); @@ -70,58 +73,58 @@ static void barrier_bench(void) } } -static void parallel_bench(void) +static void parallel_bench( void ) { - for (int i = 0; i < 20000; ++i) { + for ( int i = 0; i < 20000; ++i ) { #pragma omp parallel work(); } } -static void static_bench(void) +static void static_bench( void ) { - for (int i = 0; i < 1000; ++i) { - #pragma omp parallel for schedule (static) - for (int j = 0; j < 100; ++j) { + for ( int i = 0; i < 1000; ++i ) { + #pragma omp parallel for schedule( static ) + for ( int j = 0; j < 100; ++j ) { work(); } } } -static void dynamic_bench(void) +static void dynamic_bench( void ) { - #pragma omp parallel for schedule (dynamic) - for (int i = 0; i < 100000; ++i) { + #pragma omp parallel for schedule( dynamic ) + for ( int i = 0; i < 100000; ++i ) { work(); } } -static void guided_bench(void) +static void guided_bench( void ) { - #pragma omp parallel for schedule (guided) - for (int i = 0; i < 100000; ++i) { + #pragma omp parallel for schedule( guided ) + for ( int i = 0; i < 100000; ++i ) { work(); } } -static void runtime_bench(void) +static void runtime_bench( void ) { - #pragma omp parallel for schedule (runtime) - for (int i = 0; i < 100000; ++i) { + #pragma omp parallel for schedule( runtime ) + for ( int i = 0; i < 100000; ++i ) { work(); } } -static void single_bench(void) +static void single_bench( void ) { #pragma omp parallel - for (int i = 0; i < 10000; ++i) { + for ( int i = 0; i < 10000; ++i ) { #pragma omp single work(); } } -static void all(void) +static void all( void ) { barrier_bench(); parallel_bench(); @@ -132,25 +135,25 @@ static void all(void) single_bench(); } -static void do_bench(const char *name, void (*bench)(void), int n) +static void do_bench( const char *name, void ( *bench )( void ), int n ) { double start; double delta; - (*bench)(); + ( *bench )(); start = omp_get_wtime(); - for (int i = 0; i < n; ++i) { - (*bench)(); + for ( int i = 0; i < n; ++i ) { + ( *bench )(); } delta = omp_get_wtime() - start; - printf(",\n \"%s-bench\": %f", name, delta); + printf( ",\n \"%s-bench\": %f", name, delta ); } static const char *test_sep = ""; -static void microbench(int num_threads, int n) +static void microbench( int num_threads, int n ) { - omp_set_num_threads(num_threads); + omp_set_num_threads( num_threads ); printf( "%s{\n" " \"num-threads\": %i,\n" @@ -160,30 +163,30 @@ static void microbench(int num_threads, int n) n ); test_sep = ", "; - do_bench("barrier", barrier_bench, n); - do_bench("parallel", parallel_bench, n); - do_bench("static", static_bench, n); - do_bench("dynamic", dynamic_bench, n); - do_bench("guided", guided_bench, n); - do_bench("runtime", runtime_bench, n); - do_bench("single", single_bench, n); - printf("\n }"); + do_bench( "barrier", barrier_bench, n ); + do_bench( "parallel", parallel_bench, n ); + do_bench( "static", static_bench, n ); + do_bench( "dynamic", dynamic_bench, n ); + do_bench( "guided", guided_bench, n ); + do_bench( "runtime", runtime_bench, n ); + do_bench( "single", single_bench, n ); + printf( "\n }" ); } -static int estimate_3s_runtime_with_one_proc(void) +static int estimate_3s_runtime_with_one_proc( void ) { double start; double delta; - int n; + int n; - omp_set_num_threads(1); + omp_set_num_threads( 1 ); all(); start = omp_get_wtime(); all(); delta = omp_get_wtime() - start; - if (delta > 0.0 && delta <= 1.0) { - n = (int) (3.0 / delta); + if ( delta > 0.0 && delta <= 1.0 ) { + n = (int) ( 3.0 / delta ); } else { n = 1; } @@ -191,138 +194,138 @@ static int estimate_3s_runtime_with_one_proc(void) return n; } -static void test(void) +static void test( void ) { int num_procs; int n; - printf("*** BEGIN OF JSON DATA ***\n[\n "); + printf( "*** BEGIN OF JSON DATA ***\n[\n " ); n = estimate_3s_runtime_with_one_proc(); num_procs = omp_get_num_procs(); - omp_set_num_threads(num_procs); + omp_set_num_threads( num_procs ); - for (int i = 1; i <= num_procs; ++i) { - microbench(i, n); + for ( int i = 1; i <= num_procs; ++i ) { + microbench( i, n ); } - printf("\n]\n*** END OF JSON DATA ***\n"); + printf( "\n]\n*** END OF JSON DATA ***\n" ); } #ifdef __rtems__ -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; rtems_status_code sc; - cpu_set_t cpu_set; + cpu_set_t cpu_set; - rtems_print_printer_fprintf_putc(&rtems_test_printer); + rtems_print_printer_fprintf_putc( &rtems_test_printer ); TEST_BEGIN(); - CPU_ZERO(&cpu_set); - CPU_SET(0, &cpu_set); + CPU_ZERO( &cpu_set ); + CPU_SET( 0, &cpu_set ); - sc = rtems_task_set_affinity(RTEMS_SELF, sizeof(cpu_set), &cpu_set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( RTEMS_SELF, sizeof( cpu_set ), &cpu_set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } typedef struct { pthread_mutex_t mtx; - pthread_cond_t cnd; - bool cpus_used[CPU_COUNT_MAX]; + pthread_cond_t cnd; + bool cpus_used[ CPU_COUNT_MAX ]; } test_context; static test_context test_instance; -static uint32_t find_free_cpu(test_context *ctx) +static uint32_t find_free_cpu( test_context *ctx ) { uint32_t i; uint32_t n; n = rtems_scheduler_get_processor_maximum(); - pthread_mutex_lock(&ctx->mtx); + pthread_mutex_lock( &ctx->mtx ); do { - for (i = 1; i < n; ++i) { - if (!ctx->cpus_used[i]) { - ctx->cpus_used[i] = true; + for ( i = 1; i < n; ++i ) { + if ( !ctx->cpus_used[ i ] ) { + ctx->cpus_used[ i ] = true; break; } } - if (i == n) { - pthread_cond_wait(&ctx->cnd, &ctx->mtx); + if ( i == n ) { + pthread_cond_wait( &ctx->cnd, &ctx->mtx ); } - } while (i == n); + } while ( i == n ); - pthread_mutex_unlock(&ctx->mtx); + pthread_mutex_unlock( &ctx->mtx ); return i; } -static void begin_extension(Thread_Control *th) +static void begin_extension( Thread_Control *th ) { rtems_id th_id; th_id = th->Object.id; - if (rtems_object_id_get_api(th_id) == OBJECTS_POSIX_API) { - rtems_status_code sc; - rtems_id sched_id; - uint32_t cpu_index; - cpu_set_t cpu_set; + if ( rtems_object_id_get_api( th_id ) == OBJECTS_POSIX_API ) { + rtems_status_code sc; + rtems_id sched_id; + uint32_t cpu_index; + cpu_set_t cpu_set; rtems_task_priority prio; - cpu_index = find_free_cpu(&test_instance); + cpu_index = find_free_cpu( &test_instance ); - sc = rtems_scheduler_ident_by_processor(cpu_index, &sched_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident_by_processor( cpu_index, &sched_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_priority(th_id, RTEMS_CURRENT_PRIORITY, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( th_id, RTEMS_CURRENT_PRIORITY, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(th_id, sched_id, prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( th_id, sched_id, prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - CPU_ZERO(&cpu_set); - CPU_SET((int) cpu_index, &cpu_set); + CPU_ZERO( &cpu_set ); + CPU_SET( (int) cpu_index, &cpu_set ); - sc = rtems_task_set_affinity(th_id, sizeof(cpu_set), &cpu_set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( th_id, sizeof( cpu_set ), &cpu_set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void terminate_extension(Thread_Control *th) +static void terminate_extension( Thread_Control *th ) { rtems_id th_id; th_id = th->Object.id; - if (rtems_object_id_get_api(th_id) == OBJECTS_POSIX_API) { + if ( rtems_object_id_get_api( th_id ) == OBJECTS_POSIX_API ) { rtems_status_code sc; - cpu_set_t cpu_set; - uint32_t cpu_index; - test_context *ctx; + cpu_set_t cpu_set; + uint32_t cpu_index; + test_context *ctx; - sc = rtems_task_get_affinity(th_id, sizeof(cpu_set), &cpu_set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_get_affinity( th_id, sizeof( cpu_set ), &cpu_set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - cpu_index = CPU_FFS(&cpu_set) - 1; + cpu_index = CPU_FFS( &cpu_set ) - 1; ctx = &test_instance; - pthread_mutex_lock(&ctx->mtx); - rtems_test_assert(ctx->cpus_used[cpu_index]); - ctx->cpus_used[cpu_index] = false; - pthread_cond_broadcast(&ctx->cnd); - pthread_mutex_unlock(&ctx->mtx); + pthread_mutex_lock( &ctx->mtx ); + rtems_test_assert( ctx->cpus_used[ cpu_index ] ); + ctx->cpus_used[ cpu_index ] = false; + pthread_cond_broadcast( &ctx->cnd ); + pthread_mutex_unlock( &ctx->mtx ); } } @@ -334,12 +337,10 @@ static void terminate_extension(Thread_Control *th) #define CONFIGURE_UNLIMITED_OBJECTS #define CONFIGURE_UNIFIED_WORK_AREAS -#define CONFIGURE_INITIAL_EXTENSIONS \ - { \ - .thread_begin = begin_extension, \ - .thread_terminate = terminate_extension \ - }, \ - RTEMS_TEST_INITIAL_EXTENSION +#define CONFIGURE_INITIAL_EXTENSIONS \ + { .thread_begin = begin_extension, \ + .thread_terminate = terminate_extension }, \ + RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_FLOATING_POINT @@ -351,7 +352,7 @@ static void terminate_extension(Thread_Control *th) #else /* __rtems__ */ -int main(void) +int main( void ) { test(); return 0; diff --git a/testsuites/smptests/smppsxaffinity01/init.c b/testsuites/smptests/smppsxaffinity01/init.c index 89984eb8c5..74185272ab 100644 --- a/testsuites/smptests/smppsxaffinity01/init.c +++ b/testsuites/smptests/smppsxaffinity01/init.c @@ -30,7 +30,7 @@ #include "config.h" #endif -#define _GNU_SOURCE +#define _GNU_SOURCE #include #include @@ -41,19 +41,19 @@ const char rtems_test_name[] = "SMPPSXAFFINITY 1"; #define CPU_COUNT 4 -pthread_t Init_id; +pthread_t Init_id; /* forward declarations to avoid warnings */ -void *POSIX_Init(void *argument); -void Validate_attrgetaffinity_errors(void); -void Validate_attrsetaffinity_errors(void); -void Validate_attr(void); +void *POSIX_Init( void *argument ); +void Validate_attrgetaffinity_errors( void ); +void Validate_attrsetaffinity_errors( void ); +void Validate_attr( void ); -void Validate_attrgetaffinity_errors(void) +void Validate_attrgetaffinity_errors( void ) { - int sc; - cpu_set_t cpuset; - pthread_attr_t attr; + int sc; + cpu_set_t cpuset; + pthread_attr_t attr; sc = pthread_attr_init( &attr ); rtems_test_assert( sc == 0 ); @@ -70,7 +70,7 @@ void Validate_attrgetaffinity_errors(void) /* Verify pthread_attr_getaffinity_np validates cpusetsize */ puts( "Init - pthread_attr_getaffinity_np - Invalid cpusetsize - EINVAL" ); - sc = pthread_attr_getaffinity_np( &attr, sizeof( cpuset ) * 2 , &cpuset ); + sc = pthread_attr_getaffinity_np( &attr, sizeof( cpuset ) * 2, &cpuset ); rtems_test_assert( sc == EINVAL ); sc = pthread_attr_destroy( &attr ); @@ -81,11 +81,11 @@ void Validate_attrgetaffinity_errors(void) rtems_test_assert( sc == EINVAL ); } -void Validate_attrsetaffinity_errors(void) +void Validate_attrsetaffinity_errors( void ) { - int sc; - cpu_set_t cpuset; - pthread_attr_t attr; + int sc; + cpu_set_t cpuset; + pthread_attr_t attr; sc = pthread_attr_init( &attr ); rtems_test_assert( sc == 0 ); @@ -102,26 +102,26 @@ void Validate_attrsetaffinity_errors(void) /* Verify pthread_attr_setaffinity_np validates cpusetsize */ puts( "Init - pthread_attr_setaffinity_np - Invalid cpusetsize - EINVAL" ); - sc = pthread_attr_setaffinity_np( &attr, sizeof( cpuset ) * 2 , &cpuset ); + sc = pthread_attr_setaffinity_np( &attr, sizeof( cpuset ) * 2, &cpuset ); rtems_test_assert( sc == EINVAL ); sc = pthread_attr_destroy( &attr ); rtems_test_assert( sc == 0 ); puts( "Init - pthread_attr_setaffinity_np - Not initialized attr - EINVAL" ); - sc = pthread_attr_setaffinity_np( &attr, sizeof( cpuset ), &cpuset ); + sc = pthread_attr_setaffinity_np( &attr, sizeof( cpuset ), &cpuset ); rtems_test_assert( sc == EINVAL ); } -void Validate_attr(void ) +void Validate_attr( void ) { - int sc; - pthread_attr_t attr; - uint32_t cpus; - cpu_set_t cpuset1; - cpu_set_t cpuset2; - int i; - int priority; + int sc; + pthread_attr_t attr; + uint32_t cpus; + cpu_set_t cpuset1; + cpu_set_t cpuset2; + int i; + int priority; sc = pthread_getattr_np( Init_id, &attr ); rtems_test_assert( sc == 0 ); @@ -129,7 +129,6 @@ void Validate_attr(void ) priority = sched_get_priority_min( SCHED_FIFO ); rtems_test_assert( priority != -1 ); - cpus = rtems_scheduler_get_processor_maximum(); puts( "Init - Validate pthread_attr_setaffinity_np and " @@ -137,23 +136,21 @@ void Validate_attr(void ) ); /* Set each cpu seperately in the affinity set */ - for ( i=0; i #include @@ -41,95 +41,94 @@ const char rtems_test_name[] = "SMPPSXAFFINITY 2"; -pthread_t Init_id; -pthread_t Med_id[NUM_CPUS-1]; -pthread_t Low_id[NUM_CPUS]; +pthread_t Init_id; +pthread_t Med_id[ NUM_CPUS - 1 ]; +pthread_t Low_id[ NUM_CPUS ]; /* forward declarations to avoid warnings */ -void *POSIX_Init(void *argument); -void Validate_setaffinity_errors(void); -void Validate_getaffinity_errors(void); -void Validate_affinity(void); -void *Thread_1(void *unused); +void *POSIX_Init( void *argument ); +void Validate_setaffinity_errors( void ); +void Validate_getaffinity_errors( void ); +void Validate_affinity( void ); +void *Thread_1( void *unused ); -void *Thread_1(void *unused) +void *Thread_1( void *unused ) { (void) unused; - while(1); + while ( 1 ); } -void Validate_setaffinity_errors(void) +void Validate_setaffinity_errors( void ) { - int sc; - cpu_set_t cpuset; + int sc; + cpu_set_t cpuset; /* Verify pthread_setaffinity_np checks that more cpu's don't hurt. */ - CPU_FILL(&cpuset); + CPU_FILL( &cpuset ); puts( "Init - pthread_setaffinity_np - Lots of cpus - SUCCESS" ); - sc = pthread_setaffinity_np( Init_id, sizeof(cpu_set_t), &cpuset ); + sc = pthread_setaffinity_np( Init_id, sizeof( cpu_set_t ), &cpuset ); rtems_test_assert( sc == 0 ); /* Verify pthread_setaffinity_np checks that at least one cpu is set */ - CPU_ZERO(&cpuset); + CPU_ZERO( &cpuset ); puts( "Init - pthread_setaffinity_np - no cpu - EINVAL" ); - sc = pthread_setaffinity_np( Init_id, sizeof(cpu_set_t), &cpuset ); + sc = pthread_setaffinity_np( Init_id, sizeof( cpu_set_t ), &cpuset ); rtems_test_assert( sc == EINVAL ); /* Verify pthread_setaffinity_np checks that at thread id is valid */ - CPU_ZERO(&cpuset); - CPU_SET(0, &cpuset); + CPU_ZERO( &cpuset ); + CPU_SET( 0, &cpuset ); puts( "Init - pthread_setaffinity_np - Invalid thread - ESRCH" ); - sc = pthread_setaffinity_np( 999, sizeof(cpu_set_t), &cpuset ); + sc = pthread_setaffinity_np( 999, sizeof( cpu_set_t ), &cpuset ); rtems_test_assert( sc == ESRCH ); /* Verify pthread_setaffinity_np validates cpusetsize */ puts( "Init - pthread_setaffinity_np - Invalid cpusetsize - EINVAL" ); - sc = pthread_setaffinity_np( Init_id, 1, &cpuset ); + sc = pthread_setaffinity_np( Init_id, 1, &cpuset ); rtems_test_assert( sc == EINVAL ); /* Verify pthread_setaffinity_np validates cpuset */ puts( "Init - pthread_setaffinity_np - Invalid cpuset - EFAULT" ); - sc = pthread_setaffinity_np( Init_id, sizeof(cpu_set_t), NULL ); + sc = pthread_setaffinity_np( Init_id, sizeof( cpu_set_t ), NULL ); rtems_test_assert( sc == EFAULT ); } -void Validate_getaffinity_errors(void) +void Validate_getaffinity_errors( void ) { - int sc; - cpu_set_t cpuset; + int sc; + cpu_set_t cpuset; /* Verify pthread_getaffinity_np checks that at thread id is valid */ - CPU_ZERO(&cpuset); - CPU_SET(0, &cpuset); + CPU_ZERO( &cpuset ); + CPU_SET( 0, &cpuset ); puts( "Init - pthread_getaffinity_np - Invalid thread - ESRCH" ); - sc = pthread_getaffinity_np( 999, sizeof(cpu_set_t), &cpuset ); + sc = pthread_getaffinity_np( 999, sizeof( cpu_set_t ), &cpuset ); rtems_test_assert( sc == ESRCH ); /* Verify pthread_getaffinity_np validates cpusetsize */ puts( "Init - pthread_getaffinity_np - Invalid cpusetsize - EINVAL" ); - sc = pthread_getaffinity_np( Init_id, 1, &cpuset ); + sc = pthread_getaffinity_np( Init_id, 1, &cpuset ); rtems_test_assert( sc == EINVAL ); /* Verify pthread_getaffinity_np validates cpuset */ - puts("Init - pthread_getaffinity_np - Invalid cpuset - EFAULT"); - sc = pthread_getaffinity_np( Init_id, sizeof(cpu_set_t), NULL ); + puts( "Init - pthread_getaffinity_np - Invalid cpuset - EFAULT" ); + sc = pthread_getaffinity_np( Init_id, sizeof( cpu_set_t ), NULL ); rtems_test_assert( sc == EFAULT ); } -void Validate_affinity(void ) +void Validate_affinity( void ) { - pthread_attr_t attr; - cpu_set_t cpuset0; - cpu_set_t cpuset1; - cpu_set_t cpuset2; - int i; - int sc; - int cpu_count; - struct sched_param param; + pthread_attr_t attr; + cpu_set_t cpuset0; + cpu_set_t cpuset1; + cpu_set_t cpuset2; + int i; + int sc; + int cpu_count; + struct sched_param param; - - puts( "Init - Set Init priority to high"); + puts( "Init - Set Init priority to high" ); sc = pthread_getattr_np( Init_id, &attr ); rtems_test_assert( sc == 0 ); @@ -142,86 +141,88 @@ void Validate_affinity(void ) sc = pthread_setschedparam( Init_id, SCHED_FIFO, ¶m ); rtems_test_assert( !sc ); - sc = pthread_getaffinity_np( Init_id, sizeof(cpu_set_t), &cpuset0 ); + sc = pthread_getaffinity_np( Init_id, sizeof( cpu_set_t ), &cpuset0 ); rtems_test_assert( !sc ); /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); /* Fill the remaining cpus with med priority tasks */ - puts( "Init - Create Medium priority tasks"); - for (i=0; i<(cpu_count-1); i++){ - sc = pthread_create( &Med_id[i], &attr, Thread_1, NULL ); + puts( "Init - Create Medium priority tasks" ); + for ( i = 0; i < ( cpu_count - 1 ); i++ ) { + sc = pthread_create( &Med_id[ i ], &attr, Thread_1, NULL ); rtems_test_assert( !sc ); } - puts( "Init - Verify Medium priority tasks"); - for (i=0; i<(cpu_count-1); i++){ - sc = pthread_getaffinity_np( Med_id[i], sizeof(cpu_set_t), &cpuset2 ); + puts( "Init - Verify Medium priority tasks" ); + for ( i = 0; i < ( cpu_count - 1 ); i++ ) { + sc = pthread_getaffinity_np( Med_id[ i ], sizeof( cpu_set_t ), &cpuset2 ); rtems_test_assert( !sc ); - rtems_test_assert( CPU_EQUAL(&cpuset0, &cpuset2) ); + rtems_test_assert( CPU_EQUAL( &cpuset0, &cpuset2 ) ); } /* * Create low priority thread for each remaining cpu with the affinity * set to only run on one cpu. */ - puts( "Init - Create Low priority tasks"); - for (i=0; imtx_b, &ctx->mtx_attr); - rtems_test_assert(eno == 0); + eno = pthread_mutex_init( &ctx->mtx_b, &ctx->mtx_attr ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutex_getprioceiling(&ctx->mtx_b, &prio_ceiling); - rtems_test_assert(eno == 0); - rtems_test_assert(prio_ceiling == 254); + eno = pthread_mutex_getprioceiling( &ctx->mtx_b, &prio_ceiling ); + rtems_test_assert( eno == 0 ); + rtems_test_assert( prio_ceiling == 254 ); - eno = pthread_mutex_lock(&ctx->mtx_b); - rtems_test_assert(eno == 0); + eno = pthread_mutex_lock( &ctx->mtx_b ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutex_unlock(&ctx->mtx_b); - rtems_test_assert(eno == 0); + eno = pthread_mutex_unlock( &ctx->mtx_b ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutex_destroy(&ctx->mtx_b); - rtems_test_assert(eno == 0); + eno = pthread_mutex_destroy( &ctx->mtx_b ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutex_getprioceiling(&ctx->mtx_a, &prio_ceiling); - rtems_test_assert(eno == 0); - rtems_test_assert(prio_ceiling == 126); + eno = pthread_mutex_getprioceiling( &ctx->mtx_a, &prio_ceiling ); + rtems_test_assert( eno == 0 ); + rtems_test_assert( prio_ceiling == 126 ); - eno = pthread_mutex_lock(&ctx->mtx_a); - rtems_test_assert(eno == EINVAL); + eno = pthread_mutex_lock( &ctx->mtx_a ); + rtems_test_assert( eno == EINVAL ); return ctx; } -static void test(test_context *ctx) +static void test( test_context *ctx ) { uint32_t cpu_count; - int prio_ceiling; - int eno; + int prio_ceiling; + int eno; cpu_count = rtems_scheduler_get_processor_maximum(); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - eno = pthread_mutexattr_init(&ctx->mtx_attr); - rtems_test_assert(eno == 0); + eno = pthread_mutexattr_init( &ctx->mtx_attr ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutexattr_setprotocol(&ctx->mtx_attr, PTHREAD_PRIO_PROTECT); - rtems_test_assert(eno == 0); + eno = pthread_mutexattr_setprotocol( &ctx->mtx_attr, PTHREAD_PRIO_PROTECT ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutex_init(&ctx->mtx_a, &ctx->mtx_attr); - rtems_test_assert(eno == 0); + eno = pthread_mutex_init( &ctx->mtx_a, &ctx->mtx_attr ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutex_getprioceiling(&ctx->mtx_a, &prio_ceiling); - rtems_test_assert(eno == 0); - rtems_test_assert(prio_ceiling == 126); + eno = pthread_mutex_getprioceiling( &ctx->mtx_a, &prio_ceiling ); + rtems_test_assert( eno == 0 ); + rtems_test_assert( prio_ceiling == 126 ); - eno = pthread_mutex_lock(&ctx->mtx_a); - rtems_test_assert(eno == 0); + eno = pthread_mutex_lock( &ctx->mtx_a ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutex_unlock(&ctx->mtx_a); - rtems_test_assert(eno == 0); + eno = pthread_mutex_unlock( &ctx->mtx_a ); + rtems_test_assert( eno == 0 ); - if (cpu_count > 1) { - rtems_id scheduler_a_id; - rtems_id scheduler_b_id; - rtems_status_code sc; + if ( cpu_count > 1 ) { + rtems_id scheduler_a_id; + rtems_id scheduler_b_id; + rtems_status_code sc; rtems_task_priority prio; - void *exit_code; + void *exit_code; - sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_A, &scheduler_a_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_B, &scheduler_b_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_priority(pthread_self(), RTEMS_CURRENT_PRIORITY, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( + pthread_self(), + RTEMS_CURRENT_PRIORITY, + &prio + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(pthread_self(), scheduler_b_id, prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( pthread_self(), scheduler_b_id, prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - eno = pthread_create(&ctx->thread_b, NULL, thread_b, ctx); - rtems_test_assert(eno == 0); + eno = pthread_create( &ctx->thread_b, NULL, thread_b, ctx ); + rtems_test_assert( eno == 0 ); exit_code = NULL; - eno = pthread_join(ctx->thread_b, &exit_code); - rtems_test_assert(eno == 0); - rtems_test_assert(exit_code == ctx); + eno = pthread_join( ctx->thread_b, &exit_code ); + rtems_test_assert( eno == 0 ); + rtems_test_assert( exit_code == ctx ); - sc = rtems_task_set_scheduler(pthread_self(), scheduler_a_id, prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( pthread_self(), scheduler_a_id, prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - eno = pthread_mutex_destroy(&ctx->mtx_a); - rtems_test_assert(eno == 0); + eno = pthread_mutex_destroy( &ctx->mtx_a ); + rtems_test_assert( eno == 0 ); - eno = pthread_mutexattr_destroy(&ctx->mtx_attr); - rtems_test_assert(eno == 0); + eno = pthread_mutexattr_destroy( &ctx->mtx_attr ); + rtems_test_assert( eno == 0 ); } -static void *POSIX_Init(void *arg) +static void *POSIX_Init( void *arg ) { (void) arg; @@ -163,14 +167,14 @@ static void *POSIX_Init(void *arg) TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); - test(&test_instance); + test( &test_instance ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -184,17 +188,17 @@ static void *POSIX_Init(void *arg) #include -RTEMS_SCHEDULER_PRIORITY_SMP(a, 128); +RTEMS_SCHEDULER_PRIORITY_SMP( a, 128 ); -RTEMS_SCHEDULER_PRIORITY_SMP(b, 256); +RTEMS_SCHEDULER_PRIORITY_SMP( b, 256 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_PRIORITY_SMP(a, SCHED_A), \ - RTEMS_SCHEDULER_TABLE_PRIORITY_SMP(b, SCHED_B) \ +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_PRIORITY_SMP( a, SCHED_A ), \ + RTEMS_SCHEDULER_TABLE_PRIORITY_SMP( b, SCHED_B ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smppsxsignal01/init.c b/testsuites/smptests/smppsxsignal01/init.c index 5bab2f9100..24d7d7162c 100644 --- a/testsuites/smptests/smppsxsignal01/init.c +++ b/testsuites/smptests/smppsxsignal01/init.c @@ -38,155 +38,149 @@ const char rtems_test_name[] = "SMPPSXSIGNAL 1"; #define TEST_SIGNAL SIGUSR1 -typedef enum { - SIG_READY, - SIG_SENT, - SIG_PROCESSED -} test_state; +typedef enum { SIG_READY, SIG_SENT, SIG_PROCESSED } test_state; typedef struct { volatile test_state state; - pthread_t consumer; - pthread_t producer; - uint32_t consumer_processor; - uint32_t producer_processor; + pthread_t consumer; + pthread_t producer; + uint32_t consumer_processor; + uint32_t producer_processor; } test_context; -static void change_state(test_context *ctx, test_state new_state) +static void change_state( test_context *ctx, test_state new_state ) { ctx->state = new_state; } -static void wait_for_state(const test_context *ctx, test_state desired_state) +static void wait_for_state( const test_context *ctx, test_state desired_state ) { while ( ctx->state != desired_state ) { /* Wait */ } } -static test_context ctx_instance = { - .state = SIG_READY -}; +static test_context ctx_instance = { .state = SIG_READY }; -static void signal_handler(int signum) +static void signal_handler( int signum ) { (void) signum; test_context *ctx = &ctx_instance; - switch (ctx->state) { + switch ( ctx->state ) { case SIG_SENT: - change_state(ctx, SIG_PROCESSED); + change_state( ctx, SIG_PROCESSED ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); } } -static void signal_send(test_context *ctx, test_state new_state) +static void signal_send( test_context *ctx, test_state new_state ) { int eno; - eno = pthread_kill(ctx->consumer, TEST_SIGNAL); - rtems_test_assert(eno == 0); + eno = pthread_kill( ctx->consumer, TEST_SIGNAL ); + rtems_test_assert( eno == 0 ); - change_state(ctx, new_state); + change_state( ctx, new_state ); } -static void check_consumer_processor(const test_context *ctx) +static void check_consumer_processor( const test_context *ctx ) { rtems_test_assert( ctx->consumer_processor == rtems_scheduler_get_processor() ); } -static void check_producer_processor(const test_context *ctx) +static void check_producer_processor( const test_context *ctx ) { rtems_test_assert( ctx->producer_processor == rtems_scheduler_get_processor() ); } -static void *producer(void *arg) +static void *producer( void *arg ) { test_context *ctx = arg; ctx->producer_processor = rtems_scheduler_get_processor(); - rtems_test_assert(ctx->consumer_processor != ctx->producer_processor); + rtems_test_assert( ctx->consumer_processor != ctx->producer_processor ); - wait_for_state(ctx, SIG_READY); - signal_send(ctx, SIG_SENT); + wait_for_state( ctx, SIG_READY ); + signal_send( ctx, SIG_SENT ); - check_producer_processor(ctx); + check_producer_processor( ctx ); return ctx; } -static void test(void) +static void test( void ) { - test_context *ctx = &ctx_instance; + test_context *ctx = &ctx_instance; struct sigaction new_action; - sigset_t test_signal_set; - int rv; - pthread_attr_t attr; - int eno; - void *producer_status; + sigset_t test_signal_set; + int rv; + pthread_attr_t attr; + int eno; + void *producer_status; ctx->consumer = pthread_self(); ctx->consumer_processor = rtems_scheduler_get_processor(); - memset(&new_action, 0, sizeof(new_action)); + memset( &new_action, 0, sizeof( new_action ) ); new_action.sa_handler = signal_handler; - rv = sigaction(TEST_SIGNAL, &new_action, NULL); - rtems_test_assert(rv == 0); + rv = sigaction( TEST_SIGNAL, &new_action, NULL ); + rtems_test_assert( rv == 0 ); - rv = sigemptyset(&test_signal_set); - rtems_test_assert(rv == 0); + rv = sigemptyset( &test_signal_set ); + rtems_test_assert( rv == 0 ); - rv = sigaddset(&test_signal_set, TEST_SIGNAL); - rtems_test_assert(rv == 0); + rv = sigaddset( &test_signal_set, TEST_SIGNAL ); + rtems_test_assert( rv == 0 ); - eno = pthread_sigmask(SIG_UNBLOCK, &test_signal_set, NULL); - rtems_test_assert(eno == 0); + eno = pthread_sigmask( SIG_UNBLOCK, &test_signal_set, NULL ); + rtems_test_assert( eno == 0 ); - eno = pthread_attr_init(&attr); - rtems_test_assert(eno == 0); + eno = pthread_attr_init( &attr ); + rtems_test_assert( eno == 0 ); - eno = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); - rtems_test_assert(eno == 0); + eno = pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE ); + rtems_test_assert( eno == 0 ); - eno = pthread_create(&ctx->producer, &attr, producer, ctx); - rtems_test_assert(eno == 0); + eno = pthread_create( &ctx->producer, &attr, producer, ctx ); + rtems_test_assert( eno == 0 ); - eno = pthread_attr_destroy(&attr); - rtems_test_assert(eno == 0); + eno = pthread_attr_destroy( &attr ); + rtems_test_assert( eno == 0 ); - check_consumer_processor(ctx); + check_consumer_processor( ctx ); - wait_for_state(ctx, SIG_PROCESSED); + wait_for_state( ctx, SIG_PROCESSED ); - check_consumer_processor(ctx); + check_consumer_processor( ctx ); producer_status = NULL; - pthread_join(ctx->producer, &producer_status); - rtems_test_assert(eno == 0); - rtems_test_assert(producer_status == ctx); + pthread_join( ctx->producer, &producer_status ); + rtems_test_assert( eno == 0 ); + rtems_test_assert( producer_status == ctx ); } -static void *POSIX_Init(void *arg) +static void *POSIX_Init( void *arg ) { (void) arg; TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() >= 2) { + if ( rtems_scheduler_get_processor_maximum() >= 2 ) { test(); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER diff --git a/testsuites/smptests/smpschedaffinity01/init.c b/testsuites/smptests/smpschedaffinity01/init.c index 3680385166..12a7457f63 100644 --- a/testsuites/smptests/smpschedaffinity01/init.c +++ b/testsuites/smptests/smpschedaffinity01/init.c @@ -53,51 +53,51 @@ const char rtems_test_name[] = "SMPSCHEDAFFINITY 1"; #define TASK_COUNT 5 struct task_data_t { - rtems_id id; - int expected_cpu; - cpu_set_t cpuset; - bool ran; - int actual_cpu; + rtems_id id; + int expected_cpu; + cpu_set_t cpuset; + bool ran; + int actual_cpu; }; -static struct task_data_t task_data[NUM_CPUS] = { - {0x0, 2, {{0x4}}, false, -1}, - {0x0, 0, {{0x1}}, false, -1}, - {0x0, 3, {{0x8}}, false, -1}, - {0x0, 1, {{0x2}}, false, -1} +static struct task_data_t task_data[ NUM_CPUS ] = { + { 0x0, 2, { { 0x4 } }, false, -1 }, + { 0x0, 0, { { 0x1 } }, false, -1 }, + { 0x0, 3, { { 0x8 } }, false, -1 }, + { 0x0, 1, { { 0x2 } }, false, -1 } }; - + /* * Spin loop to allow tasks to delay without yeilding the * processor. */ -static void test_delay(int ticks) -{ +static void test_delay( int ticks ) +{ rtems_interval start, stop; start = rtems_clock_get_ticks_since_boot(); do { stop = rtems_clock_get_ticks_since_boot(); - } while ( (stop - start) < ticks ); + } while ( ( stop - start ) < ticks ); } -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; - uint32_t cpu; + uint32_t cpu; cpu_set_t cpuset; cpu = rtems_scheduler_get_processor(); - rtems_task_get_affinity( rtems_task_self(), sizeof(cpuset), &cpuset ); + rtems_task_get_affinity( rtems_task_self(), sizeof( cpuset ), &cpuset ); - task_data[arg].ran = true; - task_data[arg].actual_cpu = cpu; + task_data[ arg ].ran = true; + task_data[ arg ].actual_cpu = cpu; rtems_task_exit(); } -static void test(void) +static void test( void ) { rtems_status_code sc; rtems_task_argument i; @@ -106,60 +106,62 @@ static void test(void) /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); - - size = sizeof(cpu_set_t); + + size = sizeof( cpu_set_t ); /* Create and start tasks on each cpu with the appropriate affinity. */ - for (i = 0; i < NUM_CPUS; i++) { - - /* Skip if this cpu doesn't exist, don't create task */ - if ( task_data[i].expected_cpu >= cpu_count ) { - printf( - "Skipping TA0%" PRIdrtems_task_argument - " because on a core we do not have\n", - i - ); - continue; - } - - sc = rtems_task_create( - rtems_build_name('T', 'A', '0', '0'+i), - 4, - RTEMS_MINIMUM_STACK_SIZE, - RTEMS_DEFAULT_MODES, - RTEMS_DEFAULT_ATTRIBUTES, - &task_data[ i ].id - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - + for ( i = 0; i < NUM_CPUS; i++ ) { + /* Skip if this cpu doesn't exist, don't create task */ + if ( task_data[ i ].expected_cpu >= cpu_count ) { printf( - "Set TA%" PRIdrtems_task_argument " affinity to cpu %d\n", - i, - task_data[i].expected_cpu + "Skipping TA0%" PRIdrtems_task_argument + " because on a core we do not have\n", + i ); - sc = rtems_task_set_affinity( task_data[ i ].id, size, &task_data[i].cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + continue; + } - printf( - "Start TA%" PRIdrtems_task_argument " on cpu %d\n", - i, - task_data[i].expected_cpu - ); - sc = rtems_task_start( task_data[ i ].id, task, i ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_create( + rtems_build_name( 'T', 'A', '0', '0' + i ), + 4, + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_MODES, + RTEMS_DEFAULT_ATTRIBUTES, + &task_data[ i ].id + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + + printf( + "Set TA%" PRIdrtems_task_argument " affinity to cpu %d\n", + i, + task_data[ i ].expected_cpu + ); + sc = rtems_task_set_affinity( + task_data[ i ].id, + size, + &task_data[ i ].cpuset + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + + printf( + "Start TA%" PRIdrtems_task_argument " on cpu %d\n", + i, + task_data[ i ].expected_cpu + ); + sc = rtems_task_start( task_data[ i ].id, task, i ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } /* spin for 100 ticks */ - test_delay(100); - - printf("Verify Tasks Ran\n"); - for (i = 0; i < NUM_CPUS; i++) { + test_delay( 100 ); + printf( "Verify Tasks Ran\n" ); + for ( i = 0; i < NUM_CPUS; i++ ) { /* Skip if this cpu doesn't exist, task doesn't exist */ - if ( task_data[i].expected_cpu >= cpu_count ) { + if ( task_data[ i ].expected_cpu >= cpu_count ) { printf( "Skipping TA0%" PRIdrtems_task_argument - " because on a core we do not have\n", + " because on a core we do not have\n", i ); continue; @@ -169,18 +171,20 @@ static void test(void) printf( "TA0%" PRIdrtems_task_argument ": ran=%d expected=%d actual=%d\n", i, - task_data[i].ran, - task_data[i].expected_cpu, - task_data[i].actual_cpu + task_data[ i ].ran, + task_data[ i ].expected_cpu, + task_data[ i ].actual_cpu ); /* Abort test if values are not as expected */ - rtems_test_assert( task_data[i].ran == true ); - rtems_test_assert( task_data[i].expected_cpu == task_data[i].actual_cpu ); + rtems_test_assert( task_data[ i ].ran == true ); + rtems_test_assert( + task_data[ i ].expected_cpu == task_data[ i ].actual_cpu + ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -189,7 +193,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -199,11 +203,11 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS NUM_CPUS -#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT +#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION - #define CONFIGURE_INIT_TASK_PRIORITY 8 + #define CONFIGURE_INIT_TASK_PRIORITY 8 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE #define CONFIGURE_INIT diff --git a/testsuites/smptests/smpschedaffinity02/init.c b/testsuites/smptests/smpschedaffinity02/init.c index 471a92ba61..989ec689af 100644 --- a/testsuites/smptests/smpschedaffinity02/init.c +++ b/testsuites/smptests/smpschedaffinity02/init.c @@ -46,61 +46,63 @@ const char rtems_test_name[] = "SMPSCHEDAFFINITY 2"; -#define NUM_CPUS 2 +#define NUM_CPUS 2 struct task_data_t { - rtems_id id; - int expected_cpu; - cpu_set_t cpuset; - bool ran; - int actual_cpu; + rtems_id id; + int expected_cpu; + cpu_set_t cpuset; + bool ran; + int actual_cpu; }; -struct task_data_t task_data = { - 0x0, 0, {{0x3}}, false, -1 -}; +struct task_data_t task_data = { 0x0, 0, { { 0x3 } }, false, -1 }; -rtems_id task_sem; +rtems_id task_sem; -static void task(rtems_task_argument arg); +static void task( rtems_task_argument arg ); static void task_verify( bool ran, bool change_affinity, int cpu ); -static void init_verify( int expect ); +static void init_verify( int expect ); -static void test_delay(int ticks) -{ +static void test_delay( int ticks ) +{ rtems_interval start, stop; start = rtems_clock_get_ticks_since_boot(); do { stop = rtems_clock_get_ticks_since_boot(); - } while ( (stop - start) < ticks ); + } while ( ( stop - start ) < ticks ); } static void task_verify( bool ran, bool change_affinity, int cpu ) { - rtems_status_code sc; - size_t size = sizeof(cpu_set_t); + rtems_status_code sc; + size_t size = sizeof( cpu_set_t ); /* Obtain the semaphore without blocking */ - while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL ); + while ( + rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ) != RTEMS_SUCCESSFUL + ); /* print the expected and actual values */ - printf( "TA01: expected=%d actual=%d ran=%d\n", - task_data.expected_cpu, - task_data.actual_cpu, - task_data.ran - ); + printf( + "TA01: expected=%d actual=%d ran=%d\n", + task_data.expected_cpu, + task_data.actual_cpu, + task_data.ran + ); /* Verify expected results */ rtems_test_assert( task_data.ran == ran ); - if (ran) + if ( ran ) { rtems_test_assert( task_data.expected_cpu == task_data.actual_cpu ); + } - if (change_affinity) { - printf("Set TA01 to cpu %d\n", cpu); - CPU_ZERO(&task_data.cpuset); - CPU_SET(cpu, &task_data.cpuset); + if ( change_affinity ) { + printf( "Set TA01 to cpu %d\n", cpu ); + CPU_ZERO( &task_data.cpuset ); + CPU_SET( cpu, &task_data.cpuset ); sc = rtems_task_set_affinity( task_data.id, size, &task_data.cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } /* Reset the states */ @@ -108,117 +110,114 @@ static void task_verify( bool ran, bool change_affinity, int cpu ) task_data.expected_cpu = cpu; /* Release the semaphore */ - rtems_semaphore_release(task_sem); - test_delay(25); -} + rtems_semaphore_release( task_sem ); + test_delay( 25 ); +} -static void init_verify( int expect ) +static void init_verify( int expect ) { int cpu; - - test_delay(20); + test_delay( 20 ); cpu = rtems_scheduler_get_processor(); - printf( "Init: expected=%d actual=%d\n", expect, cpu); + printf( "Init: expected=%d actual=%d\n", expect, cpu ); rtems_test_assert( expect == cpu ); } -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; - rtems_status_code sc; + rtems_status_code sc; /* Never block and continually get core id */ - while (true) { - sc = rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0); - if (sc == RTEMS_SUCCESSFUL) { + while ( true ) { + sc = rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ); + if ( sc == RTEMS_SUCCESSFUL ) { task_data.actual_cpu = rtems_scheduler_get_processor(); task_data.ran = true; - rtems_semaphore_release(task_sem); - test_delay(25); + rtems_semaphore_release( task_sem ); + test_delay( 25 ); } } } -static void test(void) +static void test( void ) { - rtems_status_code sc; - uint32_t cpu_count; - rtems_id id_self; - cpu_set_t cpuset; - + rtems_status_code sc; + uint32_t cpu_count; + rtems_id id_self; + cpu_set_t cpuset; + /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); - if (cpu_count < NUM_CPUS) { - printf("Error: Test requires at least 2 cpus\n"); + if ( cpu_count < NUM_CPUS ) { + printf( "Error: Test requires at least 2 cpus\n" ); return; } id_self = rtems_task_self(); - - printf("Create Semaphore\n"); - sc = rtems_semaphore_create( - rtems_build_name('S', 'E', 'M', '0'), + + printf( "Create Semaphore\n" ); + sc = rtems_semaphore_create( + rtems_build_name( 'S', 'E', 'M', '0' ), 1, - RTEMS_BINARY_SEMAPHORE | - RTEMS_PRIORITY | - RTEMS_PRIORITY_CEILING, + RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, 0, &task_sem - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - printf("Create TA1\n"); + printf( "Create TA1\n" ); sc = rtems_task_create( - rtems_build_name('T', 'A', '0', '1'), + rtems_build_name( 'T', 'A', '0', '1' ), 4, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_data.id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* TA1 should start on cpu 0, since init starts on core 1 */ sc = rtems_task_start( task_data.id, task, 1 ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Verify Init task is on cpu 1 */ - init_verify(1); + init_verify( 1 ); /* Verify TA1 on cpu 0 and set the affinity to cpu 0 */ task_verify( true, true, 0 ); - + /* Verify Init task is on cpu 1 */ - init_verify(1); + init_verify( 1 ); /* Verify TA1 on cpu 0 and change the affinity to cpu 1 */ task_verify( true, true, 1 ); /* Verify Init task is on cpu 1 */ - init_verify(1); + init_verify( 1 ); /* Verify TA1 did not run */ task_verify( false, false, 1 ); /* Set affinity of Init to cpu 0 */ - printf("Set Affinity of init task to cpu 0\n"); - CPU_ZERO(&cpuset); - CPU_SET(0, &cpuset); - sc = rtems_task_set_affinity( id_self, sizeof(cpuset), &cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + printf( "Set Affinity of init task to cpu 0\n" ); + CPU_ZERO( &cpuset ); + CPU_SET( 0, &cpuset ); + sc = rtems_task_set_affinity( id_self, sizeof( cpuset ), &cpuset ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Verify init task went to cpu 0 */ - test_delay(50); - init_verify(0); + test_delay( 50 ); + init_verify( 0 ); /* Verfiy TA1 is now running on cpu 1 */ - task_verify(true, false, 1); + task_verify( true, false, 1 ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -227,7 +226,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -237,11 +236,11 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS NUM_CPUS -#define CONFIGURE_MAXIMUM_TASKS NUM_CPUS +#define CONFIGURE_MAXIMUM_TASKS NUM_CPUS #define CONFIGURE_MAXIMUM_SEMAPHORES 1 -#define CONFIGURE_INIT_TASK_PRIORITY 4 +#define CONFIGURE_INIT_TASK_PRIORITY 4 #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpschedaffinity03/init.c b/testsuites/smptests/smpschedaffinity03/init.c index 218914de58..653f4afb46 100644 --- a/testsuites/smptests/smpschedaffinity03/init.c +++ b/testsuites/smptests/smpschedaffinity03/init.c @@ -43,53 +43,52 @@ const char rtems_test_name[] = "SMPSCHEDAFFINITY 3"; #define NUM_CPUS 4 #define TASK_COUNT NUM_CPUS -static void test_delay(rtems_interval ticks) -{ +static void test_delay( rtems_interval ticks ) +{ rtems_interval start, stop; start = rtems_clock_get_ticks_since_boot(); do { stop = rtems_clock_get_ticks_since_boot(); - } while ( (stop - start) < ticks ); + } while ( ( stop - start ) < ticks ); } -static void test(void) +static void test( void ) { - rtems_status_code sc; - rtems_id id; - uint32_t cpu_count; - int cpu; - int i; - cpu_set_t cpuset; + rtems_status_code sc; + rtems_id id; + uint32_t cpu_count; + int cpu; + int i; + cpu_set_t cpuset; /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); - + id = rtems_task_self(); /* * The Init task comes up on the maximum core so start at * that core and walk the affinity down to core 0. */ - for( i=cpu_count-1; i >= 0; i--) { - + for ( i = cpu_count - 1; i >= 0; i-- ) { /* Move the affinity to the current core - 1 */ - CPU_ZERO(&cpuset); - CPU_SET(i, &cpuset); - printf("Set Affinity for cpu %d\n", i); - sc = rtems_task_set_affinity( id, sizeof(cpuset), &cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + CPU_ZERO( &cpuset ); + CPU_SET( i, &cpuset ); + printf( "Set Affinity for cpu %d\n", i ); + sc = rtems_task_set_affinity( id, sizeof( cpuset ), &cpuset ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Wait 100 clock ticks */ - test_delay(100); + test_delay( 100 ); /* Check the cpu the Init task is running on */ cpu = rtems_scheduler_get_processor(); - printf("On cpu %d\n", cpu); - rtems_test_assert(cpu == i); + printf( "On cpu %d\n", cpu ); + rtems_test_assert( cpu == i ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -98,7 +97,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -108,11 +107,11 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS NUM_CPUS -#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT +#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION - #define CONFIGURE_INIT_TASK_PRIORITY 8 + #define CONFIGURE_INIT_TASK_PRIORITY 8 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE #define CONFIGURE_INIT diff --git a/testsuites/smptests/smpschedaffinity04/init.c b/testsuites/smptests/smpschedaffinity04/init.c index 57a9839c4d..487cbe9643 100644 --- a/testsuites/smptests/smpschedaffinity04/init.c +++ b/testsuites/smptests/smpschedaffinity04/init.c @@ -44,135 +44,136 @@ const char rtems_test_name[] = "SMPSCHEDAFFINITY 4"; #define TASK_COUNT 2 struct task_data_t { - rtems_id id; - int expected_cpu; - bool ran; - int actual_cpu; + rtems_id id; + int expected_cpu; + bool ran; + int actual_cpu; }; -struct task_data_t task_data = { - 0x0, 2, false, 0xff -}; +struct task_data_t task_data = { 0x0, 2, false, 0xff }; -rtems_id task_sem; +rtems_id task_sem; -static void task(rtems_task_argument arg); +static void task( rtems_task_argument arg ); -static void test_delay(rtems_interval ticks) -{ +static void test_delay( rtems_interval ticks ) +{ rtems_interval start, stop; start = rtems_clock_get_ticks_since_boot(); do { stop = rtems_clock_get_ticks_since_boot(); - } while ( (stop - start) < ticks ); + } while ( ( stop - start ) < ticks ); } /* * Task that continually sets the cpu and * run indicators without blocking. */ -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; - rtems_status_code sc; + rtems_status_code sc; - while (true) { - sc = rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0); - if (sc == RTEMS_SUCCESSFUL) { + while ( true ) { + sc = rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ); + if ( sc == RTEMS_SUCCESSFUL ) { task_data.ran = true; task_data.actual_cpu = rtems_scheduler_get_processor(); - rtems_semaphore_release(task_sem); + rtems_semaphore_release( task_sem ); } } } -static void test(void) +static void test( void ) { - rtems_status_code sc; - uint32_t cpu_count; - uint32_t cpu; - uint32_t i; - cpu_set_t cpuset; + rtems_status_code sc; + uint32_t cpu_count; + uint32_t cpu; + uint32_t i; + cpu_set_t cpuset; /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); - if (cpu_count < 2) { - printf("Error: Test requires at least 2 cpus\n"); + if ( cpu_count < 2 ) { + printf( "Error: Test requires at least 2 cpus\n" ); return; } - printf("Create Semaphore\n"); - sc = rtems_semaphore_create( - rtems_build_name('S', 'E', 'M', '0'), - 1, /* initial count = 1 */ - RTEMS_BINARY_SEMAPHORE | - RTEMS_PRIORITY | - RTEMS_PRIORITY_CEILING, + printf( "Create Semaphore\n" ); + sc = rtems_semaphore_create( + rtems_build_name( 'S', 'E', 'M', '0' ), + 1, /* initial count = 1 */ + RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, 0, &task_sem - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* * Create and start TA1 at a higher priority * than the init task. */ sc = rtems_task_create( - rtems_build_name('T', 'A', '0', '1'), + rtems_build_name( 'T', 'A', '0', '1' ), 4, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_data.id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - printf("Start TA1\n"); + printf( "Start TA1\n" ); sc = rtems_task_start( task_data.id, task, 0 ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* * Verify the Init task is running on the max core. - */ - printf("Verify Init task is on cpu %" PRIu32 "\n",cpu_count-1); + */ + printf( "Verify Init task is on cpu %" PRIu32 "\n", cpu_count - 1 ); cpu = rtems_scheduler_get_processor(); - rtems_test_assert(cpu == (cpu_count-1)); + rtems_test_assert( cpu == ( cpu_count - 1 ) ); /* Walk TA1 across all of the cores */ - for(i=0; i < cpu_count; i++) { + for ( i = 0; i < cpu_count; i++ ) { /* Set the Affinity to core i */ - CPU_ZERO(&cpuset); - CPU_SET(i, &cpuset); - printf("Set Affinity TA1 to cpu %d\n", i); - sc = rtems_task_set_affinity( task_data.id, sizeof(cpuset), &cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + CPU_ZERO( &cpuset ); + CPU_SET( i, &cpuset ); + printf( "Set Affinity TA1 to cpu %d\n", i ); + sc = rtems_task_set_affinity( task_data.id, sizeof( cpuset ), &cpuset ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Wait a bit to be sure it has switched cores then clear the task data */ - test_delay(50); - while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL ); + test_delay( 50 ); + while ( + rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ) != RTEMS_SUCCESSFUL + ); task_data.ran = false; task_data.expected_cpu = i; - rtems_semaphore_release(task_sem); - test_delay(50); + rtems_semaphore_release( task_sem ); + test_delay( 50 ); /* Verify the task ran on core i */ - while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL ); - if (task_data.ran != true) - printf("Error: TA01 never ran.\n"); - else + while ( + rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ) != RTEMS_SUCCESSFUL + ); + if ( task_data.ran != true ) { + printf( "Error: TA01 never ran.\n" ); + } else { printf( - "TA1 expected cpu: %d actual cpu %d\n", + "TA1 expected cpu: %d actual cpu %d\n", task_data.expected_cpu, task_data.actual_cpu ); - rtems_test_assert(task_data.ran == true); - rtems_test_assert(task_data.expected_cpu == task_data.actual_cpu); - rtems_semaphore_release(task_sem); + } + rtems_test_assert( task_data.ran == true ); + rtems_test_assert( task_data.expected_cpu == task_data.actual_cpu ); + rtems_semaphore_release( task_sem ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -181,7 +182,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -193,11 +194,11 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS NUM_CPUS -#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT +#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION -#define CONFIGURE_INIT_TASK_PRIORITY 8 +#define CONFIGURE_INIT_TASK_PRIORITY 8 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE #define CONFIGURE_INIT diff --git a/testsuites/smptests/smpschedaffinity05/init.c b/testsuites/smptests/smpschedaffinity05/init.c index b0616fadc8..07a77e99c7 100644 --- a/testsuites/smptests/smpschedaffinity05/init.c +++ b/testsuites/smptests/smpschedaffinity05/init.c @@ -63,89 +63,96 @@ struct task_data_t { int migrate_cpu; }; -static struct task_data_t task_data[TASK_COUNT] = { - {0x0, {{0xc}}, 7, false, 3, -1, 2}, - {0x0, {{0xf}}, 8, false, 2, -1, -1}, - {0x0, {{0x3}}, 5, false, 1, -1, 0}, - {0x0, {{0x9}}, 6, false, 0, -1, 3}, - {0x0, {{0x2}}, 9, false, -1, -1, 1} +static struct task_data_t task_data[ TASK_COUNT ] = { + { 0x0, { { 0xc } }, 7, false, 3, -1, 2 }, + { 0x0, { { 0xf } }, 8, false, 2, -1, -1 }, + { 0x0, { { 0x3 } }, 5, false, 1, -1, 0 }, + { 0x0, { { 0x9 } }, 6, false, 0, -1, 3 }, + { 0x0, { { 0x2 } }, 9, false, -1, -1, 1 } }; -rtems_id task_sem; +rtems_id task_sem; -static void verify_tasks(void); +static void verify_tasks( void ); /* * Spin loop to allow tasks to delay without yeilding the * processor. */ -static void test_delay(rtems_interval ticks) +static void test_delay( rtems_interval ticks ) { rtems_interval start, stop; start = rtems_clock_get_ticks_since_boot(); do { stop = rtems_clock_get_ticks_since_boot(); - } while ( (stop - start) < ticks ); + } while ( ( stop - start ) < ticks ); } -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; - rtems_status_code sc; + rtems_status_code sc; - while (true) { - sc = rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0); - if (sc == RTEMS_SUCCESSFUL) { - task_data[arg].ran = true; - task_data[arg].actual_cpu = rtems_scheduler_get_processor(); - rtems_semaphore_release(task_sem); + while ( true ) { + sc = rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ); + if ( sc == RTEMS_SUCCESSFUL ) { + task_data[ arg ].ran = true; + task_data[ arg ].actual_cpu = rtems_scheduler_get_processor(); + rtems_semaphore_release( task_sem ); } } } -static void verify_tasks(void) +static void verify_tasks( void ) { int i; - printf("Verify Tasks Ran\n"); + printf( "Verify Tasks Ran\n" ); - while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL ); + while ( + rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ) != RTEMS_SUCCESSFUL + ); /* Set Init task data */ - task_data[0].ran = true; - task_data[0].actual_cpu = rtems_scheduler_get_processor(); + task_data[ 0 ].ran = true; + task_data[ 0 ].actual_cpu = rtems_scheduler_get_processor(); /* Verify all tasks */ - for (i = 0; i < NUM_CPUS; i++) { - if (i==0) - printf("Init(%" PRIu32 "): ran=%d expected=%d actual=%d\n", - task_data[i].priority, - task_data[i].ran, - task_data[i].expected_cpu, - task_data[i].actual_cpu + for ( i = 0; i < NUM_CPUS; i++ ) { + if ( i == 0 ) { + printf( + "Init(%" PRIu32 "): ran=%d expected=%d actual=%d\n", + task_data[ i ].priority, + task_data[ i ].ran, + task_data[ i ].expected_cpu, + task_data[ i ].actual_cpu ); - else - printf( "TA0%d(%" PRIu32 "): ran=%d expected=%d actual=%d\n", + } else { + printf( + "TA0%d(%" PRIu32 "): ran=%d expected=%d actual=%d\n", i, - task_data[i].priority, - task_data[i].ran, - task_data[i].expected_cpu, - task_data[i].actual_cpu + task_data[ i ].priority, + task_data[ i ].ran, + task_data[ i ].expected_cpu, + task_data[ i ].actual_cpu ); + } /* Abort test if values are not as expected */ - if ( task_data[i].expected_cpu == -1 ) - rtems_test_assert( task_data[i].ran == false ); - else { - rtems_test_assert( task_data[i].ran == true ); - rtems_test_assert( task_data[i].expected_cpu == task_data[i].actual_cpu ); + if ( task_data[ i ].expected_cpu == -1 ) { + rtems_test_assert( task_data[ i ].ran == false ); + } else { + rtems_test_assert( task_data[ i ].ran == true ); + rtems_test_assert( + task_data[ i ].expected_cpu == task_data[ i ].actual_cpu + ); } } - rtems_semaphore_release(task_sem); + rtems_semaphore_release( task_sem ); } -static void test(void) +static void test( void ) { rtems_status_code sc; rtems_task_argument i; @@ -155,60 +162,56 @@ static void test(void) /* Get the number of processors that we are using. */ cpu_count = rtems_scheduler_get_processor_maximum(); - if (cpu_count != 4) { - printf("Test requires a minimum of 4 cores\n"); + if ( cpu_count != 4 ) { + printf( "Test requires a minimum of 4 cores\n" ); return; } - size = sizeof(cpu_set_t); - task_data[0].id = rtems_task_self(); - printf("Create Semaphore\n"); + size = sizeof( cpu_set_t ); + task_data[ 0 ].id = rtems_task_self(); + printf( "Create Semaphore\n" ); sc = rtems_semaphore_create( - rtems_build_name('S', 'E', 'M', '0'), - 1, /* initial count = 1 */ - RTEMS_BINARY_SEMAPHORE | - RTEMS_PRIORITY | - RTEMS_PRIORITY_CEILING, + rtems_build_name( 'S', 'E', 'M', '0' ), + 1, /* initial count = 1 */ + RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, 0, &task_sem ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Create and start tasks on each cpu with the appropriate affinity. */ - for (i = 1; i < TASK_COUNT; i++) { + for ( i = 1; i < TASK_COUNT; i++ ) { + sc = rtems_task_create( + rtems_build_name( 'T', 'A', '0', '0' + i ), + task_data[ i ].priority, + RTEMS_MINIMUM_STACK_SIZE, + RTEMS_DEFAULT_MODES, + RTEMS_DEFAULT_ATTRIBUTES, + &task_data[ i ].id + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_create( - rtems_build_name('T', 'A', '0', '0'+i), - task_data[ i ].priority, - RTEMS_MINIMUM_STACK_SIZE, - RTEMS_DEFAULT_MODES, - RTEMS_DEFAULT_ATTRIBUTES, - &task_data[ i ].id - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( + task_data[ i ].id, + size, + &task_data[ i ].cpuset + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_affinity( - task_data[ i ].id, - size, - &task_data[i].cpuset - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - - printf( - "Start TA%" PRIdrtems_task_argument " at priority %" - PRIu32 " on cpu %d\n", - i, - task_data[i].priority, - task_data[i].expected_cpu - ); - sc = rtems_task_start( task_data[ i ].id, task, i ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + printf( + "Start TA%" PRIdrtems_task_argument " at priority %" PRIu32 + " on cpu %d\n", + i, + task_data[ i ].priority, + task_data[ i ].expected_cpu + ); + sc = rtems_task_start( task_data[ i ].id, task, i ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } /* spin for 100 ticks */ - test_delay(100); + test_delay( 100 ); verify_tasks(); @@ -217,27 +220,29 @@ static void test(void) printf( "Set TA%" PRIdrtems_task_argument " priority %" PRIu32 "\n", i, - task_data[i].priority + task_data[ i ].priority ); sc = rtems_task_set_priority( task_data[ i ].id, task_data[ i ].priority, &priority ); - test_delay(25); + test_delay( 25 ); - while( rtems_semaphore_obtain (task_sem, RTEMS_NO_WAIT, 0) != RTEMS_SUCCESSFUL ); - for (i = 0; i < TASK_COUNT; i++) { + while ( + rtems_semaphore_obtain( task_sem, RTEMS_NO_WAIT, 0 ) != RTEMS_SUCCESSFUL + ); + for ( i = 0; i < TASK_COUNT; i++ ) { task_data[ i ].expected_cpu = task_data[ i ].migrate_cpu; task_data[ i ].actual_cpu = -1; task_data[ i ].ran = false; } - rtems_semaphore_release(task_sem); - test_delay(25); + rtems_semaphore_release( task_sem ); + test_delay( 25 ); verify_tasks(); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -246,7 +251,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -256,13 +261,13 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS NUM_CPUS -#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT +#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT #define CONFIGURE_MAXIMUM_SEMAPHORES 1 #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION -#define CONFIGURE_INIT_TASK_PRIORITY 7 +#define CONFIGURE_INIT_TASK_PRIORITY 7 #define CONFIGURE_RTEMS_INIT_TASKS_TABLE #define CONFIGURE_INIT diff --git a/testsuites/smptests/smpschededf01/init.c b/testsuites/smptests/smpschededf01/init.c index fdef853c6d..af7bba94d8 100644 --- a/testsuites/smptests/smpschededf01/init.c +++ b/testsuites/smptests/smpschededf01/init.c @@ -37,96 +37,96 @@ const char rtems_test_name[] = "SMPSCHEDEDF 1"; typedef struct { - rtems_id task[2]; + rtems_id task[ 2 ]; } test_context; static test_context test_instance; -static void t(test_context *ctx, rtems_interval p, long nanoseconds) +static void t( test_context *ctx, rtems_interval p, long nanoseconds ) { (void) ctx; rtems_status_code sc; - rtems_id period; - rtems_name name; + rtems_id period; + rtems_name name; - sc = rtems_object_get_classic_name(rtems_task_self(), &name); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_object_get_classic_name( rtems_task_self(), &name ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_rate_monotonic_create(name, &period); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_rate_monotonic_create( name, &period ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (true) { - rtems_test_busy_cpu_usage(0, nanoseconds); + while ( true ) { + rtems_test_busy_cpu_usage( 0, nanoseconds ); - sc = rtems_rate_monotonic_period(period, p); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_rate_monotonic_period( period, p ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void t1(rtems_task_argument arg) +static void t1( rtems_task_argument arg ) { test_context *ctx = (test_context *) arg; - t(ctx, 50, 25000000); + t( ctx, 50, 25000000 ); } -static void t2(rtems_task_argument arg) +static void t2( rtems_task_argument arg ) { test_context *ctx = (test_context *) arg; - t(ctx, 75, 30000000); + t( ctx, 75, 30000000 ); } -static void test(test_context *ctx) +static void test( test_context *ctx ) { rtems_status_code sc; sc = rtems_task_create( - rtems_build_name('T', '1', ' ', ' '), + rtems_build_name( 'T', '1', ' ', ' ' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->task[0] + &ctx->task[ 0 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('T', '2', ' ', ' '), + rtems_build_name( 'T', '2', ' ', ' ' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->task[1] + &ctx->task[ 1 ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_wake_after(1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->task[0], t1, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->task[ 0 ], t1, (rtems_task_argument) ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->task[1], t2, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->task[ 1 ], t2, (rtems_task_argument) ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); rtems_cpu_usage_reset(); - sc = rtems_task_wake_after(50 * 75); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 50 * 75 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_suspend(ctx->task[0]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->task[ 0 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_suspend(ctx->task[1]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( ctx->task[ 1 ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_cpu_usage_report_with_plugin(&rtems_test_printer); - rtems_rate_monotonic_report_statistics_with_plugin(&rtems_test_printer); + rtems_cpu_usage_report_with_plugin( &rtems_test_printer ); + rtems_rate_monotonic_report_statistics_with_plugin( &rtems_test_printer ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -134,10 +134,10 @@ static void Init(rtems_task_argument arg) TEST_BEGIN(); - test(ctx); + test( ctx ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_MICROSECONDS_PER_TICK 1000 @@ -145,7 +145,7 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS 3 +#define CONFIGURE_MAXIMUM_TASKS 3 #define CONFIGURE_MAXIMUM_PERIODS 2 #define CONFIGURE_MAXIMUM_PROCESSORS 1 @@ -154,13 +154,13 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_EDF_SMP(a); +RTEMS_SCHEDULER_EDF_SMP( a ); #define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(a, rtems_build_name('E', 'D', 'F', ' ')) + RTEMS_SCHEDULER_TABLE_EDF_SMP( a, rtems_build_name( 'E', 'D', 'F', ' ' ) ) #define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpschededf02/init.c b/testsuites/smptests/smpschededf02/init.c index 211b4a0669..24aff38fb7 100644 --- a/testsuites/smptests/smpschededf02/init.c +++ b/testsuites/smptests/smpschededf02/init.c @@ -39,18 +39,11 @@ const char rtems_test_name[] = "SMPSCHEDEDF 2"; #define TASK_COUNT 5 -#define P(i) (UINT32_C(2) + i) +#define P( i ) ( UINT32_C( 2 ) + i ) -#define A(cpu0, cpu1) ((cpu1 << 1) | cpu0) +#define A( cpu0, cpu1 ) ( ( cpu1 << 1 ) | cpu0 ) -typedef enum { - T0, - T1, - T2, - T3, - T4, - IDLE -} task_index; +typedef enum { T0, T1, T2, T3, T4, IDLE } task_index; typedef struct { enum { @@ -65,168 +58,168 @@ typedef struct { struct { rtems_task_priority priority; - uint32_t cpu_set; + uint32_t cpu_set; } data; - uint8_t expected_cpu_allocations[CPU_COUNT]; + uint8_t expected_cpu_allocations[ CPU_COUNT ]; } test_action; typedef struct { rtems_id timer_id; rtems_id master_id; - rtems_id task_ids[TASK_COUNT]; - size_t action_index; + rtems_id task_ids[ TASK_COUNT ]; + size_t action_index; } test_context; -#define RESET \ - { \ - KIND_RESET, \ - 0, \ - { 0 }, \ - { IDLE, IDLE } \ +#define RESET \ + { \ + KIND_RESET, 0, { 0 }, \ + { \ + IDLE, IDLE \ + } \ } -#define SET_PRIORITY(index, prio, cpu0, cpu1) \ - { \ - KIND_SET_PRIORITY, \ - index, \ - { .priority = prio }, \ - { cpu0, cpu1 } \ +#define SET_PRIORITY( index, prio, cpu0, cpu1 ) \ + { \ + KIND_SET_PRIORITY, index, { .priority = prio }, \ + { \ + cpu0, cpu1 \ + } \ } -#define SET_AFFINITY(index, aff, cpu0, cpu1) \ - { \ - KIND_SET_AFFINITY, \ - index, \ - { .cpu_set = aff }, \ - { cpu0, cpu1 } \ +#define SET_AFFINITY( index, aff, cpu0, cpu1 ) \ + { \ + KIND_SET_AFFINITY, index, { .cpu_set = aff }, \ + { \ + cpu0, cpu1 \ + } \ } -#define BLOCK(index, cpu0, cpu1) \ - { \ - KIND_BLOCK, \ - index, \ - { 0 }, \ - { cpu0, cpu1 } \ +#define BLOCK( index, cpu0, cpu1 ) \ + { \ + KIND_BLOCK, index, { 0 }, \ + { \ + cpu0, cpu1 \ + } \ } -#define UNBLOCK(index, cpu0, cpu1) \ - { \ - KIND_UNBLOCK, \ - index, \ - { 0 }, \ - { cpu0, cpu1 } \ +#define UNBLOCK( index, cpu0, cpu1 ) \ + { \ + KIND_UNBLOCK, index, { 0 }, \ + { \ + cpu0, cpu1 \ + } \ } static const test_action test_actions[] = { RESET, - UNBLOCK( T0, T0, IDLE), - UNBLOCK( T1, T0, T1), - UNBLOCK( T3, T0, T1), - SET_PRIORITY( T1, P(2), T0, T1), - SET_PRIORITY( T3, P(1), T0, T3), - BLOCK( T3, T0, T1), - SET_AFFINITY( T1, A(1, 1), T0, T1), - SET_AFFINITY( T1, A(1, 0), T1, T0), - SET_AFFINITY( T1, A(1, 1), T1, T0), - SET_AFFINITY( T1, A(1, 0), T1, T0), - SET_AFFINITY( T1, A(0, 1), T0, T1), - BLOCK( T0, IDLE, T1), - UNBLOCK( T0, T0, T1), - BLOCK( T1, T0, IDLE), - UNBLOCK( T1, T0, T1), + UNBLOCK( T0, T0, IDLE ), + UNBLOCK( T1, T0, T1 ), + UNBLOCK( T3, T0, T1 ), + SET_PRIORITY( T1, P( 2 ), T0, T1 ), + SET_PRIORITY( T3, P( 1 ), T0, T3 ), + BLOCK( T3, T0, T1 ), + SET_AFFINITY( T1, A( 1, 1 ), T0, T1 ), + SET_AFFINITY( T1, A( 1, 0 ), T1, T0 ), + SET_AFFINITY( T1, A( 1, 1 ), T1, T0 ), + SET_AFFINITY( T1, A( 1, 0 ), T1, T0 ), + SET_AFFINITY( T1, A( 0, 1 ), T0, T1 ), + BLOCK( T0, IDLE, T1 ), + UNBLOCK( T0, T0, T1 ), + BLOCK( T1, T0, IDLE ), + UNBLOCK( T1, T0, T1 ), /* * Show that FIFO order is honoured across all threads of the same priority. */ RESET, - SET_PRIORITY( T1, P(0), IDLE, IDLE), - SET_PRIORITY( T2, P(1), IDLE, IDLE), - SET_PRIORITY( T3, P(1), IDLE, IDLE), - SET_AFFINITY( T3, A(1, 0), IDLE, IDLE), - SET_PRIORITY( T4, P(1), IDLE, IDLE), - SET_AFFINITY( T4, A(1, 0), IDLE, IDLE), - UNBLOCK( T0, T0, IDLE), - UNBLOCK( T1, T0, T1), - UNBLOCK( T2, T0, T1), - UNBLOCK( T3, T0, T1), - UNBLOCK( T4, T0, T1), - BLOCK( T1, T0, T2), - BLOCK( T2, T3, T0), - BLOCK( T3, T4, T0), + SET_PRIORITY( T1, P( 0 ), IDLE, IDLE ), + SET_PRIORITY( T2, P( 1 ), IDLE, IDLE ), + SET_PRIORITY( T3, P( 1 ), IDLE, IDLE ), + SET_AFFINITY( T3, A( 1, 0 ), IDLE, IDLE ), + SET_PRIORITY( T4, P( 1 ), IDLE, IDLE ), + SET_AFFINITY( T4, A( 1, 0 ), IDLE, IDLE ), + UNBLOCK( T0, T0, IDLE ), + UNBLOCK( T1, T0, T1 ), + UNBLOCK( T2, T0, T1 ), + UNBLOCK( T3, T0, T1 ), + UNBLOCK( T4, T0, T1 ), + BLOCK( T1, T0, T2 ), + BLOCK( T2, T3, T0 ), + BLOCK( T3, T4, T0 ), /* * Schedule a high priority affine thread directly with a low priority affine * thread in the corresponding ready queue. In this case we, remove the * affine ready queue in _Scheduler_EDF_SMP_Allocate_processor(). */ RESET, - UNBLOCK( T0, T0, IDLE), - UNBLOCK( T1, T0, T1), - SET_PRIORITY( T1, P(2), T0, T1), - SET_AFFINITY( T3, A(0, 1), T0, T1), - UNBLOCK( T3, T0, T1), - SET_PRIORITY( T2, P(1), T0, T1), - SET_AFFINITY( T2, A(0, 1), T0, T1), - UNBLOCK( T2, T0, T2), - BLOCK( T1, T0, T2), - BLOCK( T2, T0, T3), + UNBLOCK( T0, T0, IDLE ), + UNBLOCK( T1, T0, T1 ), + SET_PRIORITY( T1, P( 2 ), T0, T1 ), + SET_AFFINITY( T3, A( 0, 1 ), T0, T1 ), + UNBLOCK( T3, T0, T1 ), + SET_PRIORITY( T2, P( 1 ), T0, T1 ), + SET_AFFINITY( T2, A( 0, 1 ), T0, T1 ), + UNBLOCK( T2, T0, T2 ), + BLOCK( T1, T0, T2 ), + BLOCK( T2, T0, T3 ), /* Force migration of a higher priority one-to-all thread */ RESET, - UNBLOCK( T0, T0, IDLE), - SET_AFFINITY( T1, A(1, 0), T0, IDLE), - UNBLOCK( T1, T1, T0), + UNBLOCK( T0, T0, IDLE ), + SET_AFFINITY( T1, A( 1, 0 ), T0, IDLE ), + UNBLOCK( T1, T1, T0 ), /* * Block a one-to-one thread while having a non-empty affine ready queue on * the same processor. */ RESET, - SET_AFFINITY( T1, A(1, 0), IDLE, IDLE), - SET_AFFINITY( T3, A(1, 0), IDLE, IDLE), - UNBLOCK( T0, T0, IDLE), - UNBLOCK( T1, T1, T0), - UNBLOCK( T2, T1, T0), - UNBLOCK( T3, T1, T0), - BLOCK( T1, T2, T0), - BLOCK( T0, T3, T2), + SET_AFFINITY( T1, A( 1, 0 ), IDLE, IDLE ), + SET_AFFINITY( T3, A( 1, 0 ), IDLE, IDLE ), + UNBLOCK( T0, T0, IDLE ), + UNBLOCK( T1, T1, T0 ), + UNBLOCK( T2, T1, T0 ), + UNBLOCK( T3, T1, T0 ), + BLOCK( T1, T2, T0 ), + BLOCK( T0, T3, T2 ), /* * Make sure that a one-to-one thread does not get the wrong processor * allocated after selecting the highest ready thread. */ RESET, - SET_AFFINITY( T1, A(1, 0), IDLE, IDLE), - SET_AFFINITY( T2, A(1, 0), IDLE, IDLE), - UNBLOCK( T0, T0, IDLE), - UNBLOCK( T1, T1, T0), - UNBLOCK( T2, T1, T0), - BLOCK( T0, T1, IDLE), + SET_AFFINITY( T1, A( 1, 0 ), IDLE, IDLE ), + SET_AFFINITY( T2, A( 1, 0 ), IDLE, IDLE ), + UNBLOCK( T0, T0, IDLE ), + UNBLOCK( T1, T1, T0 ), + UNBLOCK( T2, T1, T0 ), + BLOCK( T0, T1, IDLE ), RESET }; static test_context test_instance; -static void set_priority(rtems_id id, rtems_task_priority prio) +static void set_priority( rtems_id id, rtems_task_priority prio ) { rtems_status_code sc; - sc = rtems_task_set_priority(id, prio, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( id, prio, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void set_affinity(rtems_id id, uint32_t cpu_set_32) +static void set_affinity( rtems_id id, uint32_t cpu_set_32 ) { rtems_status_code sc; - cpu_set_t cpu_set; - size_t i; + cpu_set_t cpu_set; + size_t i; - CPU_ZERO(&cpu_set); + CPU_ZERO( &cpu_set ); - for (i = 0; i < CPU_COUNT; ++i) { - if ((cpu_set_32 & (UINT32_C(1) << i)) != 0) { - CPU_SET(i, &cpu_set); + for ( i = 0; i < CPU_COUNT; ++i ) { + if ( ( cpu_set_32 & ( UINT32_C( 1 ) << i ) ) != 0 ) { + CPU_SET( i, &cpu_set ); } } - sc = rtems_task_set_affinity(id, sizeof(cpu_set), &cpu_set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( id, sizeof( cpu_set ), &cpu_set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } /* @@ -235,24 +228,26 @@ static void set_affinity(rtems_id id, uint32_t cpu_set_32) * idle threads shall be ordered in the scheduled chain according to the CPU * index. */ -static void reset(test_context *ctx) +static void reset( test_context *ctx ) { rtems_status_code sc; - size_t i; + size_t i; - for (i = 0; i < TASK_COUNT; ++i) { - set_priority(ctx->task_ids[i], P(i)); - set_affinity(ctx->task_ids[i], A(1, 1)); + for ( i = 0; i < TASK_COUNT; ++i ) { + set_priority( ctx->task_ids[ i ], P( i ) ); + set_affinity( ctx->task_ids[ i ], A( 1, 1 ) ); } - for (i = CPU_COUNT; i < TASK_COUNT; ++i) { - sc = rtems_task_suspend(ctx->task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_ALREADY_SUSPENDED); + for ( i = CPU_COUNT; i < TASK_COUNT; ++i ) { + sc = rtems_task_suspend( ctx->task_ids[ i ] ); + rtems_test_assert( + sc == RTEMS_SUCCESSFUL || sc == RTEMS_ALREADY_SUSPENDED + ); } - for (i = 0; i < CPU_COUNT; ++i) { - sc = rtems_task_resume(ctx->task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_INCORRECT_STATE); + for ( i = 0; i < CPU_COUNT; ++i ) { + sc = rtems_task_resume( ctx->task_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL || sc == RTEMS_INCORRECT_STATE ); } /* @@ -262,35 +257,38 @@ static void reset(test_context *ctx) * a test case. The idle threads of a scheduler have all the same priority, * so we have to take the FIFO ordering within a priority group into account. */ - for (i = 0; i < CPU_COUNT; ++i) { + for ( i = 0; i < CPU_COUNT; ++i ) { const Per_CPU_Control *c; - const Thread_Control *h; + const Thread_Control *h; - c = _Per_CPU_Get_by_index(CPU_COUNT - 1 - i); + c = _Per_CPU_Get_by_index( CPU_COUNT - 1 - i ); h = c->heir; - sc = rtems_task_suspend(h->Object.id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( h->Object.id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void check_cpu_allocations(test_context *ctx, const test_action *action) +static void check_cpu_allocations( + test_context *ctx, + const test_action *action +) { size_t i; - for (i = 0; i < CPU_COUNT; ++i) { - task_index e; + for ( i = 0; i < CPU_COUNT; ++i ) { + task_index e; const Per_CPU_Control *c; - const Thread_Control *h; + const Thread_Control *h; - e = action->expected_cpu_allocations[i]; - c = _Per_CPU_Get_by_index(i); + e = action->expected_cpu_allocations[ i ]; + c = _Per_CPU_Get_by_index( i ); h = c->heir; - if (e != IDLE) { - rtems_test_assert(h->Object.id == ctx->task_ids[e]); + if ( e != IDLE ) { + rtems_test_assert( h->Object.id == ctx->task_ids[ e ] ); } else { - rtems_test_assert(h->is_idle); + rtems_test_assert( h->is_idle ); } } } @@ -299,131 +297,131 @@ static void check_cpu_allocations(test_context *ctx, const test_action *action) * Use a timer to execute the actions, since it runs with thread dispatching * disabled. This is necessary to check the expected processor allocations. */ -static void timer(rtems_id id, void *arg) +static void timer( rtems_id id, void *arg ) { - test_context *ctx; + test_context *ctx; rtems_status_code sc; - size_t i; + size_t i; ctx = arg; i = ctx->action_index; - if (i == 0) { - sc = rtems_task_suspend(ctx->master_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + if ( i == 0 ) { + sc = rtems_task_suspend( ctx->master_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - if (i < RTEMS_ARRAY_SIZE(test_actions)) { - const test_action *action = &test_actions[i]; - rtems_id task; + if ( i < RTEMS_ARRAY_SIZE( test_actions ) ) { + const test_action *action = &test_actions[ i ]; + rtems_id task; ctx->action_index = i + 1; - task = ctx->task_ids[action->index]; + task = ctx->task_ids[ action->index ]; - switch (action->kind) { + switch ( action->kind ) { case KIND_SET_PRIORITY: - set_priority(task, action->data.priority); + set_priority( task, action->data.priority ); break; case KIND_SET_AFFINITY: - set_affinity(task, action->data.cpu_set); + set_affinity( task, action->data.cpu_set ); break; case KIND_BLOCK: - sc = rtems_task_suspend(task); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( task ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); break; case KIND_UNBLOCK: - sc = rtems_task_resume(task); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( task ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); break; default: - rtems_test_assert(action->kind == KIND_RESET); - reset(ctx); + rtems_test_assert( action->kind == KIND_RESET ); + reset( ctx ); break; } - check_cpu_allocations(ctx, action); + check_cpu_allocations( ctx, action ); - sc = rtems_timer_reset(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_reset( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } else { - sc = rtems_task_resume(ctx->master_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->master_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(ctx->master_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( ctx->master_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void do_nothing_task(rtems_task_argument arg) +static void do_nothing_task( rtems_task_argument arg ) { (void) arg; - while (true) { + while ( true ) { /* Do nothing */ } } -static void test(void) +static void test( void ) { - test_context *ctx; + test_context *ctx; rtems_status_code sc; - size_t i; + size_t i; ctx = &test_instance; ctx->master_id = rtems_task_self(); - for (i = 0; i < TASK_COUNT; ++i) { + for ( i = 0; i < TASK_COUNT; ++i ) { sc = rtems_task_create( - rtems_build_name(' ', ' ', 'T', '0' + i), - P(i), + rtems_build_name( ' ', ' ', 'T', '0' + i ), + P( i ), RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->task_ids[i] + &ctx->task_ids[ i ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->task_ids[i], do_nothing_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->task_ids[ i ], do_nothing_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } sc = rtems_timer_create( - rtems_build_name('A', 'C', 'T', 'N'), + rtems_build_name( 'A', 'C', 'T', 'N' ), &ctx->timer_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_timer_fire_after(ctx->timer_id, 1, timer, ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_fire_after( ctx->timer_id, 1, timer, ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < TASK_COUNT; ++i) { - sc = rtems_task_delete(ctx->task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( i = 0; i < TASK_COUNT; ++i ) { + sc = rtems_task_delete( ctx->task_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_timer_delete(ctx->timer_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_delete( ctx->timer_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() == CPU_COUNT) { + if ( rtems_scheduler_get_processor_maximum() == CPU_COUNT ) { test(); } else { - puts("warning: wrong processor count to run the test"); + puts( "warning: wrong processor count to run the test" ); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_MICROSECONDS_PER_TICK 1000 @@ -431,7 +429,7 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS (1 + TASK_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + TASK_COUNT ) #define CONFIGURE_MAXIMUM_TIMERS 1 #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT diff --git a/testsuites/smptests/smpschededf03/init.c b/testsuites/smptests/smpschededf03/init.c index 89a0098c48..bcbf8f23db 100644 --- a/testsuites/smptests/smpschededf03/init.c +++ b/testsuites/smptests/smpschededf03/init.c @@ -37,34 +37,34 @@ const char rtems_test_name[] = "SMPSCHEDEDF 3"; #define CPU_COUNT 32 -#define TASK_COUNT (3 * CPU_COUNT) +#define TASK_COUNT ( 3 * CPU_COUNT ) typedef struct { - rtems_id task_ids[TASK_COUNT]; + rtems_id task_ids[ TASK_COUNT ]; } test_context; static test_context test_instance; -static void wait_task(rtems_task_argument arg) +static void wait_task( rtems_task_argument arg ) { (void) arg; - while (true) { + while ( true ) { rtems_status_code sc; - sc = rtems_task_wake_after(1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static uint32_t simple_random(uint32_t v) +static uint32_t simple_random( uint32_t v ) { v *= 1664525; v += 1013904223; return v; } -static void affinity_task(rtems_task_argument arg) +static void affinity_task( rtems_task_argument arg ) { uint32_t v; uint32_t n; @@ -72,24 +72,24 @@ static void affinity_task(rtems_task_argument arg) v = (uint32_t) arg; n = rtems_scheduler_get_processor_maximum(); - while (true) { + while ( true ) { rtems_status_code sc; - cpu_set_t set; + cpu_set_t set; - CPU_ZERO(&set); - CPU_SET((v >> 13) % n, &set); - v = simple_random(v); + CPU_ZERO( &set ); + CPU_SET( ( v >> 13 ) % n, &set ); + v = simple_random( v ); - sc = rtems_task_set_affinity(RTEMS_SELF, sizeof(set), &set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( RTEMS_SELF, sizeof( set ), &set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } static void create_and_start_task( - test_context *ctx, + test_context *ctx, rtems_task_entry entry, - size_t i, - size_t j + size_t i, + size_t j ) { rtems_status_code sc; @@ -97,62 +97,58 @@ static void create_and_start_task( j = j * CPU_COUNT + i; sc = rtems_task_create( - rtems_build_name('E', 'D', 'F', ' '), + rtems_build_name( 'E', 'D', 'F', ' ' ), i + 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->task_ids[j] + &ctx->task_ids[ j ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->task_ids[j], entry, j); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->task_ids[ j ], entry, j ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void delete_task( - test_context *ctx, - size_t i, - size_t j -) +static void delete_task( test_context *ctx, size_t i, size_t j ) { rtems_status_code sc; j = j * CPU_COUNT + i; - sc = rtems_task_delete(ctx->task_ids[j]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->task_ids[ j ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test(test_context *ctx) +static void test( test_context *ctx ) { rtems_status_code sc; - size_t i; + size_t i; - for (i = 0; i < CPU_COUNT; ++i) { - create_and_start_task(ctx, wait_task, i, 0); - create_and_start_task(ctx, affinity_task, i, 1); - create_and_start_task(ctx, affinity_task, i, 2); + for ( i = 0; i < CPU_COUNT; ++i ) { + create_and_start_task( ctx, wait_task, i, 0 ); + create_and_start_task( ctx, affinity_task, i, 1 ); + create_and_start_task( ctx, affinity_task, i, 2 ); } - sc = rtems_task_wake_after(10 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 10 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < CPU_COUNT; ++i) { - delete_task(ctx, i, 0); - delete_task(ctx, i, 1); - delete_task(ctx, i, 2); + for ( i = 0; i < CPU_COUNT; ++i ) { + delete_task( ctx, i, 0 ); + delete_task( ctx, i, 1 ); + delete_task( ctx, i, 2 ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - test(&test_instance); + test( &test_instance ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_MICROSECONDS_PER_TICK 1000 @@ -160,7 +156,7 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS (1 + TASK_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + TASK_COUNT ) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT diff --git a/testsuites/smptests/smpschededf04/init.c b/testsuites/smptests/smpschededf04/init.c index 33a7be6b45..9655cfe19d 100644 --- a/testsuites/smptests/smpschededf04/init.c +++ b/testsuites/smptests/smpschededf04/init.c @@ -39,87 +39,91 @@ const char rtems_test_name[] = "SMPSCHEDEDF 4"; #define TASK_COUNT 2 -#define MAIN rtems_build_name('M', 'A', 'I', 'N') +#define MAIN rtems_build_name( 'M', 'A', 'I', 'N' ) -#define OTHER rtems_build_name('O', 'T', 'H', 'R') +#define OTHER rtems_build_name( 'O', 'T', 'H', 'R' ) typedef struct { rtems_id other_scheduler_id; - rtems_id task_ids[TASK_COUNT]; + rtems_id task_ids[ TASK_COUNT ]; } test_context; static test_context test_instance; -static void do_nothing_task(rtems_task_argument arg) +static void do_nothing_task( rtems_task_argument arg ) { (void) arg; - _CPU_Thread_Idle_body(0); + _CPU_Thread_Idle_body( 0 ); } -static void test(void) +static void test( void ) { - test_context *ctx; + test_context *ctx; rtems_status_code sc; - size_t i; + size_t i; ctx = &test_instance; - for (i = 0; i < TASK_COUNT; ++i) { + for ( i = 0; i < TASK_COUNT; ++i ) { sc = rtems_task_create( - rtems_build_name('N', 'B', 'D', 'Y'), + rtems_build_name( 'N', 'B', 'D', 'Y' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->task_ids[i] + &ctx->task_ids[ i ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->task_ids[i], do_nothing_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->task_ids[ i ], do_nothing_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_scheduler_ident(OTHER, &ctx->other_scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( OTHER, &ctx->other_scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < TASK_COUNT; ++i) { + for ( i = 0; i < TASK_COUNT; ++i ) { const Per_CPU_Control *cpu; - sc = rtems_task_set_scheduler(ctx->task_ids[i], ctx->other_scheduler_id, 2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( + ctx->task_ids[ i ], + ctx->other_scheduler_id, + 2 + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - cpu = _Per_CPU_Get_by_index(CPU_COUNT - 1 - i); - rtems_test_assert(cpu->heir->Object.id == ctx->task_ids[i]); + cpu = _Per_CPU_Get_by_index( CPU_COUNT - 1 - i ); + rtems_test_assert( cpu->heir->Object.id == ctx->task_ids[ i ] ); } - for (i = 0; i < TASK_COUNT; ++i) { - sc = rtems_task_delete(ctx->task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( i = 0; i < TASK_COUNT; ++i ) { + sc = rtems_task_delete( ctx->task_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() == CPU_COUNT) { + if ( rtems_scheduler_get_processor_maximum() == CPU_COUNT ) { test(); } else { - puts("warning: wrong processor count to run the test"); + puts( "warning: wrong processor count to run the test" ); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS (1 + TASK_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + TASK_COUNT ) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT @@ -127,19 +131,19 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_EDF_SMP(a); +RTEMS_SCHEDULER_EDF_SMP( a ); -RTEMS_SCHEDULER_EDF_SMP(b); +RTEMS_SCHEDULER_EDF_SMP( b ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(a, MAIN), \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(b, OTHER) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( a, MAIN ), \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( b, OTHER ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpschedsem01/init.c b/testsuites/smptests/smpschedsem01/init.c index cc105d1c56..ba0c77c104 100644 --- a/testsuites/smptests/smpschedsem01/init.c +++ b/testsuites/smptests/smpschedsem01/init.c @@ -36,52 +36,50 @@ const char rtems_test_name[] = "SMPSCHEDSEM 01"; -#define NUM_CPUS 1 -#define TASK_COUNT 2 +#define NUM_CPUS 1 +#define TASK_COUNT 2 #define TASK_PRIORITY 8 -#define SEM_PRIORITY 5 +#define SEM_PRIORITY 5 /* * Test verifies priority, * Changes priority by obtaining a higher priority semaphore * Releases semaphore to return priority */ -static void test(void) +static void test( void ) { rtems_status_code sc; rtems_task_priority priority; rtems_id task_sem; - sc = rtems_semaphore_create( - rtems_build_name('S', 'E', 'M', '0'), + sc = rtems_semaphore_create( + rtems_build_name( 'S', 'E', 'M', '0' ), 1, - RTEMS_BINARY_SEMAPHORE | - RTEMS_PRIORITY | - RTEMS_PRIORITY_CEILING, + RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, 5, &task_sem - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority); - printf("Init: priority %d expected %d\n",(int)priority, TASK_PRIORITY ); + rtems_task_set_priority( RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority ); + printf( "Init: priority %d expected %d\n", (int) priority, TASK_PRIORITY ); rtems_test_assert( priority == TASK_PRIORITY ); - printf("Init: Obtain Semaphore\n"); - sc = rtems_semaphore_obtain (task_sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority); - printf("Init: priority %d expected %d\n",(int)priority, SEM_PRIORITY ); + printf( "Init: Obtain Semaphore\n" ); + sc = rtems_semaphore_obtain( task_sem, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_task_set_priority( RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority ); + printf( "Init: priority %d expected %d\n", (int) priority, SEM_PRIORITY ); rtems_test_assert( priority == SEM_PRIORITY ); - printf("Init: Release Semaphore\n"); - rtems_semaphore_release(task_sem); - rtems_task_set_priority(RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority); - printf("Init: priority %d expected %d\n",(int)priority, TASK_PRIORITY ); + printf( "Init: Release Semaphore\n" ); + rtems_semaphore_release( task_sem ); + rtems_task_set_priority( RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &priority ); + printf( "Init: priority %d expected %d\n", (int) priority, TASK_PRIORITY ); rtems_test_assert( priority == TASK_PRIORITY ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -90,7 +88,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -100,12 +98,12 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS NUM_CPUS -#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT -#define CONFIGURE_MAXIMUM_SEMAPHORES 1 +#define CONFIGURE_MAXIMUM_TASKS TASK_COUNT +#define CONFIGURE_MAXIMUM_SEMAPHORES 1 #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION -#define CONFIGURE_INIT_TASK_PRIORITY TASK_PRIORITY +#define CONFIGURE_INIT_TASK_PRIORITY TASK_PRIORITY #define CONFIGURE_RTEMS_INIT_TASKS_TABLE #define CONFIGURE_INIT diff --git a/testsuites/smptests/smpscheduler01/init.c b/testsuites/smptests/smpscheduler01/init.c index 576d09c53a..e5503997cc 100644 --- a/testsuites/smptests/smpscheduler01/init.c +++ b/testsuites/smptests/smpscheduler01/init.c @@ -44,61 +44,61 @@ const char rtems_test_name[] = "SMPSCHEDULER 1"; #define SECOND_TASK_READY RTEMS_EVENT_0 -static rtems_id task_ids[TASK_COUNT]; +static rtems_id task_ids[ TASK_COUNT ]; -static void suspend(size_t i) +static void suspend( size_t i ) { - rtems_status_code sc = rtems_task_suspend(task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_status_code sc = rtems_task_suspend( task_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void resume(size_t i) +static void resume( size_t i ) { - rtems_status_code sc = rtems_task_resume(task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_status_code sc = rtems_task_resume( task_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; rtems_task_priority task_priority; - rtems_status_code sc; + rtems_status_code sc; sc = rtems_task_set_priority( RTEMS_SELF, RTEMS_CURRENT_PRIORITY, &task_priority ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - if (arg == 1) { - sc = rtems_event_send(task_ids[0], SECOND_TASK_READY); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + if ( arg == 1 ) { + sc = rtems_event_send( task_ids[ 0 ], SECOND_TASK_READY ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - while (true) { + while ( true ) { /* Do nothing */ } } -static bool is_per_cpu_state_ok(void) +static bool is_per_cpu_state_ok( void ) { - bool ok = true; + bool ok = true; uint32_t n = rtems_scheduler_get_processor_maximum(); uint32_t i; - for (i = 0; i < n; ++i) { - const Thread_Control *thread = _Per_CPU_Get_by_index(i)->executing; - uint32_t count = 0; - uint32_t j; + for ( i = 0; i < n; ++i ) { + const Thread_Control *thread = _Per_CPU_Get_by_index( i )->executing; + uint32_t count = 0; + uint32_t j; - for (j = 0; j < n; ++j) { - const Per_CPU_Control *cpu = _Per_CPU_Get_by_index(j); - const Thread_Control *executing = cpu->executing; - const Thread_Control *heir = cpu->heir; + for ( j = 0; j < n; ++j ) { + const Per_CPU_Control *cpu = _Per_CPU_Get_by_index( j ); + const Thread_Control *executing = cpu->executing; + const Thread_Control *heir = cpu->heir; - if (i != j) { + if ( i != j ) { count += executing == thread; count += heir == thread; } else { @@ -109,80 +109,80 @@ static bool is_per_cpu_state_ok(void) ok = ok && _Thread_Get_CPU( heir ) == cpu; } - ok = ok && (count == 1); + ok = ok && ( count == 1 ); } return ok; } -static void test_scheduler_cross(void) +static void test_scheduler_cross( void ) { - bool per_cpu_state_ok; + bool per_cpu_state_ok; Per_CPU_Control *cpu_self; cpu_self = _Thread_Dispatch_disable(); - suspend(0); - suspend(1); - resume(0); - resume(1); + suspend( 0 ); + suspend( 1 ); + resume( 0 ); + resume( 1 ); per_cpu_state_ok = is_per_cpu_state_ok(); _Thread_Dispatch_enable( cpu_self ); - rtems_test_assert(per_cpu_state_ok); + rtems_test_assert( per_cpu_state_ok ); } -static void test_scheduler_move_heir(void) +static void test_scheduler_move_heir( void ) { - bool per_cpu_state_ok; + bool per_cpu_state_ok; Per_CPU_Control *cpu_self; cpu_self = _Thread_Dispatch_disable(); - suspend(2); - suspend(3); - suspend(0); - resume(2); - suspend(1); - resume(3); - resume(0); + suspend( 2 ); + suspend( 3 ); + suspend( 0 ); + resume( 2 ); + suspend( 1 ); + resume( 3 ); + resume( 0 ); per_cpu_state_ok = is_per_cpu_state_ok(); - resume(1); + resume( 1 ); _Thread_Dispatch_enable( cpu_self ); - rtems_test_assert(per_cpu_state_ok); + rtems_test_assert( per_cpu_state_ok ); } -static void test(void) +static void test( void ) { - rtems_event_set events; - rtems_status_code sc; + rtems_event_set events; + rtems_status_code sc; rtems_task_argument task_index; - task_ids[0] = rtems_task_self(); + task_ids[ 0 ] = rtems_task_self(); - for (task_index = 1; task_index < TASK_COUNT; ++task_index) { - rtems_id task_id; + for ( task_index = 1; task_index < TASK_COUNT; ++task_index ) { + rtems_id task_id; - sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), - FIRST_TASK_PRIORITY + task_index, - RTEMS_MINIMUM_STACK_SIZE, - RTEMS_DEFAULT_MODES, - RTEMS_DEFAULT_ATTRIBUTES, - &task_id - ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_create( + rtems_build_name( 'T', 'A', 'S', 'K' ), + FIRST_TASK_PRIORITY + task_index, + 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, task_index); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_id, task, task_index ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - task_ids[task_index] = task_id; + task_ids[ task_index ] = task_id; } sc = rtems_event_receive( @@ -191,14 +191,14 @@ static void test(void) RTEMS_NO_TIMEOUT, &events ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(events == SECOND_TASK_READY); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( events == SECOND_TASK_READY ); test_scheduler_cross(); test_scheduler_move_heir(); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -207,7 +207,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -220,9 +220,9 @@ static void Init(rtems_task_argument arg) /* We need a scheduler with lazy processor allocation for this test */ #define CONFIGURE_SCHEDULER_SIMPLE_SMP -#define CONFIGURE_INIT_TASK_PRIORITY FIRST_TASK_PRIORITY +#define CONFIGURE_INIT_TASK_PRIORITY FIRST_TASK_PRIORITY #define CONFIGURE_INIT_TASK_INITIAL_MODES RTEMS_DEFAULT_MODES -#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES +#define CONFIGURE_INIT_TASK_ATTRIBUTES RTEMS_DEFAULT_ATTRIBUTES #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpscheduler02/init.c b/testsuites/smptests/smpscheduler02/init.c index 5f7512baf1..31405dc8a6 100644 --- a/testsuites/smptests/smpscheduler02/init.c +++ b/testsuites/smptests/smpscheduler02/init.c @@ -39,11 +39,11 @@ const char rtems_test_name[] = "SMPSCHEDULER 2"; -#define SCHED_A rtems_build_name(' ', ' ', ' ', 'A') +#define SCHED_A rtems_build_name( ' ', ' ', ' ', 'A' ) -#define SCHED_B rtems_build_name(' ', ' ', ' ', 'B') +#define SCHED_B rtems_build_name( ' ', ' ', ' ', 'B' ) -#define SCHED_C rtems_build_name(' ', ' ', ' ', 'C') +#define SCHED_C rtems_build_name( ' ', ' ', ' ', 'C' ) static rtems_id main_task_id; @@ -53,376 +53,380 @@ static rtems_id imtx_id; static volatile bool ready; -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; rtems_status_code sc; - rtems_test_assert(rtems_scheduler_get_processor() == 1); - rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); + rtems_test_assert( sched_get_priority_min( SCHED_RR ) == 1 ); rtems_test_assert( - sched_get_priority_max(SCHED_RR) == PRIORITY_DEFAULT_MAXIMUM - 1 + sched_get_priority_max( SCHED_RR ) == PRIORITY_DEFAULT_MAXIMUM - 1 ); - sc = rtems_semaphore_obtain(cmtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_NOT_DEFINED); + sc = rtems_semaphore_obtain( cmtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_NOT_DEFINED ); - sc = rtems_event_transient_send(main_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( main_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_obtain(imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(imtx_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( imtx_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(main_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( main_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (1) { + while ( 1 ) { /* Do nothing */ } } -static void sticky_task(rtems_task_argument arg) +static void sticky_task( rtems_task_argument arg ) { rtems_status_code sc; - rtems_id mtx_id; + rtems_id mtx_id; (void) arg; - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); sc = rtems_semaphore_create( - rtems_build_name(' ', 'M', 'T', 'X'), + rtems_build_name( ' ', 'M', 'T', 'X' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_MULTIPROCESSOR_RESOURCE_SHARING, 2, &mtx_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_obtain(mtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( mtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); ready = true; - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_release(mtx_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( mtx_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(mtx_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( mtx_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(main_task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( main_task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (1) { + while ( 1 ) { /* Do nothing */ } } -static void test_scheduler_add_remove_processors(void) +static void test_scheduler_add_remove_processors( void ) { rtems_status_code sc; - rtems_id scheduler_a_id; - rtems_id scheduler_c_id; + rtems_id scheduler_a_id; + rtems_id scheduler_c_id; - sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_A, &scheduler_a_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_ident(SCHED_C, &scheduler_c_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_C, &scheduler_c_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_add_processor(scheduler_c_id, 62); - rtems_test_assert(sc == RTEMS_NOT_CONFIGURED); + sc = rtems_scheduler_add_processor( scheduler_c_id, 62 ); + rtems_test_assert( sc == RTEMS_NOT_CONFIGURED ); - sc = rtems_scheduler_add_processor(scheduler_c_id, 63); - rtems_test_assert(sc == RTEMS_INCORRECT_STATE); + sc = rtems_scheduler_add_processor( scheduler_c_id, 63 ); + rtems_test_assert( sc == RTEMS_INCORRECT_STATE ); - sc = rtems_scheduler_remove_processor(scheduler_c_id, 62); - rtems_test_assert(sc == RTEMS_INVALID_NUMBER); + sc = rtems_scheduler_remove_processor( scheduler_c_id, 62 ); + rtems_test_assert( sc == RTEMS_INVALID_NUMBER ); - sc = rtems_scheduler_remove_processor(scheduler_a_id, 0); - rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE); + sc = rtems_scheduler_remove_processor( scheduler_a_id, 0 ); + rtems_test_assert( sc == RTEMS_RESOURCE_IN_USE ); - if (rtems_scheduler_get_processor_maximum() > 1) { - rtems_id scheduler_id; - rtems_id scheduler_b_id; - rtems_id task_id; + if ( rtems_scheduler_get_processor_maximum() > 1 ) { + rtems_id scheduler_id; + rtems_id scheduler_b_id; + rtems_id task_id; cpu_set_t first_cpu; - sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_B, &scheduler_b_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_remove_processor(scheduler_b_id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_remove_processor( scheduler_b_id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_add_processor(scheduler_a_id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_add_processor( scheduler_a_id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - sc = rtems_scheduler_remove_processor(scheduler_a_id, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_remove_processor( scheduler_a_id, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - CPU_ZERO(&first_cpu); - CPU_SET(0, &first_cpu); + CPU_ZERO( &first_cpu ); + CPU_SET( 0, &first_cpu ); sc = rtems_scheduler_ident_by_processor_set( - sizeof(first_cpu), + sizeof( first_cpu ), &first_cpu, &scheduler_id ); - rtems_test_assert(sc == RTEMS_INCORRECT_STATE); + rtems_test_assert( sc == RTEMS_INCORRECT_STATE ); - sc = rtems_scheduler_add_processor(scheduler_a_id, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_add_processor( scheduler_a_id, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(task_id, sticky_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_id, sticky_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (!ready) { + while ( !ready ) { /* Wait */ } - sc = rtems_scheduler_remove_processor(scheduler_a_id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_remove_processor( scheduler_a_id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - sc = rtems_event_transient_send(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_add_processor(scheduler_b_id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_add_processor( scheduler_b_id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void test(void) +static void test( void ) { - rtems_status_code sc; - rtems_id task_id; - rtems_id scheduler_id; - rtems_id scheduler_a_id; - rtems_id scheduler_b_id; - rtems_id scheduler_c_id; + rtems_status_code sc; + rtems_id task_id; + rtems_id scheduler_id; + rtems_id scheduler_a_id; + rtems_id scheduler_b_id; + rtems_id scheduler_c_id; rtems_task_priority prio; - cpu_set_t cpuset; - cpu_set_t first_cpu; - cpu_set_t second_cpu; - cpu_set_t all_cpus; - cpu_set_t online_cpus; - uint32_t cpu_count; + cpu_set_t cpuset; + cpu_set_t first_cpu; + cpu_set_t second_cpu; + cpu_set_t all_cpus; + cpu_set_t online_cpus; + uint32_t cpu_count; - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); cpu_count = rtems_scheduler_get_processor_maximum(); main_task_id = rtems_task_self(); - CPU_ZERO(&first_cpu); - CPU_SET(0, &first_cpu); + CPU_ZERO( &first_cpu ); + CPU_SET( 0, &first_cpu ); - CPU_ZERO(&second_cpu); - CPU_SET(1, &second_cpu); + CPU_ZERO( &second_cpu ); + CPU_SET( 1, &second_cpu ); - CPU_FILL(&all_cpus); + CPU_FILL( &all_cpus ); - CPU_ZERO(&online_cpus); - CPU_SET(0, &online_cpus); + CPU_ZERO( &online_cpus ); + CPU_SET( 0, &online_cpus ); - if (cpu_count > 1) { - CPU_SET(1, &online_cpus); + if ( cpu_count > 1 ) { + CPU_SET( 1, &online_cpus ); } - sc = rtems_scheduler_ident(SCHED_A, &scheduler_a_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_A, &scheduler_a_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - if (cpu_count > 1) { - sc = rtems_scheduler_ident(SCHED_B, &scheduler_b_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(scheduler_a_id != scheduler_b_id); + if ( cpu_count > 1 ) { + sc = rtems_scheduler_ident( SCHED_B, &scheduler_b_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( scheduler_a_id != scheduler_b_id ); } - sc = rtems_scheduler_ident(SCHED_C, &scheduler_c_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_C, &scheduler_c_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name('C', 'M', 'T', 'X'), + rtems_build_name( 'C', 'M', 'T', 'X' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_PRIORITY_CEILING, 1, &cmtx_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_semaphore_create( - rtems_build_name('I', 'M', 'T', 'X'), + rtems_build_name( 'I', 'M', 'T', 'X' ), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_PRIORITY | RTEMS_INHERIT_PRIORITY, 1, &imtx_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); prio = 2; - sc = rtems_semaphore_set_priority(cmtx_id, scheduler_a_id, prio, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(prio == 1); + sc = rtems_semaphore_set_priority( cmtx_id, scheduler_a_id, prio, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( prio == 1 ); - if (cpu_count > 1) { + if ( cpu_count > 1 ) { prio = 1; - sc = rtems_semaphore_set_priority(cmtx_id, scheduler_b_id, prio, &prio); - rtems_test_assert(sc == RTEMS_NOT_DEFINED); - rtems_test_assert(prio == 1); + sc = rtems_semaphore_set_priority( cmtx_id, scheduler_b_id, prio, &prio ); + rtems_test_assert( sc == RTEMS_NOT_DEFINED ); + rtems_test_assert( prio == 1 ); } - CPU_ZERO(&cpuset); + CPU_ZERO( &cpuset ); sc = rtems_scheduler_get_processor_set( scheduler_a_id, - sizeof(cpuset), + sizeof( cpuset ), &cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(CPU_EQUAL(&cpuset, &first_cpu)); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( CPU_EQUAL( &cpuset, &first_cpu ) ); - if (cpu_count > 1) { - CPU_ZERO(&cpuset); + if ( cpu_count > 1 ) { + CPU_ZERO( &cpuset ); sc = rtems_scheduler_get_processor_set( scheduler_b_id, - sizeof(cpuset), + sizeof( cpuset ), &cpuset ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(CPU_EQUAL(&cpuset, &second_cpu)); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( CPU_EQUAL( &cpuset, &second_cpu ) ); } sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_get_scheduler(task_id, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(scheduler_id == scheduler_a_id); + sc = rtems_task_get_scheduler( task_id, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( scheduler_id == scheduler_a_id ); - CPU_ZERO(&cpuset); - sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(CPU_EQUAL(&cpuset, &online_cpus)); + CPU_ZERO( &cpuset ); + sc = rtems_task_get_affinity( task_id, sizeof( cpuset ), &cpuset ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( CPU_EQUAL( &cpuset, &online_cpus ) ); - rtems_test_assert(sched_get_priority_min(SCHED_RR) == 1); - rtems_test_assert(sched_get_priority_max(SCHED_RR) == 254); + rtems_test_assert( sched_get_priority_min( SCHED_RR ) == 1 ); + rtems_test_assert( sched_get_priority_max( SCHED_RR ) == 254 ); - sc = rtems_task_set_scheduler(task_id, scheduler_c_id, 1); - rtems_test_assert(sc == RTEMS_UNSATISFIED); + sc = rtems_task_set_scheduler( task_id, scheduler_c_id, 1 ); + rtems_test_assert( sc == RTEMS_UNSATISFIED ); - sc = rtems_task_set_scheduler(task_id, scheduler_c_id + 1, 1); - rtems_test_assert(sc == RTEMS_INVALID_ID); + sc = rtems_task_set_scheduler( task_id, scheduler_c_id + 1, 1 ); + rtems_test_assert( sc == RTEMS_INVALID_ID ); - if (cpu_count > 1) { - sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + if ( cpu_count > 1 ) { + sc = rtems_task_set_scheduler( task_id, scheduler_b_id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_get_scheduler(task_id, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(scheduler_id == scheduler_b_id); + sc = rtems_task_get_scheduler( task_id, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( scheduler_id == scheduler_b_id ); - CPU_ZERO(&cpuset); - sc = rtems_task_get_affinity(task_id, sizeof(cpuset), &cpuset); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(CPU_EQUAL(&cpuset, &online_cpus)); + CPU_ZERO( &cpuset ); + sc = rtems_task_get_affinity( task_id, sizeof( cpuset ), &cpuset ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( CPU_EQUAL( &cpuset, &online_cpus ) ); - sc = rtems_task_set_affinity(task_id, sizeof(all_cpus), &all_cpus); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( task_id, sizeof( all_cpus ), &all_cpus ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_affinity(task_id, sizeof(first_cpu), &first_cpu); - rtems_test_assert(sc == RTEMS_INVALID_NUMBER); + sc = rtems_task_set_affinity( task_id, sizeof( first_cpu ), &first_cpu ); + rtems_test_assert( sc == RTEMS_INVALID_NUMBER ); - sc = rtems_task_get_scheduler(task_id, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(scheduler_id == scheduler_b_id); + sc = rtems_task_get_scheduler( task_id, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( scheduler_id == scheduler_b_id ); - sc = rtems_task_set_affinity(task_id, sizeof(online_cpus), &online_cpus); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( + task_id, + sizeof( online_cpus ), + &online_cpus + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_affinity(task_id, sizeof(second_cpu), &second_cpu); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( task_id, sizeof( second_cpu ), &second_cpu ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(task_id, scheduler_a_id, 1); - rtems_test_assert(sc == RTEMS_UNSATISFIED); + sc = rtems_task_set_scheduler( task_id, scheduler_a_id, 1 ); + rtems_test_assert( sc == RTEMS_UNSATISFIED ); - sc = rtems_task_get_scheduler(task_id, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(scheduler_id == scheduler_b_id); + sc = rtems_task_get_scheduler( task_id, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( scheduler_id == scheduler_b_id ); - sc = rtems_semaphore_obtain(imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_obtain( imtx_id, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(task_id, scheduler_b_id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( task_id, scheduler_b_id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(task_id, task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_id, task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* Ensure that the other task waits for the mutex owned by us */ - sc = rtems_task_wake_after(2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 2 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(RTEMS_SELF, scheduler_b_id, 1); - rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE); + sc = rtems_task_set_scheduler( RTEMS_SELF, scheduler_b_id, 1 ); + rtems_test_assert( sc == RTEMS_RESOURCE_IN_USE ); - sc = rtems_semaphore_release(imtx_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_release( imtx_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(cmtx_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( cmtx_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_semaphore_delete(imtx_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_semaphore_delete( imtx_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); test_scheduler_add_remove_processors(); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -430,20 +434,20 @@ static void Init(rtems_task_argument arg) TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); test(); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS 2 +#define CONFIGURE_MAXIMUM_TASKS 2 #define CONFIGURE_MAXIMUM_SEMAPHORES 2 /* Lets see when the first RTEMS system hits this limit */ @@ -455,52 +459,52 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_PRIORITY_SMP(a, 256); +RTEMS_SCHEDULER_PRIORITY_SMP( a, 256 ); -RTEMS_SCHEDULER_EDF_SMP(b); +RTEMS_SCHEDULER_EDF_SMP( b ); -RTEMS_SCHEDULER_SIMPLE_SMP(c); +RTEMS_SCHEDULER_SIMPLE_SMP( c ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_PRIORITY_SMP(a, SCHED_A), \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(b, SCHED_B), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(c, SCHED_C) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_PRIORITY_SMP( a, SCHED_A ), \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( b, SCHED_B ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( c, SCHED_C ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ - RTEMS_SCHEDULER_ASSIGN(2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN_NO_SCHEDULER, \ + RTEMS_SCHEDULER_ASSIGN( 2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpscheduler03/init.c b/testsuites/smptests/smpscheduler03/init.c index 39dea836e1..e9ead44e04 100644 --- a/testsuites/smptests/smpscheduler03/init.c +++ b/testsuites/smptests/smpscheduler03/init.c @@ -32,7 +32,7 @@ #include #include -void Init(rtems_task_argument arg); +void Init( rtems_task_argument arg ); const char rtems_test_name[] = "SMPSCHEDULER 3"; @@ -47,13 +47,16 @@ const char rtems_test_name[] = "SMPSCHEDULER 3"; #include -RTEMS_SCHEDULER_PRIORITY_SMP(a, CONFIGURE_MAXIMUM_PRIORITY + 1); +RTEMS_SCHEDULER_PRIORITY_SMP( a, CONFIGURE_MAXIMUM_PRIORITY + 1 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_PRIORITY_SMP(a, rtems_build_name('T', 'E', 'S', 'T')) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_PRIORITY_SMP( \ + a, \ + rtems_build_name( 'T', 'E', 'S', 'T' ) \ + ) #define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) #define CONFIGURE_MAXIMUM_TASKS 3 diff --git a/testsuites/smptests/smpscheduler03/test.c b/testsuites/smptests/smpscheduler03/test.c index 75f5a3c310..8b131e7eae 100644 --- a/testsuites/smptests/smpscheduler03/test.c +++ b/testsuites/smptests/smpscheduler03/test.c @@ -36,28 +36,30 @@ #include "tmacros.h" -void Init(rtems_task_argument arg); +void Init( rtems_task_argument arg ); -static Scheduler_SMP_Node *get_scheduler_node(Thread_Control *thread) +static Scheduler_SMP_Node *get_scheduler_node( Thread_Control *thread ) { - return _Scheduler_SMP_Node_downcast(_Thread_Scheduler_get_home_node(thread)); + return _Scheduler_SMP_Node_downcast( + _Thread_Scheduler_get_home_node( thread ) + ); } static void apply_priority( - Thread_Control *thread, - Priority_Control new_priority, - Priority_Group_order priority_group_order, + Thread_Control *thread, + Priority_Control new_priority, + Priority_Group_order priority_group_order, Thread_queue_Context *queue_context ) { const Scheduler_Control *scheduler; - scheduler = _Thread_Scheduler_get_home(thread); - new_priority = _Scheduler_Map_priority(scheduler, new_priority); + scheduler = _Thread_Scheduler_get_home( thread ); + new_priority = _Scheduler_Map_priority( scheduler, new_priority ); - _Thread_queue_Context_initialize(queue_context); - _Thread_queue_Context_clear_priority_updates(queue_context); - _Thread_Wait_acquire(thread, queue_context); + _Thread_queue_Context_initialize( queue_context ); + _Thread_queue_Context_clear_priority_updates( queue_context ); + _Thread_Wait_acquire( thread, queue_context ); _Thread_Priority_change( thread, &thread->Real_priority, @@ -65,67 +67,67 @@ static void apply_priority( priority_group_order, queue_context ); - _Thread_Wait_release(thread, queue_context); + _Thread_Wait_release( thread, queue_context ); } static void change_priority( - Thread_Control *thread, - Priority_Control new_priority, + Thread_Control *thread, + Priority_Control new_priority, Priority_Group_order priority_group_order ) { Thread_queue_Context queue_context; - apply_priority(thread, new_priority, priority_group_order, &queue_context); - _Thread_Priority_update(&queue_context); + apply_priority( thread, new_priority, priority_group_order, &queue_context ); + _Thread_Priority_update( &queue_context ); } -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { (void) arg; - rtems_test_assert(0); + rtems_test_assert( 0 ); } -static rtems_id start_task(rtems_task_priority prio) +static rtems_id start_task( rtems_task_priority prio ) { rtems_status_code sc; - rtems_id task_id; + rtems_id task_id; sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), prio, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(task_id, task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_id, task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); return task_id; } -static Thread_Control *get_thread_by_id(rtems_id task_id) +static Thread_Control *get_thread_by_id( rtems_id task_id ) { ISR_lock_Context lock_context; - Thread_Control *thread; + Thread_Control *thread; - thread = _Thread_Get(task_id, &lock_context); - rtems_test_assert(thread != NULL); - _ISR_lock_ISR_enable(&lock_context); + thread = _Thread_Get( task_id, &lock_context ); + rtems_test_assert( thread != NULL ); + _ISR_lock_ISR_enable( &lock_context ); return thread; } static void test_case_change_priority( - Thread_Control *executing, - Scheduler_SMP_Node *executing_node, + Thread_Control *executing, + Scheduler_SMP_Node *executing_node, Scheduler_SMP_Node_state start_state, - Priority_Control prio, - Priority_Group_order priority_group_order, + Priority_Control prio, + Priority_Group_order priority_group_order, Scheduler_SMP_Node_state new_state ) { @@ -133,92 +135,92 @@ static void test_case_change_priority( cpu_self = _Thread_Dispatch_disable(); - switch (start_state) { + switch ( start_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: - change_priority(executing, 1, PRIORITY_GROUP_FIRST); + change_priority( executing, 1, PRIORITY_GROUP_FIRST ); break; case SCHEDULER_SMP_NODE_READY: - change_priority(executing, 4, PRIORITY_GROUP_FIRST); + change_priority( executing, 4, PRIORITY_GROUP_FIRST ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } - rtems_test_assert(executing_node->state == start_state); + rtems_test_assert( executing_node->state == start_state ); - change_priority(executing, prio, priority_group_order); - rtems_test_assert(executing_node->state == new_state); + change_priority( executing, prio, priority_group_order ); + rtems_test_assert( executing_node->state == new_state ); - change_priority(executing, 1, PRIORITY_GROUP_FIRST); - rtems_test_assert(executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED); + change_priority( executing, 1, PRIORITY_GROUP_FIRST ); + rtems_test_assert( executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED ); _Thread_Dispatch_enable( cpu_self ); } -static const Scheduler_SMP_Node_state states[2] = { +static const Scheduler_SMP_Node_state states[ 2 ] = { SCHEDULER_SMP_NODE_SCHEDULED, SCHEDULER_SMP_NODE_READY }; -static const Priority_Control priorities[2] = { 2, 5 }; +static const Priority_Control priorities[ 2 ] = { 2, 5 }; -static const Priority_Group_order priority_group_order[2] = { +static const Priority_Group_order priority_group_order[ 2 ] = { PRIORITY_GROUP_FIRST, PRIORITY_GROUP_LAST }; -static void test_change_priority(void) +static void test_change_priority( void ) { - rtems_status_code sc; - rtems_id task_id; - Thread_Control *executing; + rtems_status_code sc; + rtems_id task_id; + Thread_Control *executing; Scheduler_SMP_Node *executing_node; - size_t i; - size_t j; - size_t k; + size_t i; + size_t j; + size_t k; - task_id = start_task(3); + task_id = start_task( 3 ); executing = _Thread_Get_executing(); - executing_node = get_scheduler_node(executing); + executing_node = get_scheduler_node( executing ); - for (i = 0; i < RTEMS_ARRAY_SIZE(states); ++i) { - for (j = 0; j < RTEMS_ARRAY_SIZE(priorities); ++j) { - for (k = 0; k < RTEMS_ARRAY_SIZE(priority_group_order); ++k) { + for ( i = 0; i < RTEMS_ARRAY_SIZE( states ); ++i ) { + for ( j = 0; j < RTEMS_ARRAY_SIZE( priorities ); ++j ) { + for ( k = 0; k < RTEMS_ARRAY_SIZE( priority_group_order ); ++k ) { test_case_change_priority( executing, executing_node, - states[i], - priorities[j], - priority_group_order[k], - states[j] + states[ i ], + priorities[ j ], + priority_group_order[ k ], + states[ j ] ); } } } - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void update_priority_op( - Thread_Control *thread, - Scheduler_SMP_Node *scheduler_node, - Priority_Control new_priority, + Thread_Control *thread, + Scheduler_SMP_Node *scheduler_node, + Priority_Control new_priority, Priority_Group_order priority_group_order ) { const Scheduler_Control *scheduler; - ISR_lock_Context state_lock_context; - ISR_lock_Context scheduler_lock_context; - Thread_queue_Context queue_context; + ISR_lock_Context state_lock_context; + ISR_lock_Context scheduler_lock_context; + Thread_queue_Context queue_context; - apply_priority(thread, new_priority, priority_group_order, &queue_context); + apply_priority( thread, new_priority, priority_group_order, &queue_context ); _Thread_State_acquire( thread, &state_lock_context ); scheduler = _Thread_Scheduler_get_home( thread ); _Scheduler_Acquire_critical( scheduler, &scheduler_lock_context ); - (*scheduler->Operations.update_priority)( + ( *scheduler->Operations.update_priority )( scheduler, thread, &scheduler_node->Base @@ -229,12 +231,12 @@ static void update_priority_op( } static void test_case_update_priority_op( - Thread_Control *executing, - Scheduler_SMP_Node *executing_node, - Thread_Control *other, + Thread_Control *executing, + Scheduler_SMP_Node *executing_node, + Thread_Control *other, Scheduler_SMP_Node_state start_state, - Priority_Control prio, - Priority_Group_order priority_group_order, + Priority_Control prio, + Priority_Group_order priority_group_order, Scheduler_SMP_Node_state new_state ) { @@ -242,106 +244,102 @@ static void test_case_update_priority_op( cpu_self = _Thread_Dispatch_disable(); - switch (start_state) { + switch ( start_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: - change_priority(executing, 1, PRIORITY_GROUP_FIRST); + change_priority( executing, 1, PRIORITY_GROUP_FIRST ); break; case SCHEDULER_SMP_NODE_READY: - change_priority(executing, 4, PRIORITY_GROUP_FIRST); + change_priority( executing, 4, PRIORITY_GROUP_FIRST ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } - rtems_test_assert(executing_node->state == start_state); + rtems_test_assert( executing_node->state == start_state ); - update_priority_op(executing, executing_node, prio, priority_group_order); - rtems_test_assert(executing_node->state == new_state); + update_priority_op( executing, executing_node, prio, priority_group_order ); + rtems_test_assert( executing_node->state == new_state ); - if (start_state != new_state) { - switch (start_state) { + if ( start_state != new_state ) { + switch ( start_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: - rtems_test_assert(cpu_self->heir == other); + rtems_test_assert( cpu_self->heir == other ); break; case SCHEDULER_SMP_NODE_READY: - rtems_test_assert(cpu_self->heir == executing); + rtems_test_assert( cpu_self->heir == executing ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } } - change_priority(executing, 1, PRIORITY_GROUP_FIRST); - rtems_test_assert(executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED); + change_priority( executing, 1, PRIORITY_GROUP_FIRST ); + rtems_test_assert( executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED ); _Thread_Dispatch_enable( cpu_self ); } -static void test_update_priority_op(void) +static void test_update_priority_op( void ) { - rtems_status_code sc; - rtems_id task_id; - Thread_Control *executing; + rtems_status_code sc; + rtems_id task_id; + Thread_Control *executing; Scheduler_SMP_Node *executing_node; - Thread_Control *other; - size_t i; - size_t j; - size_t k; + Thread_Control *other; + size_t i; + size_t j; + size_t k; - task_id = start_task(3); + task_id = start_task( 3 ); executing = _Thread_Get_executing(); - executing_node = get_scheduler_node(executing); + executing_node = get_scheduler_node( executing ); - other = get_thread_by_id(task_id); + other = get_thread_by_id( task_id ); - for (i = 0; i < RTEMS_ARRAY_SIZE(states); ++i) { - for (j = 0; j < RTEMS_ARRAY_SIZE(priorities); ++j) { - for (k = 0; k < RTEMS_ARRAY_SIZE(priority_group_order); ++k) { + for ( i = 0; i < RTEMS_ARRAY_SIZE( states ); ++i ) { + for ( j = 0; j < RTEMS_ARRAY_SIZE( priorities ); ++j ) { + for ( k = 0; k < RTEMS_ARRAY_SIZE( priority_group_order ); ++k ) { test_case_update_priority_op( executing, executing_node, other, - states[i], - priorities[j], - priority_group_order[k], - states[j] + states[ i ], + priorities[ j ], + priority_group_order[ k ], + states[ j ] ); } } } - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void yield_op( - Thread_Control *thread, + Thread_Control *thread, Scheduler_SMP_Node *scheduler_node ) { const Scheduler_Control *scheduler; - ISR_lock_Context state_lock_context; - ISR_lock_Context scheduler_lock_context; + ISR_lock_Context state_lock_context; + ISR_lock_Context scheduler_lock_context; _Thread_State_acquire( thread, &state_lock_context ); scheduler = _Thread_Scheduler_get_home( thread ); _Scheduler_Acquire_critical( scheduler, &scheduler_lock_context ); - (*scheduler->Operations.yield)( - scheduler, - thread, - &scheduler_node->Base - ); + ( *scheduler->Operations.yield )( scheduler, thread, &scheduler_node->Base ); _Scheduler_Release_critical( scheduler, &scheduler_lock_context ); _Thread_State_release( thread, &state_lock_context ); } static void test_case_yield_op( - Thread_Control *executing, - Scheduler_SMP_Node *executing_node, - Thread_Control *other, + Thread_Control *executing, + Scheduler_SMP_Node *executing_node, + Thread_Control *other, Scheduler_SMP_Node_state start_state, Scheduler_SMP_Node_state new_state ) @@ -350,133 +348,133 @@ static void test_case_yield_op( cpu_self = _Thread_Dispatch_disable(); - change_priority(executing, 4, PRIORITY_GROUP_LAST); - change_priority(other, 4, PRIORITY_GROUP_LAST); + change_priority( executing, 4, PRIORITY_GROUP_LAST ); + change_priority( other, 4, PRIORITY_GROUP_LAST ); - switch (start_state) { + switch ( start_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: - switch (new_state) { + switch ( new_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: - change_priority(executing, 2, PRIORITY_GROUP_LAST); - change_priority(other, 3, PRIORITY_GROUP_LAST); + change_priority( executing, 2, PRIORITY_GROUP_LAST ); + change_priority( other, 3, PRIORITY_GROUP_LAST ); break; case SCHEDULER_SMP_NODE_READY: - change_priority(executing, 2, PRIORITY_GROUP_LAST); - change_priority(other, 2, PRIORITY_GROUP_LAST); + change_priority( executing, 2, PRIORITY_GROUP_LAST ); + change_priority( other, 2, PRIORITY_GROUP_LAST ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } break; case SCHEDULER_SMP_NODE_READY: - switch (new_state) { + switch ( new_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; case SCHEDULER_SMP_NODE_READY: - change_priority(executing, 3, PRIORITY_GROUP_LAST); - change_priority(other, 2, PRIORITY_GROUP_LAST); + change_priority( executing, 3, PRIORITY_GROUP_LAST ); + change_priority( other, 2, PRIORITY_GROUP_LAST ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } - rtems_test_assert(executing_node->state == start_state); + rtems_test_assert( executing_node->state == start_state ); - yield_op(executing, executing_node); - rtems_test_assert(executing_node->state == new_state); + yield_op( executing, executing_node ); + rtems_test_assert( executing_node->state == new_state ); - switch (new_state) { + switch ( new_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: case SCHEDULER_SMP_NODE_READY: break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } - change_priority(executing, 1, PRIORITY_GROUP_FIRST); - rtems_test_assert(executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED); + change_priority( executing, 1, PRIORITY_GROUP_FIRST ); + rtems_test_assert( executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED ); _Thread_Dispatch_enable( cpu_self ); } -static void test_yield_op(void) +static void test_yield_op( void ) { - rtems_status_code sc; - rtems_id task_id; - Thread_Control *executing; + rtems_status_code sc; + rtems_id task_id; + Thread_Control *executing; Scheduler_SMP_Node *executing_node; - Thread_Control *other; - size_t i; - size_t j; + Thread_Control *other; + size_t i; + size_t j; - task_id = start_task(2); + task_id = start_task( 2 ); executing = _Thread_Get_executing(); - executing_node = get_scheduler_node(executing); + executing_node = get_scheduler_node( executing ); - other = get_thread_by_id(task_id); + other = get_thread_by_id( task_id ); - for (i = 0; i < RTEMS_ARRAY_SIZE(states); ++i) { - for (j = 0; j < RTEMS_ARRAY_SIZE(states); ++j) { + for ( i = 0; i < RTEMS_ARRAY_SIZE( states ); ++i ) { + for ( j = 0; j < RTEMS_ARRAY_SIZE( states ); ++j ) { if ( - states[i] != SCHEDULER_SMP_NODE_READY - || states[j] != SCHEDULER_SMP_NODE_SCHEDULED + states[ i ] != SCHEDULER_SMP_NODE_READY || + states[ j ] != SCHEDULER_SMP_NODE_SCHEDULED ) { test_case_yield_op( executing, executing_node, other, - states[i], - states[j] + states[ i ], + states[ j ] ); } } } - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } static void block_op( - Thread_Control *thread, + Thread_Control *thread, Scheduler_SMP_Node *scheduler_node ) { const Scheduler_Control *scheduler; - ISR_lock_Context state_lock_context; - ISR_lock_Context scheduler_lock_context; + ISR_lock_Context state_lock_context; + ISR_lock_Context scheduler_lock_context; _Thread_State_acquire( thread, &state_lock_context ); scheduler = _Thread_Scheduler_get_home( thread ); _Scheduler_Acquire_critical( scheduler, &scheduler_lock_context ); - (*scheduler->Operations.block)(scheduler, thread, &scheduler_node->Base); + ( *scheduler->Operations.block )( scheduler, thread, &scheduler_node->Base ); _Scheduler_Release_critical( scheduler, &scheduler_lock_context ); _Thread_State_release( thread, &state_lock_context ); } static void unblock_op( - Thread_Control *thread, + Thread_Control *thread, Scheduler_SMP_Node *scheduler_node ) { const Scheduler_Control *scheduler; - ISR_lock_Context state_lock_context; - ISR_lock_Context scheduler_lock_context; + ISR_lock_Context state_lock_context; + ISR_lock_Context scheduler_lock_context; _Thread_State_acquire( thread, &state_lock_context ); scheduler = _Thread_Scheduler_get_home( thread ); _Scheduler_Acquire_critical( scheduler, &scheduler_lock_context ); - (*scheduler->Operations.unblock)( + ( *scheduler->Operations.unblock )( scheduler, thread, &scheduler_node->Base @@ -487,9 +485,9 @@ static void unblock_op( } static void test_case_unblock_op( - Thread_Control *executing, - Scheduler_SMP_Node *executing_node, - Thread_Control *other, + Thread_Control *executing, + Scheduler_SMP_Node *executing_node, + Thread_Control *other, Scheduler_SMP_Node_state new_state ) { @@ -499,101 +497,98 @@ static void test_case_unblock_op( cpu_self = _Thread_Dispatch_disable(); - switch (new_state) { + switch ( new_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: - change_priority(executing, 2, PRIORITY_GROUP_LAST); - rtems_test_assert(executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED); + change_priority( executing, 2, PRIORITY_GROUP_LAST ); + rtems_test_assert( + executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED + ); break; case SCHEDULER_SMP_NODE_READY: - change_priority(executing, 4, PRIORITY_GROUP_LAST); - rtems_test_assert(executing_node->state == SCHEDULER_SMP_NODE_READY); + change_priority( executing, 4, PRIORITY_GROUP_LAST ); + rtems_test_assert( executing_node->state == SCHEDULER_SMP_NODE_READY ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } - block_op(executing, executing_node); - rtems_test_assert(executing_node->state == SCHEDULER_SMP_NODE_BLOCKED); + block_op( executing, executing_node ); + rtems_test_assert( executing_node->state == SCHEDULER_SMP_NODE_BLOCKED ); - unblock_op(executing, executing_node); - rtems_test_assert(executing_node->state == new_state); + unblock_op( executing, executing_node ); + rtems_test_assert( executing_node->state == new_state ); - switch (new_state) { + switch ( new_state ) { case SCHEDULER_SMP_NODE_SCHEDULED: case SCHEDULER_SMP_NODE_READY: break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); break; } - change_priority(executing, 1, PRIORITY_GROUP_FIRST); - rtems_test_assert(executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED); + change_priority( executing, 1, PRIORITY_GROUP_FIRST ); + rtems_test_assert( executing_node->state == SCHEDULER_SMP_NODE_SCHEDULED ); _Thread_Dispatch_enable( cpu_self ); } -static void test_unblock_op(void) +static void test_unblock_op( void ) { - rtems_status_code sc; - rtems_id task_id; - Thread_Control *executing; + rtems_status_code sc; + rtems_id task_id; + Thread_Control *executing; Scheduler_SMP_Node *executing_node; - Thread_Control *other; - size_t i; + Thread_Control *other; + size_t i; - task_id = start_task(3); + task_id = start_task( 3 ); executing = _Thread_Get_executing(); - executing_node = get_scheduler_node(executing); + executing_node = get_scheduler_node( executing ); - other = get_thread_by_id(task_id); + other = get_thread_by_id( task_id ); - for (i = 0; i < RTEMS_ARRAY_SIZE(states); ++i) { - test_case_unblock_op( - executing, - executing_node, - other, - states[i] - ); + for ( i = 0; i < RTEMS_ARRAY_SIZE( states ); ++i ) { + test_case_unblock_op( executing, executing_node, other, states[ i ] ); } - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -void Init(rtems_task_argument arg) +void Init( rtems_task_argument arg ) { (void) arg; rtems_resource_snapshot snapshot; - rtems_status_code sc; - rtems_id task_id; + rtems_status_code sc; + rtems_id task_id; TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &task_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); test_change_priority(); test_update_priority_op(); test_yield_op(); test_unblock_op(); - sc = rtems_task_delete(task_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( task_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } diff --git a/testsuites/smptests/smpscheduler04/init.c b/testsuites/smptests/smpscheduler04/init.c index cd4d78b125..d6ac6aeb68 100644 --- a/testsuites/smptests/smpscheduler04/init.c +++ b/testsuites/smptests/smpscheduler04/init.c @@ -47,128 +47,128 @@ const char rtems_test_name[] = "SMPSCHEDULER 4"; #define PRIO_SCHEDULER 3 typedef struct { - rtems_id migration_task; - rtems_id scheduler_task; - rtems_id scheduler_ids[CPU_COUNT]; - uint32_t migration_counter RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); - uint32_t scheduler_counter RTEMS_ALIGNED(CPU_CACHE_LINE_BYTES); + rtems_id migration_task; + rtems_id scheduler_task; + rtems_id scheduler_ids[ CPU_COUNT ]; + uint32_t migration_counter RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); + uint32_t scheduler_counter RTEMS_ALIGNED( CPU_CACHE_LINE_BYTES ); } test_context; static test_context test_instance; -static void migration_task(rtems_task_argument arg) +static void migration_task( rtems_task_argument arg ) { (void) arg; test_context *ctx = (test_context *) arg; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t cpu_index = rtems_scheduler_get_processor(); + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t cpu_index = rtems_scheduler_get_processor(); - while (true) { + while ( true ) { rtems_status_code sc; - cpu_index = (cpu_index + 1) % cpu_count; + cpu_index = ( cpu_index + 1 ) % cpu_count; sc = rtems_task_set_scheduler( RTEMS_SELF, - ctx->scheduler_ids[cpu_index], + ctx->scheduler_ids[ cpu_index ], PRIO_MIGRATION ); - if (sc == RTEMS_UNSATISFIED) { + if ( sc == RTEMS_UNSATISFIED ) { continue; } - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(cpu_index == rtems_scheduler_get_processor()); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( cpu_index == rtems_scheduler_get_processor() ); ++ctx->migration_counter; } } -static void scheduler_task(rtems_task_argument arg) +static void scheduler_task( rtems_task_argument arg ) { test_context *ctx = (test_context *) arg; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t cpu_index = rtems_scheduler_get_processor(); + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t cpu_index = rtems_scheduler_get_processor(); - while (true) { + while ( true ) { rtems_status_code sc; - cpu_index = (cpu_index - 1) % cpu_count; + cpu_index = ( cpu_index - 1 ) % cpu_count; - if (cpu_index == 0) { + if ( cpu_index == 0 ) { cpu_index = 1; } do { sc = rtems_scheduler_remove_processor( - ctx->scheduler_ids[cpu_index], + ctx->scheduler_ids[ cpu_index ], cpu_index ); - } while (sc == RTEMS_RESOURCE_IN_USE); + } while ( sc == RTEMS_RESOURCE_IN_USE ); sc = rtems_scheduler_add_processor( - ctx->scheduler_ids[cpu_index], + ctx->scheduler_ids[ cpu_index ], cpu_index ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); ++ctx->scheduler_counter; } } -static void test(test_context *ctx) +static void test( test_context *ctx ) { rtems_status_code sc; - uint32_t i; + uint32_t i; - for (i = 0; i < rtems_scheduler_get_processor_maximum(); ++i) { - sc = rtems_scheduler_ident(i, &ctx->scheduler_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( i = 0; i < rtems_scheduler_get_processor_maximum(); ++i ) { + sc = rtems_scheduler_ident( i, &ctx->scheduler_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } sc = rtems_task_create( - rtems_build_name('M', 'I', 'G', 'R'), + rtems_build_name( 'M', 'I', 'G', 'R' ), PRIO_MIGRATION, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->migration_task ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_start( ctx->migration_task, migration_task, (rtems_task_argument) ctx ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('S', 'C', 'H', 'D'), + rtems_build_name( 'S', 'C', 'H', 'D' ), PRIO_SCHEDULER, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->scheduler_task ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_start( ctx->scheduler_task, scheduler_task, (rtems_task_argument) ctx ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_wake_after(10 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 10 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->migration_task); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->migration_task ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->scheduler_task); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->scheduler_task ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); printf( "migration counter = %" PRIu32 "\n" @@ -178,18 +178,18 @@ static void test(test_context *ctx) ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; rtems_resource_snapshot snapshot; TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); - test(&test_instance); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_resource_snapshot_take( &snapshot ); + test( &test_instance ); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -203,106 +203,106 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_SIMPLE_SMP(0); -RTEMS_SCHEDULER_SIMPLE_SMP(1); -RTEMS_SCHEDULER_SIMPLE_SMP(2); -RTEMS_SCHEDULER_SIMPLE_SMP(3); -RTEMS_SCHEDULER_SIMPLE_SMP(4); -RTEMS_SCHEDULER_SIMPLE_SMP(5); -RTEMS_SCHEDULER_SIMPLE_SMP(6); -RTEMS_SCHEDULER_SIMPLE_SMP(7); -RTEMS_SCHEDULER_SIMPLE_SMP(8); -RTEMS_SCHEDULER_SIMPLE_SMP(9); -RTEMS_SCHEDULER_SIMPLE_SMP(10); -RTEMS_SCHEDULER_SIMPLE_SMP(11); -RTEMS_SCHEDULER_SIMPLE_SMP(12); -RTEMS_SCHEDULER_SIMPLE_SMP(13); -RTEMS_SCHEDULER_SIMPLE_SMP(14); -RTEMS_SCHEDULER_SIMPLE_SMP(15); -RTEMS_SCHEDULER_SIMPLE_SMP(16); -RTEMS_SCHEDULER_SIMPLE_SMP(17); -RTEMS_SCHEDULER_SIMPLE_SMP(18); -RTEMS_SCHEDULER_SIMPLE_SMP(19); -RTEMS_SCHEDULER_SIMPLE_SMP(20); -RTEMS_SCHEDULER_SIMPLE_SMP(21); -RTEMS_SCHEDULER_SIMPLE_SMP(22); -RTEMS_SCHEDULER_SIMPLE_SMP(23); -RTEMS_SCHEDULER_SIMPLE_SMP(24); -RTEMS_SCHEDULER_SIMPLE_SMP(25); -RTEMS_SCHEDULER_SIMPLE_SMP(26); -RTEMS_SCHEDULER_SIMPLE_SMP(27); -RTEMS_SCHEDULER_SIMPLE_SMP(28); -RTEMS_SCHEDULER_SIMPLE_SMP(29); -RTEMS_SCHEDULER_SIMPLE_SMP(30); -RTEMS_SCHEDULER_SIMPLE_SMP(31); +RTEMS_SCHEDULER_SIMPLE_SMP( 0 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 1 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 2 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 3 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 4 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 5 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 6 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 7 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 8 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 9 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 10 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 11 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 12 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 13 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 14 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 15 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 16 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 17 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 18 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 19 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 20 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 21 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 22 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 23 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 24 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 25 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 26 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 27 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 28 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 29 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 30 ); +RTEMS_SCHEDULER_SIMPLE_SMP( 31 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(0, 0), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(1, 1), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(2, 2), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(3, 3), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(4, 4), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(5, 5), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(6, 6), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(7, 7), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(8, 8), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(9, 9), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(10, 10), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(11, 11), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(12, 12), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(13, 13), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(14, 14), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(15, 15), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(16, 16), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(17, 17), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(18, 18), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(19, 19), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(20, 20), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(21, 21), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(22, 22), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(23, 23), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(24, 24), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(25, 25), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(26, 26), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(27, 27), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(28, 28), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(29, 29), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(30, 30), \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(31, 31) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 0, 0 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 1, 1 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 2, 2 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 3, 3 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 4, 4 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 5, 5 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 6, 6 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 7, 7 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 8, 8 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 9, 9 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 10, 10 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 11, 11 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 12, 12 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 13, 13 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 14, 14 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 15, 15 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 16, 16 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 17, 17 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 18, 18 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 19, 19 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 20, 20 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 21, 21 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 22, 22 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 23, 23 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 24, 24 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 25, 25 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 26, 26 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 27, 27 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 28, 28 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 29, 29 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 30, 30 ), \ + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( 31, 31 ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(17, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(18, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(19, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(20, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(21, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(22, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(23, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(24, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(25, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(26, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(27, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(28, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(29, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(30, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(31, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 2, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 3, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 4, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 5, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 6, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 7, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 8, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 9, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 10, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 11, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 12, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 13, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 14, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 15, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 16, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 17, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 18, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 19, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 20, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 21, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 22, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 23, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 24, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 25, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 26, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 27, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 28, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 29, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 30, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 31, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION diff --git a/testsuites/smptests/smpscheduler05/init.c b/testsuites/smptests/smpscheduler05/init.c index 733e9924b0..601d1aafad 100644 --- a/testsuites/smptests/smpscheduler05/init.c +++ b/testsuites/smptests/smpscheduler05/init.c @@ -32,7 +32,7 @@ #include #include -void Init(rtems_task_argument arg); +void Init( rtems_task_argument arg ); const char rtems_test_name[] = "SMPSCHEDULER 5"; @@ -45,13 +45,13 @@ const char rtems_test_name[] = "SMPSCHEDULER 5"; #include -RTEMS_SCHEDULER_SIMPLE_SMP(a); +RTEMS_SCHEDULER_SIMPLE_SMP( a ); #define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_SIMPLE_SMP(a, rtems_build_name('T', 'E', 'S', 'T')) + RTEMS_SCHEDULER_TABLE_SIMPLE_SMP( a, rtems_build_name( 'T', 'E', 'S', 'T' ) ) #define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) #define CONFIGURE_MAXIMUM_TASKS 3 diff --git a/testsuites/smptests/smpscheduler06/init.c b/testsuites/smptests/smpscheduler06/init.c index 2650f37ffb..46104c5172 100644 --- a/testsuites/smptests/smpscheduler06/init.c +++ b/testsuites/smptests/smpscheduler06/init.c @@ -32,7 +32,7 @@ #include #include -void Init(rtems_task_argument arg); +void Init( rtems_task_argument arg ); const char rtems_test_name[] = "SMPSCHEDULER 6"; @@ -47,19 +47,16 @@ const char rtems_test_name[] = "SMPSCHEDULER 6"; #include -RTEMS_SCHEDULER_PRIORITY_AFFINITY_SMP( - a, - CONFIGURE_MAXIMUM_PRIORITY + 1 -); +RTEMS_SCHEDULER_PRIORITY_AFFINITY_SMP( a, CONFIGURE_MAXIMUM_PRIORITY + 1 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ RTEMS_SCHEDULER_TABLE_PRIORITY_AFFINITY_SMP( \ - a, \ - rtems_build_name('T', 'E', 'S', 'T') \ + a, \ + rtems_build_name( 'T', 'E', 'S', 'T' ) \ ) #define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) #define CONFIGURE_MAXIMUM_TASKS 3 diff --git a/testsuites/smptests/smpscheduler07/init.c b/testsuites/smptests/smpscheduler07/init.c index c97788eb0e..6853c1a682 100644 --- a/testsuites/smptests/smpscheduler07/init.c +++ b/testsuites/smptests/smpscheduler07/init.c @@ -32,7 +32,7 @@ #include #include -void Init(rtems_task_argument arg); +void Init( rtems_task_argument arg ); const char rtems_test_name[] = "SMPSCHEDULER 7"; @@ -45,13 +45,13 @@ const char rtems_test_name[] = "SMPSCHEDULER 7"; #include -RTEMS_SCHEDULER_EDF_SMP(a); +RTEMS_SCHEDULER_EDF_SMP( a ); #define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_EDF_SMP( a, rtems_build_name('T', 'E', 'S', 'T')) + RTEMS_SCHEDULER_TABLE_EDF_SMP( a, rtems_build_name( 'T', 'E', 'S', 'T' ) ) #define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) #define CONFIGURE_MAXIMUM_TASKS 3 diff --git a/testsuites/smptests/smpsignal01/init.c b/testsuites/smptests/smpsignal01/init.c index 36fc937474..02664ac1d7 100644 --- a/testsuites/smptests/smpsignal01/init.c +++ b/testsuites/smptests/smpsignal01/init.c @@ -47,191 +47,191 @@ typedef enum { typedef struct { volatile test_state state; - rtems_id consumer; - rtems_id producer; - uint32_t consumer_processor; - uint32_t producer_processor; - rtems_id timer; - volatile bool done; + rtems_id consumer; + rtems_id producer; + uint32_t consumer_processor; + uint32_t producer_processor; + rtems_id timer; + volatile bool done; } test_context; -static void change_state(test_context *ctx, test_state new_state) +static void change_state( test_context *ctx, test_state new_state ) { ctx->state = new_state; } -static void wait_for_state(const test_context *ctx, test_state desired_state) +static void wait_for_state( const test_context *ctx, test_state desired_state ) { while ( ctx->state != desired_state ) { /* Wait */ } } -static test_context ctx_instance = { - .state = SIG_0_READY -}; +static test_context ctx_instance = { .state = SIG_0_READY }; -static void signal_handler(rtems_signal_set signal) +static void signal_handler( rtems_signal_set signal ) { (void) signal; test_context *ctx = &ctx_instance; - rtems_test_assert(_ISR_Get_level() == 0); + rtems_test_assert( _ISR_Get_level() == 0 ); - switch (ctx->state) { + switch ( ctx->state ) { case SIG_0_ENABLE: - change_state(ctx, SIG_0_PROCESSED); + change_state( ctx, SIG_0_PROCESSED ); break; case SIG_1_SENT: - change_state(ctx, SIG_1_PROCESSED); + change_state( ctx, SIG_1_PROCESSED ); break; default: - rtems_test_assert(0); + rtems_test_assert( 0 ); } } -static void signal_send(test_context *ctx, test_state new_state) +static void signal_send( test_context *ctx, test_state new_state ) { rtems_status_code sc; - change_state(ctx, new_state); - sc = rtems_signal_send(ctx->consumer, TEST_SIGNAL); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - + change_state( ctx, new_state ); + sc = rtems_signal_send( ctx->consumer, TEST_SIGNAL ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void check_consumer_processor(const test_context *ctx) +static void check_consumer_processor( const test_context *ctx ) { rtems_test_assert( ctx->consumer_processor == rtems_scheduler_get_processor() ); } -static void check_producer_processor(const test_context *ctx) +static void check_producer_processor( const test_context *ctx ) { rtems_test_assert( ctx->producer_processor == rtems_scheduler_get_processor() ); } -static void producer(rtems_task_argument arg) +static void producer( rtems_task_argument arg ) { test_context *ctx = (test_context *) arg; ctx->producer_processor = rtems_scheduler_get_processor(); - rtems_test_assert(ctx->consumer_processor != ctx->producer_processor); + rtems_test_assert( ctx->consumer_processor != ctx->producer_processor ); - wait_for_state(ctx, SIG_0_READY); - signal_send(ctx, SIG_0_SENT); + wait_for_state( ctx, SIG_0_READY ); + signal_send( ctx, SIG_0_SENT ); - check_producer_processor(ctx); + check_producer_processor( ctx ); - wait_for_state(ctx, SIG_1_READY); - signal_send(ctx, SIG_1_SENT); + wait_for_state( ctx, SIG_1_READY ); + signal_send( ctx, SIG_1_SENT ); - check_producer_processor(ctx); + check_producer_processor( ctx ); - rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(0); + rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( 0 ); } -static void test_two_processors(test_context *ctx) +static void test_two_processors( test_context *ctx ) { rtems_status_code sc; - rtems_mode mode; + rtems_mode mode; - sc = rtems_signal_catch(signal_handler, RTEMS_DEFAULT_MODES); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_signal_catch( signal_handler, RTEMS_DEFAULT_MODES ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('P', 'R', 'O', 'D'), + rtems_build_name( 'P', 'R', 'O', 'D' ), RTEMS_MINIMUM_PRIORITY, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->producer ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->producer, producer, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->producer, producer, (rtems_task_argument) ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - check_consumer_processor(ctx); + check_consumer_processor( ctx ); - wait_for_state(ctx, SIG_0_SENT); - change_state(ctx, SIG_0_ENABLE); + wait_for_state( ctx, SIG_0_SENT ); + change_state( ctx, SIG_0_ENABLE ); - sc = rtems_task_mode(RTEMS_ASR, RTEMS_ASR_MASK, &mode); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(mode == RTEMS_NO_ASR); + sc = rtems_task_mode( RTEMS_ASR, RTEMS_ASR_MASK, &mode ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( mode == RTEMS_NO_ASR ); - wait_for_state(ctx, SIG_0_PROCESSED); + wait_for_state( ctx, SIG_0_PROCESSED ); - check_consumer_processor(ctx); + check_consumer_processor( ctx ); - change_state(ctx, SIG_1_READY); - wait_for_state(ctx, SIG_1_PROCESSED); + change_state( ctx, SIG_1_READY ); + wait_for_state( ctx, SIG_1_PROCESSED ); - check_consumer_processor(ctx); + check_consumer_processor( ctx ); } -static void isr_level_timer(rtems_id timer, void *arg) +static void isr_level_timer( rtems_id timer, void *arg ) { (void) timer; - test_context *ctx = arg; + test_context *ctx = arg; rtems_status_code sc; - sc = rtems_signal_send(ctx->consumer, TEST_SIGNAL); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_signal_send( ctx->consumer, TEST_SIGNAL ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void isr_level_handler(rtems_signal_set signal) +static void isr_level_handler( rtems_signal_set signal ) { (void) signal; test_context *ctx = &ctx_instance; - rtems_test_assert(_ISR_Get_level() == 0); + rtems_test_assert( _ISR_Get_level() == 0 ); ctx->done = true; } -static void test_isr_level(test_context *ctx) +static void test_isr_level( test_context *ctx ) { rtems_status_code sc; - rtems_mode mode; + rtems_mode mode; - sc = rtems_task_mode(RTEMS_ASR, RTEMS_ASR_MASK, &mode); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(mode == RTEMS_NO_ASR); + sc = rtems_task_mode( RTEMS_ASR, RTEMS_ASR_MASK, &mode ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( mode == RTEMS_NO_ASR ); - sc = rtems_timer_create(rtems_build_name('T', 'I', 'M', 'R'), &ctx->timer); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_create( + rtems_build_name( 'T', 'I', 'M', 'R' ), + &ctx->timer + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(!ctx->done); + rtems_test_assert( !ctx->done ); - sc = rtems_signal_catch(isr_level_handler, RTEMS_DEFAULT_MODES); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_signal_catch( isr_level_handler, RTEMS_DEFAULT_MODES ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_timer_fire_after(ctx->timer, 1, isr_level_timer, ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_fire_after( ctx->timer, 1, isr_level_timer, ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - while (!ctx->done) { + while ( !ctx->done ) { /* Wait for timer */ } - sc = rtems_timer_delete(ctx->timer); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_delete( ctx->timer ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_mode(RTEMS_NO_ASR, RTEMS_ASR_MASK, &mode); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(mode == RTEMS_ASR); + sc = rtems_task_mode( RTEMS_NO_ASR, RTEMS_ASR_MASK, &mode ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( mode == RTEMS_ASR ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -242,14 +242,14 @@ static void Init(rtems_task_argument arg) ctx->consumer = rtems_task_self(); ctx->consumer_processor = rtems_scheduler_get_processor(); - test_isr_level(ctx); + test_isr_level( ctx ); - if (rtems_scheduler_get_processor_maximum() >= 2) { - test_two_processors(ctx); + if ( rtems_scheduler_get_processor_maximum() >= 2 ) { + test_two_processors( ctx ); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER diff --git a/testsuites/smptests/smpstart01/init.c b/testsuites/smptests/smpstart01/init.c index 8b1ba1372a..37f2e0fa56 100644 --- a/testsuites/smptests/smpstart01/init.c +++ b/testsuites/smptests/smpstart01/init.c @@ -40,32 +40,32 @@ const char rtems_test_name[] = "SMPSTART 1"; typedef struct { - const rtems_tcb *main_tcb; + const rtems_tcb *main_tcb; SMP_barrier_Control barrier; - Per_CPU_Job job; + Per_CPU_Job job; } test_context; static test_context test_instance; -static void barrier(test_context *ctx) +static void barrier( test_context *ctx ) { SMP_barrier_State bs; - _SMP_barrier_State_initialize(&bs); - _SMP_barrier_Wait(&ctx->barrier, &bs, 2); + _SMP_barrier_State_initialize( &bs ); + _SMP_barrier_Wait( &ctx->barrier, &bs, 2 ); } -static void prepare_second_cpu(void *arg) +static void prepare_second_cpu( void *arg ) { - test_context *ctx; + test_context *ctx; Per_CPU_Control *cpu_self; ctx = arg; cpu_self = _Per_CPU_Get(); - barrier(ctx); + barrier( ctx ); - while (cpu_self->heir != ctx->main_tcb) { + while ( cpu_self->heir != ctx->main_tcb ) { RTEMS_COMPILER_MEMORY_BARRIER(); } } @@ -75,15 +75,15 @@ static const Per_CPU_Job_context job_context = { .arg = &test_instance }; -static void submit_job(void) +static void submit_job( void ) { test_context *ctx; ctx = &test_instance; - _SMP_barrier_Control_initialize(&ctx->barrier); + _SMP_barrier_Control_initialize( &ctx->barrier ); ctx->job.context = &job_context; - _Per_CPU_Submit_job(_Per_CPU_Get_by_index(1), &ctx->job); + _Per_CPU_Submit_job( _Per_CPU_Get_by_index( 1 ), &ctx->job ); } RTEMS_SYSINIT_ITEM( @@ -92,28 +92,28 @@ RTEMS_SYSINIT_ITEM( RTEMS_SYSINIT_ORDER_MIDDLE ); -static void test(void) +static void test( void ) { - test_context *ctx; + test_context *ctx; rtems_status_code sc; - rtems_id id; + rtems_id id; ctx = &test_instance; ctx->main_tcb = _Thread_Get_executing(); - barrier(ctx); + barrier( ctx ); - sc = rtems_scheduler_ident_by_processor(1, &id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident_by_processor( 1, &id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(RTEMS_SELF, id, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( RTEMS_SELF, id, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); - rtems_test_assert(_ISR_Get_level() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); + rtems_test_assert( _ISR_Get_level() == 0 ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -122,7 +122,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER @@ -134,17 +134,20 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_EDF_SMP(a); +RTEMS_SCHEDULER_EDF_SMP( a ); -RTEMS_SCHEDULER_EDF_SMP(b); +RTEMS_SCHEDULER_EDF_SMP( b ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(a, rtems_build_name('A', ' ', ' ', ' ')), \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(b, rtems_build_name('B', ' ', ' ', ' ')) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( a, rtems_build_name( 'A', ' ', ' ', ' ' ) ), \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( \ + b, \ + rtems_build_name( 'B', ' ', ' ', ' ' ) \ + ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ) #define CONFIGURE_MAXIMUM_TASKS 1 diff --git a/testsuites/smptests/smpstrongapa01/init.c b/testsuites/smptests/smpstrongapa01/init.c index c3703b1b14..708e5455a9 100644 --- a/testsuites/smptests/smpstrongapa01/init.c +++ b/testsuites/smptests/smpstrongapa01/init.c @@ -40,20 +40,14 @@ const char rtems_test_name[] = "SMPSTRONGAPA 1"; #define TASK_COUNT 5 -#define P(i) (UINT32_C(2) + i) +#define P( i ) ( UINT32_C( 2 ) + i ) -#define ALL ((UINT32_C(1) << CPU_COUNT) - 1) +#define ALL ( ( UINT32_C( 1 ) << CPU_COUNT ) - 1 ) -#define A(cpu0, cpu1, cpu2, cpu3) ( (cpu3 << 3) | (cpu2 << 2) | (cpu1 << 1)| cpu0 ) +#define A( cpu0, cpu1, cpu2, cpu3 ) \ + ( ( cpu3 << 3 ) | ( cpu2 << 2 ) | ( cpu1 << 1 ) | cpu0 ) -typedef enum { - T0, - T1, - T2, - T3, - T4, - IDLE -} task_index; +typedef enum { T0, T1, T2, T3, T4, IDLE } task_index; typedef struct { enum { @@ -68,170 +62,175 @@ typedef struct { struct { rtems_task_priority priority; - uint32_t cpu_set; + uint32_t cpu_set; } data; - uint8_t expected_cpu_allocations[CPU_COUNT]; + uint8_t expected_cpu_allocations[ CPU_COUNT ]; } test_action; typedef struct { rtems_id timer_id; rtems_id master_id; - rtems_id task_ids[TASK_COUNT]; - size_t action_index; + rtems_id task_ids[ TASK_COUNT ]; + size_t action_index; } test_context; -#define RESET \ - { \ - KIND_RESET, \ - 0, \ - { 0 }, \ - { IDLE, IDLE, IDLE, IDLE } \ +#define RESET \ + { \ + KIND_RESET, 0, { 0 }, \ + { \ + IDLE, IDLE, IDLE, IDLE \ + } \ } -#define SET_PRIORITY(index, prio, cpu0, cpu1, cpu2, cpu3) \ - { \ - KIND_SET_PRIORITY, \ - index, \ - { .priority = prio }, \ - { cpu0, cpu1, cpu2, cpu3 } \ +#define SET_PRIORITY( index, prio, cpu0, cpu1, cpu2, cpu3 ) \ + { \ + KIND_SET_PRIORITY, index, { .priority = prio }, \ + { \ + cpu0, cpu1, cpu2, cpu3 \ + } \ } -#define SET_AFFINITY(index, aff, cpu0, cpu1, cpu2, cpu3) \ - { \ - KIND_SET_AFFINITY, \ - index, \ - { .cpu_set = aff }, \ - { cpu0, cpu1, cpu2, cpu3 } \ +#define SET_AFFINITY( index, aff, cpu0, cpu1, cpu2, cpu3 ) \ + { \ + KIND_SET_AFFINITY, index, { .cpu_set = aff }, \ + { \ + cpu0, cpu1, cpu2, cpu3 \ + } \ } -#define BLOCK(index, cpu0, cpu1, cpu2, cpu3) \ - { \ - KIND_BLOCK, \ - index, \ - { 0 }, \ - { cpu0, cpu1, cpu2, cpu3 } \ +#define BLOCK( index, cpu0, cpu1, cpu2, cpu3 ) \ + { \ + KIND_BLOCK, index, { 0 }, \ + { \ + cpu0, cpu1, cpu2, cpu3 \ + } \ } -#define UNBLOCK(index, cpu0, cpu1, cpu2, cpu3) \ - { \ - KIND_UNBLOCK, \ - index, \ - { 0 }, \ - { cpu0, cpu1, cpu2, cpu3 } \ +#define UNBLOCK( index, cpu0, cpu1, cpu2, cpu3 ) \ + { \ + KIND_UNBLOCK, index, { 0 }, \ + { \ + cpu0, cpu1, cpu2, cpu3 \ + } \ } static const test_action test_actions[] = { RESET, - UNBLOCK( T0, T0, IDLE, IDLE, IDLE), - UNBLOCK( T1, T0, T1, IDLE, IDLE), - UNBLOCK( T2, T0, T1, T2, IDLE), - UNBLOCK( T3, T0, T1, T2, T3), - UNBLOCK( T4, T0, T1, T2, T3), - SET_PRIORITY( T0, P(0), T0, T1, T2, T3), - SET_PRIORITY( T1, P(1), T0, T1, T2, T3), - SET_PRIORITY( T2, P(2), T0, T1, T2, T3), - SET_PRIORITY( T4, P(4), T0, T1, T2, T3), + UNBLOCK( T0, T0, IDLE, IDLE, IDLE ), + UNBLOCK( T1, T0, T1, IDLE, IDLE ), + UNBLOCK( T2, T0, T1, T2, IDLE ), + UNBLOCK( T3, T0, T1, T2, T3 ), + UNBLOCK( T4, T0, T1, T2, T3 ), + SET_PRIORITY( T0, P( 0 ), T0, T1, T2, T3 ), + SET_PRIORITY( T1, P( 1 ), T0, T1, T2, T3 ), + SET_PRIORITY( T2, P( 2 ), T0, T1, T2, T3 ), + SET_PRIORITY( T4, P( 4 ), T0, T1, T2, T3 ), /* * Introduce Task 3 intially with lowest priority to imitate late arrival */ - SET_PRIORITY( T3, P(8), T0, T1, T2, T4), - SET_AFFINITY( T0, ALL, T0, T1, T2, T4), - SET_AFFINITY( T1, A(0, 1, 0, 0), T0, T1, T2, T4), - SET_AFFINITY( T2, A(0, 0, 1, 0), T0, T1, T2, T4), - SET_AFFINITY( T4, A(0, 0, 0, 1), T0, T1, T2, T4), + SET_PRIORITY( T3, P( 8 ), T0, T1, T2, T4 ), + SET_AFFINITY( T0, ALL, T0, T1, T2, T4 ), + SET_AFFINITY( T1, A( 0, 1, 0, 0 ), T0, T1, T2, T4 ), + SET_AFFINITY( T2, A( 0, 0, 1, 0 ), T0, T1, T2, T4 ), + SET_AFFINITY( T4, A( 0, 0, 0, 1 ), T0, T1, T2, T4 ), /* *Set affinity of Task 4 only to CPU1, so that we can check shifting */ - SET_AFFINITY( T3, A(1, 0, 0, 0), T0, T1, T2, T4), + SET_AFFINITY( T3, A( 1, 0, 0, 0 ), T0, T1, T2, T4 ), /* * Show that higher priority task gets dislodged from its processor * by a lower priority task ! * and goes to the cpu that is executing the task with lowest priority * (among all cpus). */ - SET_PRIORITY( T3, P(3), T3, T1, T2, T0), + SET_PRIORITY( T3, P( 3 ), T3, T1, T2, T0 ), RESET }; static test_context test_instance; -static void set_priority(rtems_id id, rtems_task_priority prio) +static void set_priority( rtems_id id, rtems_task_priority prio ) { rtems_status_code sc; - sc = rtems_task_set_priority(id, prio, &prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( id, prio, &prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void set_affinity(rtems_id id, uint32_t cpu_set_32) +static void set_affinity( rtems_id id, uint32_t cpu_set_32 ) { rtems_status_code sc; - cpu_set_t cpu_set; - size_t i; + cpu_set_t cpu_set; + size_t i; - CPU_ZERO(&cpu_set); + CPU_ZERO( &cpu_set ); - for (i = 0; i < CPU_COUNT; ++i) { - if ((cpu_set_32 & (UINT32_C(1) << i)) != 0) { - CPU_SET(i, &cpu_set); + for ( i = 0; i < CPU_COUNT; ++i ) { + if ( ( cpu_set_32 & ( UINT32_C( 1 ) << i ) ) != 0 ) { + CPU_SET( i, &cpu_set ); } } - sc = rtems_task_set_affinity(id, sizeof(cpu_set), &cpu_set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_affinity( id, sizeof( cpu_set ), &cpu_set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void reset(test_context *ctx) +static void reset( test_context *ctx ) { rtems_status_code sc; - size_t i; + size_t i; - for (i = CPU_COUNT; i < TASK_COUNT; ++i) { - set_priority(ctx->task_ids[i], P(i)); - set_affinity(ctx->task_ids[i], ALL); + for ( i = CPU_COUNT; i < TASK_COUNT; ++i ) { + set_priority( ctx->task_ids[ i ], P( i ) ); + set_affinity( ctx->task_ids[ i ], ALL ); - sc = rtems_task_suspend(ctx->task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_ALREADY_SUSPENDED); + sc = rtems_task_suspend( ctx->task_ids[ i ] ); + rtems_test_assert( + sc == RTEMS_SUCCESSFUL || sc == RTEMS_ALREADY_SUSPENDED + ); } - for (i = 0; i < CPU_COUNT; ++i) { - set_priority(ctx->task_ids[i], P(i)); + for ( i = 0; i < CPU_COUNT; ++i ) { + set_priority( ctx->task_ids[ i ], P( i ) ); - sc = rtems_task_resume(ctx->task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL || sc == RTEMS_INCORRECT_STATE); + sc = rtems_task_resume( ctx->task_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL || sc == RTEMS_INCORRECT_STATE ); } /* Order the idle threads explicitly */ - for (i = 0; i < CPU_COUNT; ++i) { + for ( i = 0; i < CPU_COUNT; ++i ) { const Per_CPU_Control *c; - const Thread_Control *h; + const Thread_Control *h; - c = _Per_CPU_Get_by_index(CPU_COUNT - 1 - i); + c = _Per_CPU_Get_by_index( CPU_COUNT - 1 - i ); h = c->heir; - sc = rtems_task_suspend(h->Object.id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( h->Object.id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void check_cpu_allocations(test_context *ctx, const test_action *action) +static void check_cpu_allocations( + test_context *ctx, + const test_action *action +) { size_t i; - for (i = 0; i < CPU_COUNT; ++i) { - task_index e; + for ( i = 0; i < CPU_COUNT; ++i ) { + task_index e; const Per_CPU_Control *c; - const Thread_Control *h; + const Thread_Control *h; - e = action->expected_cpu_allocations[i]; - c = _Per_CPU_Get_by_index(i); + e = action->expected_cpu_allocations[ i ]; + c = _Per_CPU_Get_by_index( i ); h = c->heir; - if (e != IDLE) { - rtems_test_assert(h->Object.id == ctx->task_ids[e]); + if ( e != IDLE ) { + rtems_test_assert( h->Object.id == ctx->task_ids[ e ] ); } else { - rtems_test_assert(h->is_idle); + rtems_test_assert( h->is_idle ); } } } @@ -240,131 +239,131 @@ static void check_cpu_allocations(test_context *ctx, const test_action *action) * Use a timer to execute the actions, since it runs with thread dispatching * disabled. This is necessary to check the expected processor allocations. */ -static void timer(rtems_id id, void *arg) +static void timer( rtems_id id, void *arg ) { - test_context *ctx; + test_context *ctx; rtems_status_code sc; - size_t i; + size_t i; ctx = arg; i = ctx->action_index; - if (i == 0) { - sc = rtems_task_suspend(ctx->master_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + if ( i == 0 ) { + sc = rtems_task_suspend( ctx->master_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - if (i < RTEMS_ARRAY_SIZE(test_actions)) { - const test_action *action = &test_actions[i]; - rtems_id task; + if ( i < RTEMS_ARRAY_SIZE( test_actions ) ) { + const test_action *action = &test_actions[ i ]; + rtems_id task; ctx->action_index = i + 1; - task = ctx->task_ids[action->index]; + task = ctx->task_ids[ action->index ]; - switch (action->kind) { + switch ( action->kind ) { case KIND_SET_PRIORITY: - set_priority(task, action->data.priority); + set_priority( task, action->data.priority ); break; case KIND_SET_AFFINITY: - set_affinity(task, action->data.cpu_set); + set_affinity( task, action->data.cpu_set ); break; case KIND_BLOCK: - sc = rtems_task_suspend(task); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( task ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); break; case KIND_UNBLOCK: - sc = rtems_task_resume(task); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( task ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); break; default: - rtems_test_assert(action->kind == KIND_RESET); - reset(ctx); + rtems_test_assert( action->kind == KIND_RESET ); + reset( ctx ); break; } - check_cpu_allocations(ctx, action); + check_cpu_allocations( ctx, action ); - sc = rtems_timer_reset(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_reset( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } else { - sc = rtems_task_resume(ctx->master_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->master_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_send(ctx->master_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_send( ctx->master_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void do_nothing_task(rtems_task_argument arg) +static void do_nothing_task( rtems_task_argument arg ) { (void) arg; - while (true) { + while ( true ) { /* Do nothing */ } } -static void test(void) +static void test( void ) { - test_context *ctx; + test_context *ctx; rtems_status_code sc; - size_t i; + size_t i; ctx = &test_instance; ctx->master_id = rtems_task_self(); - for (i = 0; i < TASK_COUNT; ++i) { + for ( i = 0; i < TASK_COUNT; ++i ) { sc = rtems_task_create( - rtems_build_name(' ', ' ', 'T', '0' + i), - P(i), + rtems_build_name( ' ', ' ', 'T', '0' + i ), + P( i ), RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->task_ids[i] + &ctx->task_ids[ i ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->task_ids[i], do_nothing_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->task_ids[ i ], do_nothing_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } sc = rtems_timer_create( - rtems_build_name('A', 'C', 'T', 'N'), + rtems_build_name( 'A', 'C', 'T', 'N' ), &ctx->timer_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_timer_fire_after(ctx->timer_id, 1, timer, ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_fire_after( ctx->timer_id, 1, timer, ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_event_transient_receive(RTEMS_WAIT, RTEMS_NO_TIMEOUT); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_transient_receive( RTEMS_WAIT, RTEMS_NO_TIMEOUT ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (i = 0; i < TASK_COUNT; ++i) { - sc = rtems_task_delete(ctx->task_ids[i]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( i = 0; i < TASK_COUNT; ++i ) { + sc = rtems_task_delete( ctx->task_ids[ i ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_timer_delete(ctx->timer_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_timer_delete( ctx->timer_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() == CPU_COUNT) { + if ( rtems_scheduler_get_processor_maximum() == CPU_COUNT ) { test(); } else { - puts("warning: wrong processor count to run the test"); + puts( "warning: wrong processor count to run the test" ); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_MICROSECONDS_PER_TICK 1000 @@ -372,7 +371,7 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER -#define CONFIGURE_MAXIMUM_TASKS (1 + TASK_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + TASK_COUNT ) #define CONFIGURE_MAXIMUM_TIMERS 1 #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT diff --git a/testsuites/smptests/smpswitchextension01/init.c b/testsuites/smptests/smpswitchextension01/init.c index 223f2d7e48..c8b71b4e1d 100644 --- a/testsuites/smptests/smpswitchextension01/init.c +++ b/testsuites/smptests/smpswitchextension01/init.c @@ -54,200 +54,201 @@ const char rtems_test_name[] = "SMPSWITCHEXTENSION 1"; typedef struct { uint32_t toggles; - uint32_t unused_space_for_cache_line_alignment[7]; + uint32_t unused_space_for_cache_line_alignment[ 7 ]; } test_toggler_counters; typedef struct { - test_toggler_counters counters[TOGGLER_COUNT]; - rtems_id toggler_ids[TOGGLER_COUNT]; - rtems_id extension_ids[EXTENSION_COUNT]; - uint32_t extension_switches; - uint32_t context_switches[EXTENSION_COUNT]; + test_toggler_counters counters[ TOGGLER_COUNT ]; + rtems_id toggler_ids[ TOGGLER_COUNT ]; + rtems_id extension_ids[ EXTENSION_COUNT ]; + uint32_t extension_switches; + uint32_t context_switches[ EXTENSION_COUNT ]; } test_context; CPU_STRUCTURE_ALIGNMENT static test_context ctx_instance; -static void switch_0(Thread_Control *executing, Thread_Control *heir) +static void switch_0( Thread_Control *executing, Thread_Control *heir ) { test_context *ctx = &ctx_instance; (void) executing; (void) heir; - ++ctx->context_switches[0]; + ++ctx->context_switches[ 0 ]; } -static void switch_1(Thread_Control *executing, Thread_Control *heir) +static void switch_1( Thread_Control *executing, Thread_Control *heir ) { test_context *ctx = &ctx_instance; (void) executing; (void) heir; - ++ctx->context_switches[1]; + ++ctx->context_switches[ 1 ]; } -static void switch_2(Thread_Control *executing, Thread_Control *heir) +static void switch_2( Thread_Control *executing, Thread_Control *heir ) { test_context *ctx = &ctx_instance; (void) executing; (void) heir; - ++ctx->context_switches[2]; + ++ctx->context_switches[ 2 ]; } -static const rtems_extensions_table extensions[EXTENSION_COUNT] = { +static const rtems_extensions_table extensions[ EXTENSION_COUNT ] = { { .thread_switch = switch_0 }, { .thread_switch = switch_1 }, { .thread_switch = switch_2 } }; -static void toggler(rtems_task_argument self) +static void toggler( rtems_task_argument self ) { - test_context *ctx = &ctx_instance; - test_toggler_counters *counters = &ctx->counters[self]; + test_context *ctx = &ctx_instance; + test_toggler_counters *counters = &ctx->counters[ self ]; - while (true) { + while ( true ) { rtems_status_code sc; ++counters->toggles; - sc = rtems_task_wake_after(RTEMS_YIELD_PROCESSOR); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( RTEMS_YIELD_PROCESSOR ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void switcher(rtems_task_argument self) +static void switcher( rtems_task_argument self ) { (void) self; test_context *ctx = &ctx_instance; - while (true) { - size_t ext_index; + while ( true ) { + size_t ext_index; rtems_status_code sc; ++ctx->extension_switches; - for (ext_index = 0; ext_index < EXTENSION_COUNT; ++ext_index) { + for ( ext_index = 0; ext_index < EXTENSION_COUNT; ++ext_index ) { sc = rtems_extension_create( - rtems_build_name('E', 'X', 'T', (char) ('0' + ext_index)), - &extensions[ext_index], - &ctx->extension_ids[ext_index] + rtems_build_name( 'E', 'X', 'T', (char) ( '0' + ext_index ) ), + &extensions[ ext_index ], + &ctx->extension_ids[ ext_index ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (ext_index = 0; ext_index < EXTENSION_COUNT; ++ext_index) { - sc = rtems_extension_delete(ctx->extension_ids[ext_index]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( ext_index = 0; ext_index < EXTENSION_COUNT; ++ext_index ) { + sc = rtems_extension_delete( ctx->extension_ids[ ext_index ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } } -static void stopper(rtems_task_argument arg) +static void stopper( rtems_task_argument arg ) { (void) arg; - while (true) { + while ( true ) { /* Do nothing */ } } -static void test(void) +static void test( void ) { - test_context *ctx = &ctx_instance; - rtems_status_code sc; + test_context *ctx = &ctx_instance; + rtems_status_code sc; rtems_task_argument toggler_index; - rtems_id stopper_id; - rtems_id switcher_id; - size_t ext_index; + rtems_id stopper_id; + rtems_id switcher_id; + size_t ext_index; sc = rtems_task_create( - rtems_build_name('S', 'T', 'O', 'P'), + rtems_build_name( 'S', 'T', 'O', 'P' ), PRIO_STOP, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &stopper_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('E', 'X', 'S', 'W'), + rtems_build_name( 'E', 'X', 'S', 'W' ), PRIO_SWITCH, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &switcher_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (toggler_index = 0; toggler_index < TOGGLER_COUNT; ++toggler_index) { + for ( toggler_index = 0; toggler_index < TOGGLER_COUNT; ++toggler_index ) { sc = rtems_task_create( - rtems_build_name('T', 'O', 'G', (char) ('0' + toggler_index)), + rtems_build_name( 'T', 'O', 'G', (char) ( '0' + toggler_index ) ), PRIO_NORMAL, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &ctx->toggler_ids[toggler_index] + &ctx->toggler_ids[ toggler_index ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (toggler_index = 0; toggler_index < TOGGLER_COUNT; ++toggler_index) { - sc = rtems_task_start(ctx->toggler_ids[toggler_index], toggler, toggler_index); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( toggler_index = 0; toggler_index < TOGGLER_COUNT; ++toggler_index ) { + sc = rtems_task_start( + ctx->toggler_ids[ toggler_index ], + toggler, + toggler_index + ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - sc = rtems_task_start(switcher_id, switcher, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( switcher_id, switcher, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_wake_after(10 * rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( 10 * rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(stopper_id, stopper, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( stopper_id, stopper, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - for (toggler_index = 0; toggler_index < TOGGLER_COUNT; ++toggler_index) { - test_toggler_counters *counters = &ctx->counters[toggler_index]; + for ( toggler_index = 0; toggler_index < TOGGLER_COUNT; ++toggler_index ) { + test_toggler_counters *counters = &ctx->counters[ toggler_index ]; printf( "toggler %" PRIuPTR "\n" - "\ttoggles %" PRIu32 "\n", + "\ttoggles %" PRIu32 "\n", toggler_index, counters->toggles ); } - for (ext_index = 0; ext_index < EXTENSION_COUNT; ++ext_index) { + for ( ext_index = 0; ext_index < EXTENSION_COUNT; ++ext_index ) { printf( "extension %" PRIuPTR "\n" - "\tcontext switches %" PRIu32 "\n", + "\tcontext switches %" PRIu32 "\n", ext_index, - ctx->context_switches[ext_index] + ctx->context_switches[ ext_index ] ); } - printf( - "extension switches %" PRIu32 "\n", - ctx->extension_switches - ); + printf( "extension switches %" PRIu32 "\n", ctx->extension_switches ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() >= 2) { + if ( rtems_scheduler_get_processor_maximum() >= 2 ) { test(); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -255,7 +256,7 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT -#define CONFIGURE_MAXIMUM_TASKS (3 + TOGGLER_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 3 + TOGGLER_COUNT ) #define CONFIGURE_MAXIMUM_USER_EXTENSIONS EXTENSION_COUNT diff --git a/testsuites/smptests/smpthreadlife01/init.c b/testsuites/smptests/smpthreadlife01/init.c index ec411de06e..f0fab06ed5 100644 --- a/testsuites/smptests/smpthreadlife01/init.c +++ b/testsuites/smptests/smpthreadlife01/init.c @@ -45,12 +45,12 @@ const char rtems_test_name[] = "SMPTHREADLIFE 1"; typedef struct { volatile rtems_task_argument main_arg; volatile rtems_task_argument worker_arg; - volatile bool terminated; - SMP_barrier_Control barrier; - SMP_barrier_State main_barrier_state; - SMP_barrier_State worker_barrier_state; - Thread_Control *delay_switch_for_executing; - rtems_id worker_id; + volatile bool terminated; + SMP_barrier_Control barrier; + SMP_barrier_State main_barrier_state; + SMP_barrier_State worker_barrier_state; + Thread_Control *delay_switch_for_executing; + rtems_id worker_id; } test_context; static test_context test_instance = { @@ -59,9 +59,9 @@ static test_context test_instance = { .worker_barrier_state = SMP_BARRIER_STATE_INITIALIZER }; -static void barrier(test_context *ctx, SMP_barrier_State *state) +static void barrier( test_context *ctx, SMP_barrier_State *state ) { - _SMP_barrier_Wait(&ctx->barrier, state, CPU_COUNT); + _SMP_barrier_Wait( &ctx->barrier, state, CPU_COUNT ); } static void restart_extension( @@ -69,7 +69,7 @@ static void restart_extension( Thread_Control *restarted ) { - rtems_test_assert(executing == restarted); + rtems_test_assert( executing == restarted ); } static void delete_extension( @@ -77,10 +77,10 @@ static void delete_extension( Thread_Control *deleted ) { - rtems_test_assert(executing != deleted); + rtems_test_assert( executing != deleted ); } -static void terminate_extension(Thread_Control *executing) +static void terminate_extension( Thread_Control *executing ) { (void) executing; @@ -89,150 +89,150 @@ static void terminate_extension(Thread_Control *executing) ctx->terminated = true; } -static void switch_extension(Thread_Control *executing, Thread_Control *heir) +static void switch_extension( Thread_Control *executing, Thread_Control *heir ) { (void) heir; test_context *ctx = &test_instance; - if (ctx->delay_switch_for_executing == executing) { + if ( ctx->delay_switch_for_executing == executing ) { ctx->delay_switch_for_executing = NULL; /* (A) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); - rtems_counter_delay_nanoseconds(100000000); + rtems_counter_delay_nanoseconds( 100000000 ); /* Avoid bad profiling statisitics */ _Profiling_Thread_dispatch_disable( _Per_CPU_Get(), 0 ); } } -static void worker_task(rtems_task_argument arg) +static void worker_task( rtems_task_argument arg ) { test_context *ctx = &test_instance; - rtems_test_assert(arg == ctx->main_arg); + rtems_test_assert( arg == ctx->main_arg ); ctx->worker_arg = arg; /* (B) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); - while (true) { + while ( true ) { /* Do nothing */ } } -static void test_restart(void) +static void test_restart( void ) { - test_context *ctx = &test_instance; - rtems_status_code sc; - rtems_id id; - rtems_task_argument arg; + test_context *ctx = &test_instance; + rtems_status_code sc; + rtems_id id; + rtems_task_argument arg; rtems_resource_snapshot snapshot; - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(id, worker_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, worker_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (B) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); - for (arg = 1; arg < 23; ++arg) { + for ( arg = 1; arg < 23; ++arg ) { ctx->main_arg = arg; ctx->worker_arg = 0; - sc = rtems_task_restart(id, arg); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_restart( id, arg ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (B) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); - rtems_test_assert(ctx->worker_arg == arg); + rtems_test_assert( ctx->worker_arg == arg ); } - sc = rtems_task_delete(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); } -static void test_delete(void) +static void test_delete( void ) { - test_context *ctx = &test_instance; - rtems_status_code sc; - rtems_id id; - rtems_task_argument arg; + test_context *ctx = &test_instance; + rtems_status_code sc; + rtems_id id; + rtems_task_argument arg; rtems_resource_snapshot snapshot; - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); - for (arg = 31; arg < 57; ++arg) { + for ( arg = 31; arg < 57; ++arg ) { ctx->main_arg = arg; ctx->worker_arg = 0; ctx->terminated = false; sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(id, worker_task, arg); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, worker_task, arg ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (B) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); - rtems_test_assert(ctx->worker_arg == arg); - rtems_test_assert(!ctx->terminated); + rtems_test_assert( ctx->worker_arg == arg ); + rtems_test_assert( !ctx->terminated ); - sc = rtems_task_delete(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(ctx->terminated); + rtems_test_assert( ctx->terminated ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); } } -static void delay_ipi_task(rtems_task_argument variant) +static void delay_ipi_task( rtems_task_argument variant ) { test_context *ctx = &test_instance; - ISR_Level level; + ISR_Level level; - _ISR_Local_disable(level); + _ISR_Local_disable( level ); /* (C) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); /* * Interrupts are disabled, so the inter-processor interrupt deleting us will * be delayed a bit. */ - rtems_counter_delay_nanoseconds(100000000); + rtems_counter_delay_nanoseconds( 100000000 ); - if (variant != 0) { + if ( variant != 0 ) { _Thread_Dispatch_disable(); } - _ISR_Local_enable(level); + _ISR_Local_enable( level ); /* * We get deleted as a side effect of enabling the thread life protection or @@ -240,45 +240,45 @@ static void delay_ipi_task(rtems_task_argument variant) */ _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); - if (variant != 0) { + if ( variant != 0 ) { _Thread_Dispatch_enable( _Per_CPU_Get() ); } - rtems_test_assert(0); + rtems_test_assert( 0 ); } -static void test_set_life_protection(rtems_task_argument variant) +static void test_set_life_protection( rtems_task_argument variant ) { - test_context *ctx = &test_instance; - rtems_status_code sc; - rtems_id id; + test_context *ctx = &test_instance; + rtems_status_code sc; + rtems_id id; rtems_resource_snapshot snapshot; - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); sc = rtems_task_create( - rtems_build_name('D', 'E', 'L', 'Y'), + rtems_build_name( 'D', 'E', 'L', 'Y' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(id, delay_ipi_task, variant); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, delay_ipi_task, variant ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (C) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); - sc = rtems_task_delete(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); } -static void delay_switch_task(rtems_task_argument arg) +static void delay_switch_task( rtems_task_argument arg ) { (void) arg; @@ -287,73 +287,69 @@ static void delay_switch_task(rtems_task_argument arg) ctx->delay_switch_for_executing = _Thread_Get_executing(); /* (D) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); rtems_task_exit(); } -static void test_wait_for_execution_stop(void) +static void test_wait_for_execution_stop( void ) { - test_context *ctx = &test_instance; - rtems_status_code sc; - rtems_id id; + test_context *ctx = &test_instance; + rtems_status_code sc; + rtems_id id; rtems_resource_snapshot snapshot; - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); sc = rtems_task_create( - rtems_build_name('S', 'W', 'I', 'T'), + rtems_build_name( 'S', 'W', 'I', 'T' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(id, delay_switch_task, 0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( id, delay_switch_task, 0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (D) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); /* (A) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); sc = rtems_task_create( - rtems_build_name('W', 'A', 'I', 'T'), + rtems_build_name( 'W', 'A', 'I', 'T' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); } -typedef enum { - TEST_OP_SUSPEND, - TEST_OP_EVENT, - TEST_OP_EVENT_SYSTEM -} test_op; +typedef enum { TEST_OP_SUSPEND, TEST_OP_EVENT, TEST_OP_EVENT_SYSTEM } test_op; -static void op_begin_suspend(void) +static void op_begin_suspend( void ) { rtems_status_code sc; - sc = rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void op_begin_event(void) +static void op_begin_event( void ) { rtems_status_code sc; - rtems_event_set events; + rtems_event_set events; events = 0; sc = rtems_event_receive( @@ -362,14 +358,14 @@ static void op_begin_event(void) RTEMS_NO_TIMEOUT, &events ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(events == RTEMS_EVENT_0); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( events == RTEMS_EVENT_0 ); } -static void op_begin_event_system(void) +static void op_begin_event_system( void ) { rtems_status_code sc; - rtems_event_set events; + rtems_event_set events; events = 0; sc = rtems_event_system_receive( @@ -378,148 +374,142 @@ static void op_begin_event_system(void) RTEMS_NO_TIMEOUT, &events ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); - rtems_test_assert(events == RTEMS_EVENT_0); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); + rtems_test_assert( events == RTEMS_EVENT_0 ); } -static void (*const test_ops_begin[])(void) = { - op_begin_suspend, - op_begin_event, - op_begin_event_system -}; +static void ( *const test_ops_begin[] )( void ) = + { op_begin_suspend, op_begin_event, op_begin_event_system }; -static void op_end_suspend(test_context *ctx) +static void op_end_suspend( test_context *ctx ) { rtems_status_code sc; - sc = rtems_task_resume(ctx->worker_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_resume( ctx->worker_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void op_end_event(test_context *ctx) +static void op_end_event( test_context *ctx ) { rtems_status_code sc; - sc = rtems_event_send(ctx->worker_id, RTEMS_EVENT_0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_send( ctx->worker_id, RTEMS_EVENT_0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void op_end_event_system(test_context *ctx) +static void op_end_event_system( test_context *ctx ) { rtems_status_code sc; - sc = rtems_event_system_send(ctx->worker_id, RTEMS_EVENT_0); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_system_send( ctx->worker_id, RTEMS_EVENT_0 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void (*const test_ops_end[])(test_context *) = { - op_end_suspend, - op_end_event, - op_end_event_system -}; +static void ( *const test_ops_end[] )( test_context * ) = + { op_end_suspend, op_end_event, op_end_event_system }; -static void op_worker_task(rtems_task_argument arg) +static void op_worker_task( rtems_task_argument arg ) { - test_context *ctx = &test_instance; - test_op op = arg; + test_context *ctx = &test_instance; + test_op op = arg; Thread_Life_state previous_life_state; - previous_life_state = _Thread_Set_life_protection(THREAD_LIFE_PROTECTED); + previous_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); /* (E) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); /* (F) */ - barrier(ctx, &ctx->worker_barrier_state); + barrier( ctx, &ctx->worker_barrier_state ); - (*test_ops_begin[op])(); + ( *test_ops_begin[ op ] )(); - _Thread_Set_life_protection(previous_life_state); - rtems_test_assert(0); + _Thread_Set_life_protection( previous_life_state ); + rtems_test_assert( 0 ); } -static void help_task(rtems_task_argument arg) +static void help_task( rtems_task_argument arg ) { test_context *ctx = &test_instance; - test_op op = arg; + test_op op = arg; /* (F) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); - rtems_counter_delay_nanoseconds(100000000); + rtems_counter_delay_nanoseconds( 100000000 ); - (*test_ops_end[op])(ctx); + ( *test_ops_end[ op ] )( ctx ); - rtems_task_suspend(RTEMS_SELF); - rtems_test_assert(0); + rtems_task_suspend( RTEMS_SELF ); + rtems_test_assert( 0 ); } -static void test_operation_with_delete_in_progress(test_op op) +static void test_operation_with_delete_in_progress( test_op op ) { - test_context *ctx = &test_instance; - rtems_status_code sc; - rtems_id help_id; + test_context *ctx = &test_instance; + rtems_status_code sc; + rtems_id help_id; rtems_resource_snapshot snapshot; - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); sc = rtems_task_create( - rtems_build_name('W', 'O', 'R', 'K'), + rtems_build_name( 'W', 'O', 'R', 'K' ), 1, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->worker_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->worker_id, op_worker_task, op); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->worker_id, op_worker_task, op ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); /* (E) */ - barrier(ctx, &ctx->main_barrier_state); + barrier( ctx, &ctx->main_barrier_state ); sc = rtems_task_create( - rtems_build_name('H', 'E', 'L', 'P'), + rtems_build_name( 'H', 'E', 'L', 'P' ), 2, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &help_id ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(help_id, help_task, op); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( help_id, help_task, op ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(ctx->worker_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( ctx->worker_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_delete(help_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_delete( help_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() >= CPU_COUNT) { + if ( rtems_scheduler_get_processor_maximum() >= CPU_COUNT ) { test_restart(); test_delete(); - test_set_life_protection(0); - test_set_life_protection(1); + test_set_life_protection( 0 ); + test_set_life_protection( 1 ); test_wait_for_execution_stop(); - test_operation_with_delete_in_progress(TEST_OP_SUSPEND); - test_operation_with_delete_in_progress(TEST_OP_EVENT); - test_operation_with_delete_in_progress(TEST_OP_EVENT_SYSTEM); + test_operation_with_delete_in_progress( TEST_OP_SUSPEND ); + test_operation_with_delete_in_progress( TEST_OP_EVENT ); + test_operation_with_delete_in_progress( TEST_OP_EVENT_SYSTEM ); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER @@ -527,16 +517,14 @@ static void Init(rtems_task_argument arg) #define CONFIGURE_MAXIMUM_PROCESSORS CPU_COUNT -#define CONFIGURE_MAXIMUM_TASKS (CPU_COUNT + 1) +#define CONFIGURE_MAXIMUM_TASKS ( CPU_COUNT + 1 ) -#define CONFIGURE_INITIAL_EXTENSIONS \ - { \ - .thread_restart = restart_extension, \ - .thread_delete = delete_extension, \ +#define CONFIGURE_INITIAL_EXTENSIONS \ + { .thread_restart = restart_extension, \ + .thread_delete = delete_extension, \ .thread_terminate = terminate_extension, \ - .thread_switch = switch_extension \ - }, \ - RTEMS_TEST_INITIAL_EXTENSION + .thread_switch = switch_extension }, \ + RTEMS_TEST_INITIAL_EXTENSION #define CONFIGURE_RTEMS_INIT_TASKS_TABLE diff --git a/testsuites/smptests/smpthreadpin01/init.c b/testsuites/smptests/smpthreadpin01/init.c index 8b4153a2f3..4331c65ad4 100644 --- a/testsuites/smptests/smpthreadpin01/init.c +++ b/testsuites/smptests/smpthreadpin01/init.c @@ -39,9 +39,9 @@ const char rtems_test_name[] = "SMPTHREADPIN 1"; #define CPU_COUNT 2 -#define SCHED_A rtems_build_name(' ', ' ', ' ', 'A') +#define SCHED_A rtems_build_name( ' ', ' ', ' ', 'A' ) -#define SCHED_B rtems_build_name(' ', ' ', ' ', 'B') +#define SCHED_B rtems_build_name( ' ', ' ', ' ', 'B' ) #define EVENT_WAKEUP_MASTER RTEMS_EVENT_0 @@ -76,72 +76,72 @@ const char rtems_test_name[] = "SMPTHREADPIN 1"; #define PRIO_VERY_HIGH 1 typedef struct { - rtems_id master; - rtems_id event; - rtems_id event_2; - rtems_id busy; - rtems_id sched_a; - rtems_id sched_b; - rtems_mutex mtx; + rtems_id master; + rtems_id event; + rtems_id event_2; + rtems_id busy; + rtems_id sched_a; + rtems_id sched_b; + rtems_mutex mtx; volatile bool flag; } test_context; static test_context test_instance; -static rtems_task_priority set_prio(rtems_id id, rtems_task_priority prio) +static rtems_task_priority set_prio( rtems_id id, rtems_task_priority prio ) { - rtems_status_code sc; + rtems_status_code sc; rtems_task_priority old_prio; old_prio = 0xffffffff; - sc = rtems_task_set_priority(id, prio, &old_prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_priority( id, prio, &old_prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); return old_prio; } -static void set_affinity(rtems_id task, uint32_t cpu_index) +static void set_affinity( rtems_id task, uint32_t cpu_index ) { rtems_status_code sc; - rtems_id sched_cpu; - rtems_id sched_task; - cpu_set_t set; + rtems_id sched_cpu; + rtems_id sched_task; + cpu_set_t set; - sc = rtems_scheduler_ident_by_processor(cpu_index, &sched_cpu); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident_by_processor( cpu_index, &sched_cpu ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_get_scheduler(task, &sched_task); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_get_scheduler( task, &sched_task ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - if (sched_task != sched_cpu) { + if ( sched_task != sched_cpu ) { rtems_task_priority prio; - CPU_FILL(&set); - sc = rtems_task_set_affinity(task, sizeof(set), &set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + CPU_FILL( &set ); + sc = rtems_task_set_affinity( task, sizeof( set ), &set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - prio = set_prio(task, RTEMS_CURRENT_PRIORITY); - sc = rtems_task_set_scheduler(task, sched_cpu, prio); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + prio = set_prio( task, RTEMS_CURRENT_PRIORITY ); + sc = rtems_task_set_scheduler( task, sched_cpu, prio ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - CPU_ZERO(&set); - CPU_SET((int) cpu_index, &set); - sc = rtems_task_set_affinity(task, sizeof(set), &set); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + CPU_ZERO( &set ); + CPU_SET( (int) cpu_index, &set ); + sc = rtems_task_set_affinity( task, sizeof( set ), &set ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void send_events(rtems_id task, rtems_event_set events) +static void send_events( rtems_id task, rtems_event_set events ) { rtems_status_code sc; - sc = rtems_event_send(task, events); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_event_send( task, events ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static rtems_event_set wait_for_events(void) +static rtems_event_set wait_for_events( void ) { - rtems_event_set events; + rtems_event_set events; rtems_status_code sc; sc = rtems_event_receive( @@ -150,54 +150,54 @@ static rtems_event_set wait_for_events(void) RTEMS_NO_TIMEOUT, &events ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); return events; } -static void pin(bool blocked) +static void pin( bool blocked ) { Per_CPU_Control *cpu_self; - Thread_Control *executing; + Thread_Control *executing; cpu_self = _Thread_Dispatch_disable(); - executing = _Per_CPU_Get_executing(cpu_self); + executing = _Per_CPU_Get_executing( cpu_self ); - if (blocked) { - _Thread_Set_state(executing, STATES_SUSPENDED); + if ( blocked ) { + _Thread_Set_state( executing, STATES_SUSPENDED ); } - _Thread_Pin(executing); + _Thread_Pin( executing ); - if (blocked) { - _Thread_Clear_state(executing, STATES_SUSPENDED); + if ( blocked ) { + _Thread_Clear_state( executing, STATES_SUSPENDED ); } - _Thread_Dispatch_enable(cpu_self); + _Thread_Dispatch_enable( cpu_self ); } -static void unpin(bool blocked) +static void unpin( bool blocked ) { Per_CPU_Control *cpu_self; - Thread_Control *executing; + Thread_Control *executing; cpu_self = _Thread_Dispatch_disable(); - executing = _Per_CPU_Get_executing(cpu_self); + executing = _Per_CPU_Get_executing( cpu_self ); - if (blocked) { - _Thread_Set_state(executing, STATES_SUSPENDED); + if ( blocked ) { + _Thread_Set_state( executing, STATES_SUSPENDED ); } - _Thread_Unpin(executing, cpu_self); + _Thread_Unpin( executing, cpu_self ); - if (blocked) { - _Thread_Clear_state(executing, STATES_SUSPENDED); + if ( blocked ) { + _Thread_Clear_state( executing, STATES_SUSPENDED ); } - _Thread_Dispatch_enable(cpu_self); + _Thread_Dispatch_enable( cpu_self ); } -static void event_task(rtems_task_argument arg) +static void event_task( rtems_task_argument arg ) { (void) arg; @@ -205,7 +205,7 @@ static void event_task(rtems_task_argument arg) ctx = (test_context *) arg; - while (true) { + while ( true ) { rtems_event_set events; events = wait_for_events(); @@ -214,387 +214,391 @@ static void event_task(rtems_task_argument arg) * The order of event processing is important! */ - if ((events & EVENT_MTX_LOCK) != 0) { - rtems_mutex_lock(&ctx->mtx); + if ( ( events & EVENT_MTX_LOCK ) != 0 ) { + rtems_mutex_lock( &ctx->mtx ); } - if ((events & EVENT_MTX_UNLOCK) != 0) { - rtems_mutex_unlock(&ctx->mtx); + if ( ( events & EVENT_MTX_UNLOCK ) != 0 ) { + rtems_mutex_unlock( &ctx->mtx ); } - if ((events & EVENT_MOVE_BUSY_TO_CPU_0) != 0) { - set_affinity(ctx->busy, 0); + if ( ( events & EVENT_MOVE_BUSY_TO_CPU_0 ) != 0 ) { + set_affinity( ctx->busy, 0 ); } - if ((events & EVENT_MOVE_BUSY_TO_CPU_1) != 0) { - set_affinity(ctx->busy, 1); + if ( ( events & EVENT_MOVE_BUSY_TO_CPU_1 ) != 0 ) { + set_affinity( ctx->busy, 1 ); } - if ((events & EVENT_MOVE_SELF_TO_CPU_0) != 0) { - set_affinity(RTEMS_SELF, 0); + if ( ( events & EVENT_MOVE_SELF_TO_CPU_0 ) != 0 ) { + set_affinity( RTEMS_SELF, 0 ); } - if ((events & EVENT_MOVE_SELF_TO_CPU_1) != 0) { - set_affinity(RTEMS_SELF, 1); + if ( ( events & EVENT_MOVE_SELF_TO_CPU_1 ) != 0 ) { + set_affinity( RTEMS_SELF, 1 ); } - if ((events & EVENT_SET_SELF_PRIO_TO_LOW) != 0) { - set_prio(RTEMS_SELF, PRIO_LOW); + if ( ( events & EVENT_SET_SELF_PRIO_TO_LOW ) != 0 ) { + set_prio( RTEMS_SELF, PRIO_LOW ); } - if ((events & EVENT_SET_BUSY_PRIO_TO_IDLE) != 0) { - set_prio(ctx->busy, PRIO_IDLE); + if ( ( events & EVENT_SET_BUSY_PRIO_TO_IDLE ) != 0 ) { + set_prio( ctx->busy, PRIO_IDLE ); } - if ((events & EVENT_SET_FLAG) != 0) { + if ( ( events & EVENT_SET_FLAG ) != 0 ) { ctx->flag = true; } - if ((events & EVENT_WAKEUP_MASTER) != 0) { - send_events(ctx->master, EVENT_WAKEUP_MASTER); + if ( ( events & EVENT_WAKEUP_MASTER ) != 0 ) { + send_events( ctx->master, EVENT_WAKEUP_MASTER ); } } } -static void busy_task(rtems_task_argument arg) +static void busy_task( rtems_task_argument arg ) { (void) arg; - _CPU_Thread_Idle_body(0); + _CPU_Thread_Idle_body( 0 ); } -static const char *blocked_or_ready(bool blocked) +static const char *blocked_or_ready( bool blocked ) { return blocked ? "blocked" : "ready"; } -static void reconfigure_scheduler(test_context *ctx) +static void reconfigure_scheduler( test_context *ctx ) { rtems_status_code sc; - puts("reconfigure scheduler"); + puts( "reconfigure scheduler" ); - set_prio(ctx->master, PRIO_MIDDLE); - set_prio(ctx->event, PRIO_LOW); - set_prio(ctx->event_2, PRIO_VERY_LOW); - set_prio(ctx->busy, PRIO_IDLE); + set_prio( ctx->master, PRIO_MIDDLE ); + set_prio( ctx->event, PRIO_LOW ); + set_prio( ctx->event_2, PRIO_VERY_LOW ); + set_prio( ctx->busy, PRIO_IDLE ); - set_affinity(ctx->master, 0); - set_affinity(ctx->event, 0); - set_affinity(ctx->event_2, 0); - set_affinity(ctx->busy, 0); + set_affinity( ctx->master, 0 ); + set_affinity( ctx->event, 0 ); + set_affinity( ctx->event_2, 0 ); + set_affinity( ctx->busy, 0 ); - sc = rtems_scheduler_remove_processor(ctx->sched_a, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_remove_processor( ctx->sched_a, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_add_processor(ctx->sched_b, 1); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_add_processor( ctx->sched_b, 1 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } -static void test_simple_pin_unpin(test_context *ctx, int run) +static void test_simple_pin_unpin( test_context *ctx, int run ) { Per_CPU_Control *cpu_self; - Thread_Control *executing; + Thread_Control *executing; - printf("test simple wait unpin (run %i)\n", run); + printf( "test simple wait unpin (run %i)\n", run ); - set_affinity(ctx->busy, 0); - set_prio(ctx->busy, PRIO_IDLE); - set_prio(RTEMS_SELF, PRIO_MIDDLE); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + set_affinity( ctx->busy, 0 ); + set_prio( ctx->busy, PRIO_IDLE ); + set_prio( RTEMS_SELF, PRIO_MIDDLE ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); cpu_self = _Thread_Dispatch_disable(); - executing = _Per_CPU_Get_executing(cpu_self); - _Thread_Pin(executing); + executing = _Per_CPU_Get_executing( cpu_self ); + _Thread_Pin( executing ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - _Thread_Unpin(executing, cpu_self); - _Thread_Dispatch_enable(cpu_self); + _Thread_Unpin( executing, cpu_self ); + _Thread_Dispatch_enable( cpu_self ); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); } -static void test_pin_wait_unpin(test_context *ctx, bool blocked, int run) -{ - printf("test pin wait unpin (%s, run %i)\n", blocked_or_ready(blocked), run); - - set_affinity(ctx->busy, 0); - set_prio(ctx->busy, PRIO_IDLE); - set_prio(RTEMS_SELF, PRIO_MIDDLE); - set_prio(ctx->event, PRIO_LOW); - set_affinity(ctx->event, 1); - rtems_test_assert(rtems_scheduler_get_processor() == 1); - - pin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 1); - - send_events(ctx->event, EVENT_WAKEUP_MASTER); - rtems_test_assert(rtems_scheduler_get_processor() == 1); - wait_for_events(); - rtems_test_assert(rtems_scheduler_get_processor() == 1); - - set_prio(ctx->busy, PRIO_HIGH); - set_affinity(ctx->busy, 0); - unpin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 1); -} - -static void test_pin_preempt_unpin(test_context *ctx, bool blocked, int run) +static void test_pin_wait_unpin( test_context *ctx, bool blocked, int run ) { printf( - "test pin preempt unpin (%s, run %i)\n", - blocked_or_ready(blocked), + "test pin wait unpin (%s, run %i)\n", + blocked_or_ready( blocked ), run ); - set_prio(RTEMS_SELF, PRIO_MIDDLE); - set_prio(ctx->event, PRIO_VERY_HIGH); - set_prio(ctx->busy, PRIO_HIGH); - set_affinity(ctx->event, 0); - set_affinity(ctx->busy, 0); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + set_affinity( ctx->busy, 0 ); + set_prio( ctx->busy, PRIO_IDLE ); + set_prio( RTEMS_SELF, PRIO_MIDDLE ); + set_prio( ctx->event, PRIO_LOW ); + set_affinity( ctx->event, 1 ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - pin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + pin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); + + send_events( ctx->event, EVENT_WAKEUP_MASTER ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); + wait_for_events(); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); + + set_prio( ctx->busy, PRIO_HIGH ); + set_affinity( ctx->busy, 0 ); + unpin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); +} + +static void test_pin_preempt_unpin( test_context *ctx, bool blocked, int run ) +{ + printf( + "test pin preempt unpin (%s, run %i)\n", + blocked_or_ready( blocked ), + run + ); + + set_prio( RTEMS_SELF, PRIO_MIDDLE ); + set_prio( ctx->event, PRIO_VERY_HIGH ); + set_prio( ctx->busy, PRIO_HIGH ); + set_affinity( ctx->event, 0 ); + set_affinity( ctx->busy, 0 ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); + + pin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); ctx->flag = false; send_events( ctx->event, - EVENT_MOVE_BUSY_TO_CPU_1 | EVENT_SET_SELF_PRIO_TO_LOW - | EVENT_SET_BUSY_PRIO_TO_IDLE | EVENT_SET_FLAG + EVENT_MOVE_BUSY_TO_CPU_1 | EVENT_SET_SELF_PRIO_TO_LOW | + EVENT_SET_BUSY_PRIO_TO_IDLE | EVENT_SET_FLAG ); - while (!ctx->flag) { - rtems_test_assert(rtems_scheduler_get_processor() == 1); + while ( !ctx->flag ) { + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); } - set_affinity(ctx->busy, 0); - unpin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + set_affinity( ctx->busy, 0 ); + unpin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); } static void test_pin_home_no_help_unpin( test_context *ctx, - bool blocked, - int run + bool blocked, + int run ) { rtems_status_code sc; printf( "test pin home no help unpin (%s, run %i)\n", - blocked_or_ready(blocked), + blocked_or_ready( blocked ), run ); - set_affinity(ctx->busy, 1); - set_prio(ctx->busy, PRIO_IDLE); - set_prio(RTEMS_SELF, PRIO_MIDDLE); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + set_affinity( ctx->busy, 1 ); + set_prio( ctx->busy, PRIO_IDLE ); + set_prio( RTEMS_SELF, PRIO_MIDDLE ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - pin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + pin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - sc = rtems_task_set_scheduler(RTEMS_SELF, ctx->sched_b, 1); - rtems_test_assert(sc == RTEMS_RESOURCE_IN_USE); + sc = rtems_task_set_scheduler( RTEMS_SELF, ctx->sched_b, 1 ); + rtems_test_assert( sc == RTEMS_RESOURCE_IN_USE ); - rtems_mutex_lock(&ctx->mtx); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_mutex_lock( &ctx->mtx ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - set_affinity(ctx->event, 1); - set_prio(ctx->event, PRIO_MIDDLE); + set_affinity( ctx->event, 1 ); + set_prio( ctx->event, PRIO_MIDDLE ); - send_events(ctx->event, EVENT_MTX_LOCK); - set_prio(ctx->event_2, PRIO_LOW); - set_affinity(ctx->event_2, 1); - send_events(ctx->event_2, EVENT_WAKEUP_MASTER); + send_events( ctx->event, EVENT_MTX_LOCK ); + set_prio( ctx->event_2, PRIO_LOW ); + set_affinity( ctx->event_2, 1 ); + send_events( ctx->event_2, EVENT_WAKEUP_MASTER ); wait_for_events(); /* Now the event task can help us */ - rtems_test_assert(ctx->mtx._Queue._heads != NULL); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( ctx->mtx._Queue._heads != NULL ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - set_affinity(ctx->event_2, 0); - set_affinity(ctx->busy, 1); - set_prio(ctx->busy, PRIO_HIGH); + set_affinity( ctx->event_2, 0 ); + set_affinity( ctx->busy, 1 ); + set_prio( ctx->busy, PRIO_HIGH ); send_events( ctx->event_2, - EVENT_MOVE_BUSY_TO_CPU_0 | EVENT_MOVE_SELF_TO_CPU_1 - | EVENT_SET_SELF_PRIO_TO_LOW | EVENT_SET_BUSY_PRIO_TO_IDLE + EVENT_MOVE_BUSY_TO_CPU_0 | EVENT_MOVE_SELF_TO_CPU_1 | + EVENT_SET_SELF_PRIO_TO_LOW | EVENT_SET_BUSY_PRIO_TO_IDLE ); - set_prio(ctx->event_2, PRIO_VERY_HIGH); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + set_prio( ctx->event_2, PRIO_VERY_HIGH ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - rtems_mutex_unlock(&ctx->mtx); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_mutex_unlock( &ctx->mtx ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - send_events(ctx->event, EVENT_WAKEUP_MASTER | EVENT_MTX_UNLOCK); + send_events( ctx->event, EVENT_WAKEUP_MASTER | EVENT_MTX_UNLOCK ); wait_for_events(); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - unpin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + unpin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); } static void test_pin_foreign_no_help_unpin( test_context *ctx, - bool blocked, - int run + bool blocked, + int run ) { printf( "test pin foreign no help unpin (%s, run %i)\n", - blocked_or_ready(blocked), + blocked_or_ready( blocked ), run ); - set_affinity(ctx->busy, 1); - set_prio(ctx->busy, PRIO_IDLE); - set_prio(RTEMS_SELF, PRIO_MIDDLE); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + set_affinity( ctx->busy, 1 ); + set_prio( ctx->busy, PRIO_IDLE ); + set_prio( RTEMS_SELF, PRIO_MIDDLE ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - rtems_mutex_lock(&ctx->mtx); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_mutex_lock( &ctx->mtx ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - set_affinity(ctx->event, 1); - set_prio(ctx->event, PRIO_MIDDLE); - send_events(ctx->event, EVENT_MTX_LOCK); - set_prio(ctx->event_2, PRIO_LOW); - set_affinity(ctx->event_2, 1); - send_events(ctx->event_2, EVENT_WAKEUP_MASTER); + set_affinity( ctx->event, 1 ); + set_prio( ctx->event, PRIO_MIDDLE ); + send_events( ctx->event, EVENT_MTX_LOCK ); + set_prio( ctx->event_2, PRIO_LOW ); + set_affinity( ctx->event_2, 1 ); + send_events( ctx->event_2, EVENT_WAKEUP_MASTER ); wait_for_events(); /* Now the event task can help us */ - rtems_test_assert(ctx->mtx._Queue._heads != NULL); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( ctx->mtx._Queue._heads != NULL ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); /* Request help */ - set_affinity(ctx->busy, 0); - set_prio(ctx->busy, PRIO_HIGH); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + set_affinity( ctx->busy, 0 ); + set_prio( ctx->busy, PRIO_HIGH ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); /* Pin while using foreign scheduler */ - pin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + pin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - set_affinity(ctx->event_2, 1); + set_affinity( ctx->event_2, 1 ); send_events( ctx->event_2, - EVENT_MOVE_BUSY_TO_CPU_1 | EVENT_MOVE_SELF_TO_CPU_0 - | EVENT_SET_SELF_PRIO_TO_LOW | EVENT_SET_BUSY_PRIO_TO_IDLE + EVENT_MOVE_BUSY_TO_CPU_1 | EVENT_MOVE_SELF_TO_CPU_0 | + EVENT_SET_SELF_PRIO_TO_LOW | EVENT_SET_BUSY_PRIO_TO_IDLE ); - set_prio(ctx->event_2, PRIO_VERY_HIGH); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + set_prio( ctx->event_2, PRIO_VERY_HIGH ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); - unpin(blocked); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + unpin( blocked ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - set_prio(ctx->busy, PRIO_IDLE); - rtems_mutex_unlock(&ctx->mtx); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + set_prio( ctx->busy, PRIO_IDLE ); + rtems_mutex_unlock( &ctx->mtx ); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); - send_events(ctx->event, EVENT_WAKEUP_MASTER | EVENT_MTX_UNLOCK); + send_events( ctx->event, EVENT_WAKEUP_MASTER | EVENT_MTX_UNLOCK ); wait_for_events(); - rtems_test_assert(rtems_scheduler_get_processor() == 0); + rtems_test_assert( rtems_scheduler_get_processor() == 0 ); } -static void test(test_context *ctx) +static void test( test_context *ctx ) { rtems_status_code sc; - int run; + int run; ctx->master = rtems_task_self(); - rtems_mutex_init(&ctx->mtx, "test"); + rtems_mutex_init( &ctx->mtx, "test" ); - sc = rtems_scheduler_ident(SCHED_A, &ctx->sched_a); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_A, &ctx->sched_a ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_scheduler_ident(SCHED_B, &ctx->sched_b); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_B, &ctx->sched_b ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); sc = rtems_task_create( - rtems_build_name('B', 'U', 'S', 'Y'), + rtems_build_name( 'B', 'U', 'S', 'Y' ), PRIO_HIGH, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->busy ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->busy, busy_task, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->busy, busy_task, (rtems_task_argument) ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - set_affinity(ctx->busy, 0); - set_prio(ctx->busy, PRIO_IDLE); - rtems_test_assert(rtems_scheduler_get_processor() == 1); + set_affinity( ctx->busy, 0 ); + set_prio( ctx->busy, PRIO_IDLE ); + rtems_test_assert( rtems_scheduler_get_processor() == 1 ); sc = rtems_task_create( - rtems_build_name('E', 'V', 'T', '1'), + rtems_build_name( 'E', 'V', 'T', '1' ), PRIO_LOW, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->event ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->event, event_task, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->event, event_task, (rtems_task_argument) ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - send_events(ctx->event, EVENT_WAKEUP_MASTER); + send_events( ctx->event, EVENT_WAKEUP_MASTER ); wait_for_events(); sc = rtems_task_create( - rtems_build_name('E', 'V', 'T', '2'), + rtems_build_name( 'E', 'V', 'T', '2' ), PRIO_LOW, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, &ctx->event_2 ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(ctx->event_2, event_task, (rtems_task_argument) ctx); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( ctx->event_2, event_task, (rtems_task_argument) ctx ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - send_events(ctx->event_2, EVENT_WAKEUP_MASTER); + send_events( ctx->event_2, EVENT_WAKEUP_MASTER ); wait_for_events(); - for (run = 1; run <= 3; ++run) { - test_simple_pin_unpin(ctx, run); - test_pin_wait_unpin(ctx, true, run); - test_pin_wait_unpin(ctx, false, run); - test_pin_preempt_unpin(ctx, true, run); - test_pin_preempt_unpin(ctx, false, run); + for ( run = 1; run <= 3; ++run ) { + test_simple_pin_unpin( ctx, run ); + test_pin_wait_unpin( ctx, true, run ); + test_pin_wait_unpin( ctx, false, run ); + test_pin_preempt_unpin( ctx, true, run ); + test_pin_preempt_unpin( ctx, false, run ); } - reconfigure_scheduler(ctx); + reconfigure_scheduler( ctx ); - for (run = 1; run <= 3; ++run) { - test_pin_home_no_help_unpin(ctx, true, run); - test_pin_home_no_help_unpin(ctx, false, run); - test_pin_foreign_no_help_unpin(ctx, true, run); - test_pin_foreign_no_help_unpin(ctx, false, run); + for ( run = 1; run <= 3; ++run ) { + test_pin_home_no_help_unpin( ctx, true, run ); + test_pin_home_no_help_unpin( ctx, false, run ); + test_pin_foreign_no_help_unpin( ctx, true, run ); + test_pin_foreign_no_help_unpin( ctx, false, run ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; TEST_BEGIN(); - if (rtems_scheduler_get_processor_maximum() == CPU_COUNT) { - test(&test_instance); + if ( rtems_scheduler_get_processor_maximum() == CPU_COUNT ) { + test( &test_instance ); } else { - puts("warning: wrong processor count to run the test"); + puts( "warning: wrong processor count to run the test" ); } TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER @@ -614,17 +618,17 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_EDF_SMP(a); +RTEMS_SCHEDULER_EDF_SMP( a ); -RTEMS_SCHEDULER_EDF_SMP(b); +RTEMS_SCHEDULER_EDF_SMP( b ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(a, SCHED_A), \ - RTEMS_SCHEDULER_TABLE_EDF_SMP(b, SCHED_B) \ +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( a, SCHED_A ), \ + RTEMS_SCHEDULER_TABLE_EDF_SMP( b, SCHED_B ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) #define CONFIGURE_INIT diff --git a/testsuites/smptests/smpunsupported01/init.c b/testsuites/smptests/smpunsupported01/init.c index 0033ab832a..33a465b1a2 100644 --- a/testsuites/smptests/smpunsupported01/init.c +++ b/testsuites/smptests/smpunsupported01/init.c @@ -34,51 +34,51 @@ const char rtems_test_name[] = "SMPUNSUPPORTED 1"; -static void test(void) +static void test( void ) { rtems_status_code sc; - rtems_mode mode; - rtems_id id; + rtems_mode mode; + rtems_id id; - sc = rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &mode); - rtems_test_assert(sc == RTEMS_NOT_IMPLEMENTED); + sc = rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &mode ); + rtems_test_assert( sc == RTEMS_NOT_IMPLEMENTED ); sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), RTEMS_MINIMUM_PRIORITY, RTEMS_MINIMUM_STACK_SIZE, RTEMS_NO_PREEMPT, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_UNSATISFIED); + rtems_test_assert( sc == RTEMS_UNSATISFIED ); - mode = RTEMS_INTERRUPT_LEVEL(0); - if (mode == 0) { - sc = rtems_task_mode(mode, RTEMS_INTERRUPT_MASK, &mode); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + mode = RTEMS_INTERRUPT_LEVEL( 0 ); + if ( mode == 0 ) { + sc = rtems_task_mode( mode, RTEMS_INTERRUPT_MASK, &mode ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - mode = RTEMS_INTERRUPT_LEVEL(1); - if (mode != 0) { - sc = rtems_task_mode(mode, RTEMS_INTERRUPT_MASK, &mode); - rtems_test_assert(sc == RTEMS_NOT_IMPLEMENTED); + mode = RTEMS_INTERRUPT_LEVEL( 1 ); + if ( mode != 0 ) { + sc = rtems_task_mode( mode, RTEMS_INTERRUPT_MASK, &mode ); + rtems_test_assert( sc == RTEMS_NOT_IMPLEMENTED ); sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), RTEMS_MINIMUM_PRIORITY, RTEMS_MINIMUM_STACK_SIZE, mode, RTEMS_DEFAULT_ATTRIBUTES, &id ); - rtems_test_assert(sc == RTEMS_UNSATISFIED); + rtems_test_assert( sc == RTEMS_UNSATISFIED ); } else { - puts("RTEMS_INTERRUPT_LEVEL(1) not supported on this platform"); + puts( "RTEMS_INTERRUPT_LEVEL(1) not supported on this platform" ); } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -87,7 +87,7 @@ static void Init(rtems_task_argument arg) test(); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER diff --git a/testsuites/smptests/smpwakeafter01/init.c b/testsuites/smptests/smpwakeafter01/init.c index bf86149d2b..d5cb82908a 100644 --- a/testsuites/smptests/smpwakeafter01/init.c +++ b/testsuites/smptests/smpwakeafter01/init.c @@ -43,110 +43,110 @@ const char rtems_test_name[] = "SMPWAKEAFTER 1"; #define INTERVAL_COUNT 8 -#define SCHED_A rtems_build_name(' ', ' ', ' ', 'A') +#define SCHED_A rtems_build_name( ' ', ' ', ' ', 'A' ) -#define SCHED_B rtems_build_name(' ', ' ', ' ', 'B') +#define SCHED_B rtems_build_name( ' ', ' ', ' ', 'B' ) -static rtems_id task_ids[CPU_COUNT][INTERVAL_COUNT]; +static rtems_id task_ids[ CPU_COUNT ][ INTERVAL_COUNT ]; -static const rtems_interval intervals[INTERVAL_COUNT] = +static const rtems_interval intervals[ INTERVAL_COUNT ] = { 1, 2, 3, 5, 7, 11, 13, 17 }; -static uint32_t counts[CPU_COUNT][INTERVAL_COUNT]; +static uint32_t counts[ CPU_COUNT ][ INTERVAL_COUNT ]; -static rtems_task_argument make_arg(uint32_t i, uint32_t j) +static rtems_task_argument make_arg( uint32_t i, uint32_t j ) { - return (i << 8) | (j << 0); + return ( i << 8 ) | ( j << 0 ); } -static void get_indices(rtems_task_argument arg, uint32_t *i, uint32_t *j) +static void get_indices( rtems_task_argument arg, uint32_t *i, uint32_t *j ) { - *i = (arg >> 8) & 0xff; - *j = (arg >> 0) & 0xff; + *i = ( arg >> 8 ) & 0xff; + *j = ( arg >> 0 ) & 0xff; } -static void task(rtems_task_argument arg) +static void task( rtems_task_argument arg ) { - uint32_t i; - uint32_t j; + uint32_t i; + uint32_t j; rtems_interval ticks; - get_indices(arg, &i, &j); - ticks = intervals[j]; + get_indices( arg, &i, &j ); + ticks = intervals[ j ]; - while (true) { + while ( true ) { rtems_status_code sc; - ++counts[i][j]; + ++counts[ i ][ j ]; - sc = rtems_task_wake_after(ticks); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( ticks ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } -static void test(void) +static void test( void ) { rtems_status_code sc; - uint32_t test_time_in_seconds = 10; - uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); - uint32_t i; + uint32_t test_time_in_seconds = 10; + uint32_t cpu_count = rtems_scheduler_get_processor_maximum(); + uint32_t i; - for (i = 0; i < cpu_count; ++i) { + for ( i = 0; i < cpu_count; ++i ) { rtems_id scheduler_id; uint32_t j; - if (i != 1) { - sc = rtems_scheduler_ident(SCHED_A, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + if ( i != 1 ) { + sc = rtems_scheduler_ident( SCHED_A, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } else { - sc = rtems_scheduler_ident(SCHED_B, &scheduler_id); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_scheduler_ident( SCHED_B, &scheduler_id ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (j = 0; j < INTERVAL_COUNT; ++j) { + for ( j = 0; j < INTERVAL_COUNT; ++j ) { sc = rtems_task_create( - rtems_build_name('T', 'A', 'S', 'K'), + rtems_build_name( 'T', 'A', 'S', 'K' ), 255, RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES, RTEMS_DEFAULT_ATTRIBUTES, - &task_ids[i][j] + &task_ids[ i ][ j ] ); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_set_scheduler(task_ids[i][j], scheduler_id, 2); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_set_scheduler( task_ids[ i ][ j ], scheduler_id, 2 ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); - sc = rtems_task_start(task_ids[i][j], task, make_arg(i, j)); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_start( task_ids[ i ][ j ], task, make_arg( i, j ) ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } } - for (i = 0; i < test_time_in_seconds; ++i) { - printf("%" PRIu32 " seconds remaining\n", test_time_in_seconds - i); + for ( i = 0; i < test_time_in_seconds; ++i ) { + printf( "%" PRIu32 " seconds remaining\n", test_time_in_seconds - i ); - sc = rtems_task_wake_after(rtems_clock_get_ticks_per_second()); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + sc = rtems_task_wake_after( rtems_clock_get_ticks_per_second() ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); } - for (i = 0; i < cpu_count; ++i) { + for ( i = 0; i < cpu_count; ++i ) { uint32_t j; - for (j = 0; j < INTERVAL_COUNT; ++j) { - sc = rtems_task_delete(task_ids[i][j]); - rtems_test_assert(sc == RTEMS_SUCCESSFUL); + for ( j = 0; j < INTERVAL_COUNT; ++j ) { + sc = rtems_task_delete( task_ids[ i ][ j ] ); + rtems_test_assert( sc == RTEMS_SUCCESSFUL ); printf( "counts[%" PRIu32 "][%" PRIu32 "] = %" PRIu32 "\n", i, j, - counts[i][j] + counts[ i ][ j ] ); } } } -static void Init(rtems_task_argument arg) +static void Init( rtems_task_argument arg ) { (void) arg; @@ -154,14 +154,14 @@ static void Init(rtems_task_argument arg) TEST_BEGIN(); - rtems_resource_snapshot_take(&snapshot); + rtems_resource_snapshot_take( &snapshot ); test(); - rtems_test_assert(rtems_resource_snapshot_check(&snapshot)); + rtems_test_assert( rtems_resource_snapshot_check( &snapshot ) ); TEST_END(); - rtems_test_exit(0); + rtems_test_exit( 0 ); } #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER @@ -177,49 +177,49 @@ static void Init(rtems_task_argument arg) #include -RTEMS_SCHEDULER_PRIORITY_SMP(a, CONFIGURE_MAXIMUM_PRIORITY + 1); +RTEMS_SCHEDULER_PRIORITY_SMP( a, CONFIGURE_MAXIMUM_PRIORITY + 1 ); -RTEMS_SCHEDULER_PRIORITY_SMP(b, CONFIGURE_MAXIMUM_PRIORITY + 1); +RTEMS_SCHEDULER_PRIORITY_SMP( b, CONFIGURE_MAXIMUM_PRIORITY + 1 ); -#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ - RTEMS_SCHEDULER_TABLE_PRIORITY_SMP(a, SCHED_A), \ - RTEMS_SCHEDULER_TABLE_PRIORITY_SMP(b, SCHED_B) +#define CONFIGURE_SCHEDULER_TABLE_ENTRIES \ + RTEMS_SCHEDULER_TABLE_PRIORITY_SMP( a, SCHED_A ), \ + RTEMS_SCHEDULER_TABLE_PRIORITY_SMP( b, SCHED_B ) -#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY), \ - RTEMS_SCHEDULER_ASSIGN(1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL), \ - RTEMS_SCHEDULER_ASSIGN(0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL) +#define CONFIGURE_SCHEDULER_ASSIGNMENTS \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_MANDATORY ), \ + RTEMS_SCHEDULER_ASSIGN( 1, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ), \ + RTEMS_SCHEDULER_ASSIGN( 0, RTEMS_SCHEDULER_ASSIGN_PROCESSOR_OPTIONAL ) -#define CONFIGURE_MAXIMUM_TASKS (1 + CPU_COUNT * INTERVAL_COUNT) +#define CONFIGURE_MAXIMUM_TASKS ( 1 + CPU_COUNT * INTERVAL_COUNT ) #define CONFIGURE_INITIAL_EXTENSIONS RTEMS_TEST_INITIAL_EXTENSION