Changeset b89b442 in rtems


Ignore:
Timestamp:
Feb 14, 2020, 2:51:01 PM (6 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
5, master
Children:
5857e83c
Parents:
33d89af
git-author:
Sebastian Huber <sebastian.huber@…> (02/14/20 14:51:01)
git-committer:
Sebastian Huber <sebastian.huber@…> (02/14/20 15:02:54)
Message:

smpschededf02: Improve readability

File:
1 edited

Legend:

Unmodified
Added
Removed
  • testsuites/smptests/smpschededf02/init.c

    r33d89af rb89b442  
    11/*
    2  * Copyright (c) 2016, 2018 embedded brains GmbH.  All rights reserved.
     2 * Copyright (c) 2016, 2020 embedded brains GmbH.  All rights reserved.
    33 *
    44 *  embedded brains GmbH
     
    1414
    1515#ifdef HAVE_CONFIG_H
    16   #include "config.h"
     16#include "config.h"
    1717#endif
    1818
    19 #include "tmacros.h"
     19#include <tmacros.h>
    2020
    2121#include <rtems.h>
     
    3131#define A(cpu0, cpu1) ((cpu1 << 1) | cpu0)
    3232
    33 #define IDLE UINT8_C(255)
    34 
    35 #define NAME rtems_build_name('E', 'D', 'F', ' ')
     33typedef enum {
     34  T0,
     35  T1,
     36  T2,
     37  T3,
     38  T4,
     39  IDLE
     40} task_index;
    3641
    3742typedef struct {
     
    4449  } kind;
    4550
    46   size_t index;
     51  task_index index;
    4752
    4853  struct {
     
    103108static const test_action test_actions[] = {
    104109  RESET,
    105   UNBLOCK(      0,              0, IDLE),
    106   UNBLOCK(      1,              0,    1),
    107   UNBLOCK(      3,              0,    1),
    108   SET_PRIORITY( 1,  P(2),       0,    1),
    109   SET_PRIORITY( 3,  P(1),       0,    3),
    110   BLOCK(        3,              0,    1),
    111   SET_AFFINITY( 1,  A(1, 1),    0,    1),
    112   SET_AFFINITY( 1,  A(1, 0),    1,    0),
    113   SET_AFFINITY( 1,  A(1, 1),    1,    0),
    114   SET_AFFINITY( 1,  A(1, 0),    1,    0),
    115   SET_AFFINITY( 1,  A(0, 1),    0,    1),
    116   BLOCK(        0,           IDLE,    1),
    117   UNBLOCK(      0,              0,    1),
    118   BLOCK(        1,              0, IDLE),
    119   UNBLOCK(      1,              0,    1),
     110  UNBLOCK(      T0,             T0, IDLE),
     111  UNBLOCK(      T1,             T0,   T1),
     112  UNBLOCK(      T3,             T0,   T1),
     113  SET_PRIORITY( T1,  P(2),      T0,   T1),
     114  SET_PRIORITY( T3,  P(1),      T0,   T3),
     115  BLOCK(        T3,             T0,   T1),
     116  SET_AFFINITY( T1,  A(1, 1),   T0,   T1),
     117  SET_AFFINITY( T1,  A(1, 0),   T1,   T0),
     118  SET_AFFINITY( T1,  A(1, 1),   T1,   T0),
     119  SET_AFFINITY( T1,  A(1, 0),   T1,   T0),
     120  SET_AFFINITY( T1,  A(0, 1),   T0,   T1),
     121  BLOCK(        T0,           IDLE,   T1),
     122  UNBLOCK(      T0,             T0,   T1),
     123  BLOCK(        T1,             T0, IDLE),
     124  UNBLOCK(      T1,             T0,   T1),
    120125  /*
    121126   * Show that FIFO order is honoured across all threads of the same priority.
    122127   */
    123128  RESET,
    124   SET_PRIORITY( 1,  P(0),    IDLE, IDLE),
    125   SET_PRIORITY( 2,  P(1),    IDLE, IDLE),
    126   SET_PRIORITY( 3,  P(1),    IDLE, IDLE),
    127   SET_AFFINITY( 3,  A(1, 0), IDLE, IDLE),
    128   SET_PRIORITY( 4,  P(1),    IDLE, IDLE),
    129   SET_AFFINITY( 4,  A(1, 0), IDLE, IDLE),
    130   UNBLOCK(      0,              0, IDLE),
    131   UNBLOCK(      1,              0,    1),
    132   UNBLOCK(      2,              0,    1),
    133   UNBLOCK(      3,              0,    1),
    134   UNBLOCK(      4,              0,    1),
    135   BLOCK(        1,              0,    2),
    136   BLOCK(        2,              3,    0),
    137   BLOCK(        3,              4,    0),
     129  SET_PRIORITY( T1,  P(0),    IDLE, IDLE),
     130  SET_PRIORITY( T2,  P(1),    IDLE, IDLE),
     131  SET_PRIORITY( T3,  P(1),    IDLE, IDLE),
     132  SET_AFFINITY( T3,  A(1, 0), IDLE, IDLE),
     133  SET_PRIORITY( T4,  P(1),    IDLE, IDLE),
     134  SET_AFFINITY( T4,  A(1, 0), IDLE, IDLE),
     135  UNBLOCK(      T0,             T0, IDLE),
     136  UNBLOCK(      T1,             T0,   T1),
     137  UNBLOCK(      T2,             T0,   T1),
     138  UNBLOCK(      T3,             T0,   T1),
     139  UNBLOCK(      T4,             T0,   T1),
     140  BLOCK(        T1,             T0,   T2),
     141  BLOCK(        T2,             T3,   T0),
     142  BLOCK(        T3,             T4,   T0),
    138143  /*
    139144   * Schedule a high priority affine thread directly with a low priority affine
     
    142147   */
    143148  RESET,
    144   UNBLOCK(      0,              0, IDLE),
    145   UNBLOCK(      1,              0,    1),
    146   SET_PRIORITY( 1,  P(2),       0,    1),
    147   SET_AFFINITY( 3,  A(0, 1),    0,    1),
    148   UNBLOCK(      3,              0,    1),
    149   SET_PRIORITY( 2,  P(1),       0,    1),
    150   SET_AFFINITY( 2,  A(0, 1),    0,    1),
    151   UNBLOCK(      2,              0,    2),
    152   BLOCK(        1,              0,    2),
    153   BLOCK(        2,              0,    3),
     149  UNBLOCK(      T0,             T0, IDLE),
     150  UNBLOCK(      T1,             T0,   T1),
     151  SET_PRIORITY( T1,  P(2),      T0,   T1),
     152  SET_AFFINITY( T3,  A(0, 1),   T0,   T1),
     153  UNBLOCK(      T3,             T0,   T1),
     154  SET_PRIORITY( T2,  P(1),      T0,   T1),
     155  SET_AFFINITY( T2,  A(0, 1),   T0,   T1),
     156  UNBLOCK(      T2,             T0,   T2),
     157  BLOCK(        T1,             T0,   T2),
     158  BLOCK(        T2,             T0,   T3),
    154159  /* Force migration of a higher priority one-to-all thread */
    155160  RESET,
    156   UNBLOCK(      0,              0, IDLE),
    157   SET_AFFINITY( 1,  A(1, 0),    0, IDLE),
    158   UNBLOCK(      1,              1,    0),
     161  UNBLOCK(      T0,             T0, IDLE),
     162  SET_AFFINITY( T1,  A(1, 0),   T0, IDLE),
     163  UNBLOCK(      T1,             T1,   T0),
    159164  /*
    160165   * Block a one-to-one thread while having a non-empty affine ready queue on
     
    162167   */
    163168  RESET,
    164   SET_AFFINITY( 1,  A(1, 0), IDLE, IDLE),
    165   SET_AFFINITY( 3,  A(1, 0), IDLE, IDLE),
    166   UNBLOCK(      0,              0, IDLE),
    167   UNBLOCK(      1,              1,    0),
    168   UNBLOCK(      2,              1,    0),
    169   UNBLOCK(      3,              1,    0),
    170   BLOCK(        1,              2,    0),
    171   BLOCK(        0,              3,    2),
     169  SET_AFFINITY( T1,  A(1, 0), IDLE, IDLE),
     170  SET_AFFINITY( T3,  A(1, 0), IDLE, IDLE),
     171  UNBLOCK(      T0,             T0, IDLE),
     172  UNBLOCK(      T1,             T1,   T0),
     173  UNBLOCK(      T2,             T1,   T0),
     174  UNBLOCK(      T3,             T1,   T0),
     175  BLOCK(        T1,             T2,   T0),
     176  BLOCK(        T0,             T3,   T2),
    172177  /*
    173178   * Make sure that a one-to-one thread does not get the wrong processor
     
    175180   */
    176181  RESET,
    177   SET_AFFINITY( 1,  A(1, 0), IDLE, IDLE),
    178   SET_AFFINITY( 2,  A(1, 0), IDLE, IDLE),
    179   UNBLOCK(      0,              0, IDLE),
    180   UNBLOCK(      1,              1,    0),
    181   UNBLOCK(      2,              1,    0),
    182   BLOCK(        0,              1, IDLE),
     182  SET_AFFINITY( T1,  A(1, 0), IDLE, IDLE),
     183  SET_AFFINITY( T2,  A(1, 0), IDLE, IDLE),
     184  UNBLOCK(      T0,             T0, IDLE),
     185  UNBLOCK(      T1,             T1,   T0),
     186  UNBLOCK(      T2,             T1,   T0),
     187  BLOCK(        T0,             T1, IDLE),
    183188  RESET
    184189};
     
    250255
    251256  for (i = 0; i < CPU_COUNT; ++i) {
    252     size_t e;
     257    task_index e;
    253258    const Per_CPU_Control *c;
    254259    const Thread_Control *h;
     
    347352  for (i = 0; i < TASK_COUNT; ++i) {
    348353    sc = rtems_task_create(
    349       NAME,
     354      rtems_build_name(' ', ' ', 'T', '0' + i),
    350355      P(i),
    351356      RTEMS_MINIMUM_STACK_SIZE,
     
    360365  }
    361366
    362   sc = rtems_timer_create(NAME, &ctx->timer_id);
     367  sc = rtems_timer_create(
     368    rtems_build_name('A', 'C', 'T', 'N'),
     369    &ctx->timer_id
     370  );
    363371  rtems_test_assert(sc == RTEMS_SUCCESSFUL);
    364372
Note: See TracChangeset for help on using the changeset viewer.