source: rtems/testsuites/validation/tc-barrier-wait.c @ 34f279aa

Last change on this file since 34f279aa was 34f279aa, checked in by Sebastian Huber <sebastian.huber@…>, on Feb 24, 2021 at 4:59:32 PM

validation: Add comments to barrier tests

Unify code sections across tests.

  • Property mode set to 100644
File size: 17.4 KB
Line 
1/* SPDX-License-Identifier: BSD-2-Clause */
2
3/**
4 * @file
5 *
6 * @ingroup RTEMSTestCaseRtemsBarrierReqWait
7 */
8
9/*
10 * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de)
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 *    notice, this list of conditions and the following disclaimer in the
19 *    documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/*
35 * This file is part of the RTEMS quality process and was automatically
36 * generated.  If you find something that needs to be fixed or
37 * worded better please post a report or patch to an RTEMS mailing list
38 * or raise a bug report:
39 *
40 * https://www.rtems.org/bugs.html
41 *
42 * For information on updating and regenerating please refer to the How-To
43 * section in the Software Requirements Engineering chapter of the
44 * RTEMS Software Engineering manual.  The manual is provided as a part of
45 * a release.  For development sources please refer to the online
46 * documentation at:
47 *
48 * https://docs.rtems.org
49 */
50
51#ifdef HAVE_CONFIG_H
52#include "config.h"
53#endif
54
55#include <rtems.h>
56#include <string.h>
57
58#include <rtems/test.h>
59
60/**
61 * @defgroup RTEMSTestCaseRtemsBarrierReqWait spec:/rtems/barrier/req/wait
62 *
63 * @ingroup RTEMSTestSuiteTestsuitesValidation0
64 *
65 * @{
66 */
67
68typedef enum {
69  RtemsBarrierReqWait_Pre_Barrier_NoObj,
70  RtemsBarrierReqWait_Pre_Barrier_Manual,
71  RtemsBarrierReqWait_Pre_Barrier_Auto,
72  RtemsBarrierReqWait_Pre_Barrier_NA
73} RtemsBarrierReqWait_Pre_Barrier;
74
75typedef enum {
76  RtemsBarrierReqWait_Pre_Timeout_Ticks,
77  RtemsBarrierReqWait_Pre_Timeout_Forever,
78  RtemsBarrierReqWait_Pre_Timeout_NA
79} RtemsBarrierReqWait_Pre_Timeout;
80
81typedef enum {
82  RtemsBarrierReqWait_Pre_Satisfy_Never,
83  RtemsBarrierReqWait_Pre_Satisfy_Wait,
84  RtemsBarrierReqWait_Pre_Satisfy_Release,
85  RtemsBarrierReqWait_Pre_Satisfy_Delete,
86  RtemsBarrierReqWait_Pre_Satisfy_NA
87} RtemsBarrierReqWait_Pre_Satisfy;
88
89typedef enum {
90  RtemsBarrierReqWait_Post_Status_Ok,
91  RtemsBarrierReqWait_Post_Status_InvId,
92  RtemsBarrierReqWait_Post_Status_Timeout,
93  RtemsBarrierReqWait_Post_Status_ObjDel,
94  RtemsBarrierReqWait_Post_Status_NoReturn,
95  RtemsBarrierReqWait_Post_Status_NA
96} RtemsBarrierReqWait_Post_Status;
97
98/**
99 * @brief Test context for spec:/rtems/barrier/req/wait test case.
100 */
101typedef struct {
102  rtems_id main_id;
103
104  rtems_id high_worker_id;
105
106  rtems_id low_worker_id;
107
108  rtems_id manual_release_id;
109
110  rtems_id auto_release_id;
111
112  rtems_id id;
113
114  rtems_interval timeout;
115
116  rtems_status_code status;
117
118  /**
119   * @brief This member defines the pre-condition states for the next action.
120   */
121  size_t pcs[ 3 ];
122
123  /**
124   * @brief This member indicates if the test action loop is currently
125   *   executed.
126   */
127  bool in_action_loop;
128} RtemsBarrierReqWait_Context;
129
130static RtemsBarrierReqWait_Context
131  RtemsBarrierReqWait_Instance;
132
133static const char * const RtemsBarrierReqWait_PreDesc_Barrier[] = {
134  "NoObj",
135  "Manual",
136  "Auto",
137  "NA"
138};
139
140static const char * const RtemsBarrierReqWait_PreDesc_Timeout[] = {
141  "Ticks",
142  "Forever",
143  "NA"
144};
145
146static const char * const RtemsBarrierReqWait_PreDesc_Satisfy[] = {
147  "Never",
148  "Wait",
149  "Release",
150  "Delete",
151  "NA"
152};
153
154static const char * const * const RtemsBarrierReqWait_PreDesc[] = {
155  RtemsBarrierReqWait_PreDesc_Barrier,
156  RtemsBarrierReqWait_PreDesc_Timeout,
157  RtemsBarrierReqWait_PreDesc_Satisfy,
158  NULL
159};
160
161#define NAME rtems_build_name( 'T', 'E', 'S', 'T' )
162
163#define EVENT_CHECK_TIMER RTEMS_EVENT_0
164
165#define EVENT_WAIT RTEMS_EVENT_1
166
167#define EVENT_RELEASE RTEMS_EVENT_2
168
169#define EVENT_DELETE RTEMS_EVENT_3
170
171typedef RtemsBarrierReqWait_Context Context;
172
173typedef enum {
174  PRIO_HIGH = 1,
175  PRIO_NORMAL,
176  PRIO_LOW
177} Priorities;
178
179static void SendEvents( rtems_id id, rtems_event_set events )
180{
181  rtems_status_code sc;
182
183  sc = rtems_event_send( id, events );
184  T_rsc_success( sc );
185}
186
187static void Worker( rtems_task_argument arg )
188{
189  Context *ctx;
190
191  ctx = (Context *) arg;
192
193  while ( true ) {
194    rtems_status_code sc;
195    rtems_event_set   events;
196
197    events = 0;
198    sc = rtems_event_receive(
199      RTEMS_ALL_EVENTS,
200      RTEMS_EVENT_ANY | RTEMS_WAIT,
201      RTEMS_NO_TIMEOUT,
202      &events
203    );
204    T_rsc_success( sc );
205
206    if ( ( events & EVENT_CHECK_TIMER ) != 0 ) {
207      T_eq_int(
208        T_get_thread_timer_state( ctx->main_id ),
209        T_THREAD_TIMER_INACTIVE
210      );
211    }
212
213    if ( ( events & EVENT_WAIT ) != 0 ) {
214      sc = rtems_barrier_wait( ctx->id, RTEMS_NO_TIMEOUT );
215      T_rsc_success( sc );
216    }
217
218    if ( ( events & EVENT_RELEASE ) != 0 ) {
219      uint32_t released;
220
221      sc = rtems_barrier_release( ctx->id, &released );
222      T_rsc_success( sc );
223    }
224
225    if ( ( events & EVENT_DELETE ) != 0 ) {
226      rtems_attribute     attribute_set;
227      uint32_t            maximum_waiters;
228      rtems_id           *id;
229      rtems_task_priority prio;
230
231      if ( ctx->id == ctx->manual_release_id ) {
232        attribute_set = RTEMS_BARRIER_MANUAL_RELEASE;
233        maximum_waiters = 0;
234        id = &ctx->manual_release_id;
235      } else {
236        attribute_set = RTEMS_BARRIER_AUTOMATIC_RELEASE;
237        maximum_waiters = 2;
238        id = &ctx->auto_release_id;
239      }
240
241      prio = 0;
242      sc = rtems_task_set_priority( RTEMS_SELF, PRIO_HIGH, &prio );
243      T_rsc_success( sc );
244      T_eq_u32( prio, PRIO_LOW );
245
246      sc = rtems_barrier_delete( ctx->id );
247      T_rsc_success( sc );
248
249      sc = rtems_barrier_create( NAME, attribute_set, maximum_waiters, id );
250      T_rsc_success( sc );
251
252      sc = rtems_task_set_priority( RTEMS_SELF, prio, &prio );
253      T_rsc_success( sc );
254      T_eq_u32( prio, PRIO_HIGH );
255    }
256  }
257}
258
259static void RtemsBarrierReqWait_Pre_Barrier_Prepare(
260  RtemsBarrierReqWait_Context    *ctx,
261  RtemsBarrierReqWait_Pre_Barrier state
262)
263{
264  switch ( state ) {
265    case RtemsBarrierReqWait_Pre_Barrier_NoObj: {
266      /*
267       * The ``id`` parameter shall be invalid.
268       */
269      ctx->id = 0xffffffff;
270      break;
271    }
272
273    case RtemsBarrierReqWait_Pre_Barrier_Manual: {
274      /*
275       * The ``id`` parameter shall be associated with a
276       * manual release barrier.
277       */
278      ctx->id = ctx->manual_release_id;
279      break;
280    }
281
282    case RtemsBarrierReqWait_Pre_Barrier_Auto: {
283      /*
284       * The ``id`` parameter shall be associated with an
285       * automatic release barrier.
286       */
287      ctx->id = ctx->auto_release_id;
288      break;
289    }
290
291    case RtemsBarrierReqWait_Pre_Barrier_NA:
292      break;
293  }
294}
295
296static void RtemsBarrierReqWait_Pre_Timeout_Prepare(
297  RtemsBarrierReqWait_Context    *ctx,
298  RtemsBarrierReqWait_Pre_Timeout state
299)
300{
301  switch ( state ) {
302    case RtemsBarrierReqWait_Pre_Timeout_Ticks: {
303      /*
304       * The ``released`` parameter shall be a clock tick
305       * interval.
306       */
307      ctx->timeout = 2;
308      break;
309    }
310
311    case RtemsBarrierReqWait_Pre_Timeout_Forever: {
312      /*
313       * The ``released`` parameter shall be
314       * RTEMS_NO_TIMEOUT.
315       */
316      ctx->timeout = RTEMS_NO_TIMEOUT;
317      break;
318    }
319
320    case RtemsBarrierReqWait_Pre_Timeout_NA:
321      break;
322  }
323}
324
325static void RtemsBarrierReqWait_Pre_Satisfy_Prepare(
326  RtemsBarrierReqWait_Context    *ctx,
327  RtemsBarrierReqWait_Pre_Satisfy state
328)
329{
330  switch ( state ) {
331    case RtemsBarrierReqWait_Pre_Satisfy_Never: {
332      /*
333       * While the calling task waits at the barrier, the barrier shall not be
334       * released or deleted.
335       */
336      if ( ctx->timeout == RTEMS_NO_TIMEOUT ) {
337        SendEvents( ctx->low_worker_id, EVENT_CHECK_TIMER | EVENT_RELEASE );
338      }
339      break;
340    }
341
342    case RtemsBarrierReqWait_Pre_Satisfy_Wait: {
343      /*
344       * Calling the directive shall release the barrier.
345       */
346      SendEvents( ctx->high_worker_id, EVENT_WAIT );
347      break;
348    }
349
350    case RtemsBarrierReqWait_Pre_Satisfy_Release: {
351      /*
352       * While the calling task waits at the barrier, the barrier shall be
353       * released.
354       */
355      SendEvents( ctx->low_worker_id, EVENT_RELEASE );
356      break;
357    }
358
359    case RtemsBarrierReqWait_Pre_Satisfy_Delete: {
360      /*
361       * While the calling task waits at the barrier, the barrier shall be
362       * deleted.
363       */
364      SendEvents( ctx->low_worker_id, EVENT_DELETE );
365      break;
366    }
367
368    case RtemsBarrierReqWait_Pre_Satisfy_NA:
369      break;
370  }
371}
372
373static void RtemsBarrierReqWait_Post_Status_Check(
374  RtemsBarrierReqWait_Context    *ctx,
375  RtemsBarrierReqWait_Post_Status state
376)
377{
378  switch ( state ) {
379    case RtemsBarrierReqWait_Post_Status_Ok: {
380      /*
381       * The return status of rtems_barrier_wait() shall be
382       * RTEMS_SUCCESSFUL.
383       */
384      T_rsc_success( ctx->status );
385      break;
386    }
387
388    case RtemsBarrierReqWait_Post_Status_InvId: {
389      /*
390       * The return status of rtems_barrier_wait() shall be
391       * RTEMS_INVALID_ID.
392       */
393      T_rsc( ctx->status, RTEMS_INVALID_ID );
394      break;
395    }
396
397    case RtemsBarrierReqWait_Post_Status_Timeout: {
398      /*
399       * The return status of rtems_barrier_wait() shall be
400       * RTEMS_TIMEOUT.
401       */
402      T_rsc( ctx->status, RTEMS_TIMEOUT );
403      break;
404    }
405
406    case RtemsBarrierReqWait_Post_Status_ObjDel: {
407      /*
408       * The return status of rtems_barrier_wait() shall be
409       * RTEMS_OBJECT_WAS_DELETED.
410       */
411      T_rsc( ctx->status, RTEMS_OBJECT_WAS_DELETED );
412      break;
413    }
414
415    case RtemsBarrierReqWait_Post_Status_NoReturn: {
416      /*
417       * The call to rtems_barrier_wait() shall not return to the calling task.
418       */
419      T_rsc_success( ctx->status );
420      break;
421    }
422
423    case RtemsBarrierReqWait_Post_Status_NA:
424      break;
425  }
426}
427
428static void RtemsBarrierReqWait_Setup( RtemsBarrierReqWait_Context *ctx )
429{
430  rtems_status_code   sc;
431  rtems_task_priority prio;
432
433  memset( ctx, 0, sizeof( *ctx ) );
434  ctx->main_id = rtems_task_self();
435
436  prio = 0;
437  sc = rtems_task_set_priority( RTEMS_SELF, PRIO_NORMAL, &prio );
438  T_rsc_success( sc );
439  T_eq_u32( prio, PRIO_HIGH );
440
441  sc = rtems_task_create(
442    rtems_build_name( 'W', 'O', 'R', 'K' ),
443    PRIO_HIGH,
444    RTEMS_MINIMUM_STACK_SIZE,
445    RTEMS_DEFAULT_MODES,
446    RTEMS_DEFAULT_ATTRIBUTES,
447    &ctx->high_worker_id
448  );
449  T_assert_rsc_success( sc );
450
451  sc = rtems_task_start(
452    ctx->high_worker_id,
453    Worker,
454    (rtems_task_argument) ctx
455  );
456  T_assert_rsc_success( sc );
457
458  sc = rtems_task_create(
459    rtems_build_name( 'W', 'O', 'R', 'K' ),
460    PRIO_LOW,
461    RTEMS_MINIMUM_STACK_SIZE,
462    RTEMS_DEFAULT_MODES,
463    RTEMS_DEFAULT_ATTRIBUTES,
464    &ctx->low_worker_id
465  );
466  T_assert_rsc_success( sc );
467
468  sc = rtems_task_start(
469    ctx->low_worker_id,
470    Worker,
471    (rtems_task_argument) ctx
472  );
473  T_assert_rsc_success( sc );
474
475  sc = rtems_barrier_create(
476    NAME,
477    RTEMS_BARRIER_MANUAL_RELEASE,
478    0,
479    &ctx->manual_release_id
480  );
481  T_assert_rsc_success( sc );
482
483  sc = rtems_barrier_create(
484    NAME,
485    RTEMS_BARRIER_AUTOMATIC_RELEASE,
486    2,
487    &ctx->auto_release_id
488  );
489  T_assert_rsc_success( sc );
490}
491
492static void RtemsBarrierReqWait_Setup_Wrap( void *arg )
493{
494  RtemsBarrierReqWait_Context *ctx;
495
496  ctx = arg;
497  ctx->in_action_loop = false;
498  RtemsBarrierReqWait_Setup( ctx );
499}
500
501static void RtemsBarrierReqWait_Teardown( RtemsBarrierReqWait_Context *ctx )
502{
503  rtems_status_code   sc;
504  rtems_task_priority prio;
505
506  prio = 0;
507  sc = rtems_task_set_priority( RTEMS_SELF, PRIO_HIGH, &prio );
508  T_rsc_success( sc );
509  T_eq_u32( prio, PRIO_NORMAL );
510
511  if ( ctx->high_worker_id != 0 ) {
512    sc = rtems_task_delete( ctx->high_worker_id );
513    T_rsc_success( sc );
514  }
515
516  if ( ctx->low_worker_id != 0 ) {
517    sc = rtems_task_delete( ctx->low_worker_id );
518    T_rsc_success( sc );
519  }
520
521  if ( ctx->manual_release_id != 0 ) {
522    sc = rtems_barrier_delete( ctx->manual_release_id );
523    T_rsc_success( sc );
524  }
525
526  if ( ctx->auto_release_id != 0 ) {
527    sc = rtems_barrier_delete( ctx->auto_release_id );
528    T_rsc_success( sc );
529  }
530}
531
532static void RtemsBarrierReqWait_Teardown_Wrap( void *arg )
533{
534  RtemsBarrierReqWait_Context *ctx;
535
536  ctx = arg;
537  ctx->in_action_loop = false;
538  RtemsBarrierReqWait_Teardown( ctx );
539}
540
541static size_t RtemsBarrierReqWait_Scope( void *arg, char *buf, size_t n )
542{
543  RtemsBarrierReqWait_Context *ctx;
544
545  ctx = arg;
546
547  if ( ctx->in_action_loop ) {
548    return T_get_scope( RtemsBarrierReqWait_PreDesc, buf, n, ctx->pcs );
549  }
550
551  return 0;
552}
553
554static T_fixture RtemsBarrierReqWait_Fixture = {
555  .setup = RtemsBarrierReqWait_Setup_Wrap,
556  .stop = NULL,
557  .teardown = RtemsBarrierReqWait_Teardown_Wrap,
558  .scope = RtemsBarrierReqWait_Scope,
559  .initial_context = &RtemsBarrierReqWait_Instance
560};
561
562static const uint8_t RtemsBarrierReqWait_TransitionMap[][ 1 ] = {
563  {
564    RtemsBarrierReqWait_Post_Status_InvId
565  }, {
566    RtemsBarrierReqWait_Post_Status_InvId
567  }, {
568    RtemsBarrierReqWait_Post_Status_InvId
569  }, {
570    RtemsBarrierReqWait_Post_Status_InvId
571  }, {
572    RtemsBarrierReqWait_Post_Status_InvId
573  }, {
574    RtemsBarrierReqWait_Post_Status_InvId
575  }, {
576    RtemsBarrierReqWait_Post_Status_InvId
577  }, {
578    RtemsBarrierReqWait_Post_Status_InvId
579  }, {
580    RtemsBarrierReqWait_Post_Status_Timeout
581  }, {
582    RtemsBarrierReqWait_Post_Status_NA
583  }, {
584    RtemsBarrierReqWait_Post_Status_Ok
585  }, {
586    RtemsBarrierReqWait_Post_Status_ObjDel
587  }, {
588    RtemsBarrierReqWait_Post_Status_NoReturn
589  }, {
590    RtemsBarrierReqWait_Post_Status_NA
591  }, {
592    RtemsBarrierReqWait_Post_Status_Ok
593  }, {
594    RtemsBarrierReqWait_Post_Status_ObjDel
595  }, {
596    RtemsBarrierReqWait_Post_Status_Timeout
597  }, {
598    RtemsBarrierReqWait_Post_Status_Ok
599  }, {
600    RtemsBarrierReqWait_Post_Status_Ok
601  }, {
602    RtemsBarrierReqWait_Post_Status_ObjDel
603  }, {
604    RtemsBarrierReqWait_Post_Status_NoReturn
605  }, {
606    RtemsBarrierReqWait_Post_Status_Ok
607  }, {
608    RtemsBarrierReqWait_Post_Status_Ok
609  }, {
610    RtemsBarrierReqWait_Post_Status_ObjDel
611  }
612};
613
614static const struct {
615  uint8_t Skip : 1;
616  uint8_t Pre_Barrier_NA : 1;
617  uint8_t Pre_Timeout_NA : 1;
618  uint8_t Pre_Satisfy_NA : 1;
619} RtemsBarrierReqWait_TransitionInfo[] = {
620  {
621    0, 0, 1, 1
622  }, {
623    0, 0, 1, 1
624  }, {
625    0, 0, 1, 1
626  }, {
627    0, 0, 1, 1
628  }, {
629    0, 0, 1, 1
630  }, {
631    0, 0, 1, 1
632  }, {
633    0, 0, 1, 1
634  }, {
635    0, 0, 1, 1
636  }, {
637    0, 0, 0, 0
638  }, {
639    1, 0, 0, 0
640  }, {
641    0, 0, 0, 0
642  }, {
643    0, 0, 0, 0
644  }, {
645    0, 0, 0, 0
646  }, {
647    1, 0, 0, 0
648  }, {
649    0, 0, 0, 0
650  }, {
651    0, 0, 0, 0
652  }, {
653    0, 0, 0, 0
654  }, {
655    0, 0, 0, 0
656  }, {
657    0, 0, 0, 0
658  }, {
659    0, 0, 0, 0
660  }, {
661    0, 0, 0, 0
662  }, {
663    0, 0, 0, 0
664  }, {
665    0, 0, 0, 0
666  }, {
667    0, 0, 0, 0
668  }
669};
670
671static void RtemsBarrierReqWait_Action( RtemsBarrierReqWait_Context *ctx )
672{
673  ctx->status = rtems_barrier_wait( ctx->id, ctx->timeout );
674}
675
676/**
677 * @fn void T_case_body_RtemsBarrierReqWait( void )
678 */
679T_TEST_CASE_FIXTURE( RtemsBarrierReqWait, &RtemsBarrierReqWait_Fixture )
680{
681  RtemsBarrierReqWait_Context *ctx;
682  size_t index;
683
684  ctx = T_fixture_context();
685  ctx->in_action_loop = true;
686  index = 0;
687
688  for (
689    ctx->pcs[ 0 ] = RtemsBarrierReqWait_Pre_Barrier_NoObj;
690    ctx->pcs[ 0 ] < RtemsBarrierReqWait_Pre_Barrier_NA;
691    ++ctx->pcs[ 0 ]
692  ) {
693    if ( RtemsBarrierReqWait_TransitionInfo[ index ].Pre_Barrier_NA ) {
694      ctx->pcs[ 0 ] = RtemsBarrierReqWait_Pre_Barrier_NA;
695      index += ( RtemsBarrierReqWait_Pre_Barrier_NA - 1 )
696        * RtemsBarrierReqWait_Pre_Timeout_NA
697        * RtemsBarrierReqWait_Pre_Satisfy_NA;
698    }
699
700    for (
701      ctx->pcs[ 1 ] = RtemsBarrierReqWait_Pre_Timeout_Ticks;
702      ctx->pcs[ 1 ] < RtemsBarrierReqWait_Pre_Timeout_NA;
703      ++ctx->pcs[ 1 ]
704    ) {
705      if ( RtemsBarrierReqWait_TransitionInfo[ index ].Pre_Timeout_NA ) {
706        ctx->pcs[ 1 ] = RtemsBarrierReqWait_Pre_Timeout_NA;
707        index += ( RtemsBarrierReqWait_Pre_Timeout_NA - 1 )
708          * RtemsBarrierReqWait_Pre_Satisfy_NA;
709      }
710
711      for (
712        ctx->pcs[ 2 ] = RtemsBarrierReqWait_Pre_Satisfy_Never;
713        ctx->pcs[ 2 ] < RtemsBarrierReqWait_Pre_Satisfy_NA;
714        ++ctx->pcs[ 2 ]
715      ) {
716        if ( RtemsBarrierReqWait_TransitionInfo[ index ].Pre_Satisfy_NA ) {
717          ctx->pcs[ 2 ] = RtemsBarrierReqWait_Pre_Satisfy_NA;
718          index += ( RtemsBarrierReqWait_Pre_Satisfy_NA - 1 );
719        }
720
721        if ( RtemsBarrierReqWait_TransitionInfo[ index ].Skip ) {
722          ++index;
723          continue;
724        }
725
726        RtemsBarrierReqWait_Pre_Barrier_Prepare( ctx, ctx->pcs[ 0 ] );
727        RtemsBarrierReqWait_Pre_Timeout_Prepare( ctx, ctx->pcs[ 1 ] );
728        RtemsBarrierReqWait_Pre_Satisfy_Prepare( ctx, ctx->pcs[ 2 ] );
729        RtemsBarrierReqWait_Action( ctx );
730        RtemsBarrierReqWait_Post_Status_Check(
731          ctx,
732          RtemsBarrierReqWait_TransitionMap[ index ][ 0 ]
733        );
734        ++index;
735      }
736    }
737  }
738}
739
740/** @} */
Note: See TracBrowser for help on using the repository browser.