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

Last change on this file since c0c4b8b was c0c4b8b, checked in by Sebastian Huber <sebastian.huber@…>, on Mar 2, 2021 at 6:54:17 AM

validation: Format comment blocks

  • Property mode set to 100644
File size: 17.3 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 manual release
276       * 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 automatic release
285       * 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 interval.
305       */
306      ctx->timeout = 2;
307      break;
308    }
309
310    case RtemsBarrierReqWait_Pre_Timeout_Forever: {
311      /*
312       * The ``released`` parameter shall be RTEMS_NO_TIMEOUT.
313       */
314      ctx->timeout = RTEMS_NO_TIMEOUT;
315      break;
316    }
317
318    case RtemsBarrierReqWait_Pre_Timeout_NA:
319      break;
320  }
321}
322
323static void RtemsBarrierReqWait_Pre_Satisfy_Prepare(
324  RtemsBarrierReqWait_Context    *ctx,
325  RtemsBarrierReqWait_Pre_Satisfy state
326)
327{
328  switch ( state ) {
329    case RtemsBarrierReqWait_Pre_Satisfy_Never: {
330      /*
331       * While the calling task waits at the barrier, the barrier shall not be
332       * released or deleted.
333       */
334      if ( ctx->timeout == RTEMS_NO_TIMEOUT ) {
335        SendEvents( ctx->low_worker_id, EVENT_CHECK_TIMER | EVENT_RELEASE );
336      }
337      break;
338    }
339
340    case RtemsBarrierReqWait_Pre_Satisfy_Wait: {
341      /*
342       * Calling the directive shall release the barrier.
343       */
344      SendEvents( ctx->high_worker_id, EVENT_WAIT );
345      break;
346    }
347
348    case RtemsBarrierReqWait_Pre_Satisfy_Release: {
349      /*
350       * While the calling task waits at the barrier, the barrier shall be
351       * released.
352       */
353      SendEvents( ctx->low_worker_id, EVENT_RELEASE );
354      break;
355    }
356
357    case RtemsBarrierReqWait_Pre_Satisfy_Delete: {
358      /*
359       * While the calling task waits at the barrier, the barrier shall be
360       * deleted.
361       */
362      SendEvents( ctx->low_worker_id, EVENT_DELETE );
363      break;
364    }
365
366    case RtemsBarrierReqWait_Pre_Satisfy_NA:
367      break;
368  }
369}
370
371static void RtemsBarrierReqWait_Post_Status_Check(
372  RtemsBarrierReqWait_Context    *ctx,
373  RtemsBarrierReqWait_Post_Status state
374)
375{
376  switch ( state ) {
377    case RtemsBarrierReqWait_Post_Status_Ok: {
378      /*
379       * The return status of rtems_barrier_wait() shall be RTEMS_SUCCESSFUL.
380       */
381      T_rsc_success( ctx->status );
382      break;
383    }
384
385    case RtemsBarrierReqWait_Post_Status_InvId: {
386      /*
387       * The return status of rtems_barrier_wait() shall be RTEMS_INVALID_ID.
388       */
389      T_rsc( ctx->status, RTEMS_INVALID_ID );
390      break;
391    }
392
393    case RtemsBarrierReqWait_Post_Status_Timeout: {
394      /*
395       * The return status of rtems_barrier_wait() shall be RTEMS_TIMEOUT.
396       */
397      T_rsc( ctx->status, RTEMS_TIMEOUT );
398      break;
399    }
400
401    case RtemsBarrierReqWait_Post_Status_ObjDel: {
402      /*
403       * The return status of rtems_barrier_wait() shall be
404       * RTEMS_OBJECT_WAS_DELETED.
405       */
406      T_rsc( ctx->status, RTEMS_OBJECT_WAS_DELETED );
407      break;
408    }
409
410    case RtemsBarrierReqWait_Post_Status_NoReturn: {
411      /*
412       * The call to rtems_barrier_wait() shall not return to the calling task.
413       */
414      T_rsc_success( ctx->status );
415      break;
416    }
417
418    case RtemsBarrierReqWait_Post_Status_NA:
419      break;
420  }
421}
422
423static void RtemsBarrierReqWait_Setup( RtemsBarrierReqWait_Context *ctx )
424{
425  rtems_status_code   sc;
426  rtems_task_priority prio;
427
428  memset( ctx, 0, sizeof( *ctx ) );
429  ctx->main_id = rtems_task_self();
430
431  prio = 0;
432  sc = rtems_task_set_priority( RTEMS_SELF, PRIO_NORMAL, &prio );
433  T_rsc_success( sc );
434  T_eq_u32( prio, PRIO_HIGH );
435
436  sc = rtems_task_create(
437    rtems_build_name( 'W', 'O', 'R', 'K' ),
438    PRIO_HIGH,
439    RTEMS_MINIMUM_STACK_SIZE,
440    RTEMS_DEFAULT_MODES,
441    RTEMS_DEFAULT_ATTRIBUTES,
442    &ctx->high_worker_id
443  );
444  T_assert_rsc_success( sc );
445
446  sc = rtems_task_start(
447    ctx->high_worker_id,
448    Worker,
449    (rtems_task_argument) ctx
450  );
451  T_assert_rsc_success( sc );
452
453  sc = rtems_task_create(
454    rtems_build_name( 'W', 'O', 'R', 'K' ),
455    PRIO_LOW,
456    RTEMS_MINIMUM_STACK_SIZE,
457    RTEMS_DEFAULT_MODES,
458    RTEMS_DEFAULT_ATTRIBUTES,
459    &ctx->low_worker_id
460  );
461  T_assert_rsc_success( sc );
462
463  sc = rtems_task_start(
464    ctx->low_worker_id,
465    Worker,
466    (rtems_task_argument) ctx
467  );
468  T_assert_rsc_success( sc );
469
470  sc = rtems_barrier_create(
471    NAME,
472    RTEMS_BARRIER_MANUAL_RELEASE,
473    0,
474    &ctx->manual_release_id
475  );
476  T_assert_rsc_success( sc );
477
478  sc = rtems_barrier_create(
479    NAME,
480    RTEMS_BARRIER_AUTOMATIC_RELEASE,
481    2,
482    &ctx->auto_release_id
483  );
484  T_assert_rsc_success( sc );
485}
486
487static void RtemsBarrierReqWait_Setup_Wrap( void *arg )
488{
489  RtemsBarrierReqWait_Context *ctx;
490
491  ctx = arg;
492  ctx->in_action_loop = false;
493  RtemsBarrierReqWait_Setup( ctx );
494}
495
496static void RtemsBarrierReqWait_Teardown( RtemsBarrierReqWait_Context *ctx )
497{
498  rtems_status_code   sc;
499  rtems_task_priority prio;
500
501  prio = 0;
502  sc = rtems_task_set_priority( RTEMS_SELF, PRIO_HIGH, &prio );
503  T_rsc_success( sc );
504  T_eq_u32( prio, PRIO_NORMAL );
505
506  if ( ctx->high_worker_id != 0 ) {
507    sc = rtems_task_delete( ctx->high_worker_id );
508    T_rsc_success( sc );
509  }
510
511  if ( ctx->low_worker_id != 0 ) {
512    sc = rtems_task_delete( ctx->low_worker_id );
513    T_rsc_success( sc );
514  }
515
516  if ( ctx->manual_release_id != 0 ) {
517    sc = rtems_barrier_delete( ctx->manual_release_id );
518    T_rsc_success( sc );
519  }
520
521  if ( ctx->auto_release_id != 0 ) {
522    sc = rtems_barrier_delete( ctx->auto_release_id );
523    T_rsc_success( sc );
524  }
525}
526
527static void RtemsBarrierReqWait_Teardown_Wrap( void *arg )
528{
529  RtemsBarrierReqWait_Context *ctx;
530
531  ctx = arg;
532  ctx->in_action_loop = false;
533  RtemsBarrierReqWait_Teardown( ctx );
534}
535
536static size_t RtemsBarrierReqWait_Scope( void *arg, char *buf, size_t n )
537{
538  RtemsBarrierReqWait_Context *ctx;
539
540  ctx = arg;
541
542  if ( ctx->in_action_loop ) {
543    return T_get_scope( RtemsBarrierReqWait_PreDesc, buf, n, ctx->pcs );
544  }
545
546  return 0;
547}
548
549static T_fixture RtemsBarrierReqWait_Fixture = {
550  .setup = RtemsBarrierReqWait_Setup_Wrap,
551  .stop = NULL,
552  .teardown = RtemsBarrierReqWait_Teardown_Wrap,
553  .scope = RtemsBarrierReqWait_Scope,
554  .initial_context = &RtemsBarrierReqWait_Instance
555};
556
557static const uint8_t RtemsBarrierReqWait_TransitionMap[][ 1 ] = {
558  {
559    RtemsBarrierReqWait_Post_Status_InvId
560  }, {
561    RtemsBarrierReqWait_Post_Status_InvId
562  }, {
563    RtemsBarrierReqWait_Post_Status_InvId
564  }, {
565    RtemsBarrierReqWait_Post_Status_InvId
566  }, {
567    RtemsBarrierReqWait_Post_Status_InvId
568  }, {
569    RtemsBarrierReqWait_Post_Status_InvId
570  }, {
571    RtemsBarrierReqWait_Post_Status_InvId
572  }, {
573    RtemsBarrierReqWait_Post_Status_InvId
574  }, {
575    RtemsBarrierReqWait_Post_Status_Timeout
576  }, {
577    RtemsBarrierReqWait_Post_Status_NA
578  }, {
579    RtemsBarrierReqWait_Post_Status_Ok
580  }, {
581    RtemsBarrierReqWait_Post_Status_ObjDel
582  }, {
583    RtemsBarrierReqWait_Post_Status_NoReturn
584  }, {
585    RtemsBarrierReqWait_Post_Status_NA
586  }, {
587    RtemsBarrierReqWait_Post_Status_Ok
588  }, {
589    RtemsBarrierReqWait_Post_Status_ObjDel
590  }, {
591    RtemsBarrierReqWait_Post_Status_Timeout
592  }, {
593    RtemsBarrierReqWait_Post_Status_Ok
594  }, {
595    RtemsBarrierReqWait_Post_Status_Ok
596  }, {
597    RtemsBarrierReqWait_Post_Status_ObjDel
598  }, {
599    RtemsBarrierReqWait_Post_Status_NoReturn
600  }, {
601    RtemsBarrierReqWait_Post_Status_Ok
602  }, {
603    RtemsBarrierReqWait_Post_Status_Ok
604  }, {
605    RtemsBarrierReqWait_Post_Status_ObjDel
606  }
607};
608
609static const struct {
610  uint8_t Skip : 1;
611  uint8_t Pre_Barrier_NA : 1;
612  uint8_t Pre_Timeout_NA : 1;
613  uint8_t Pre_Satisfy_NA : 1;
614} RtemsBarrierReqWait_TransitionInfo[] = {
615  {
616    0, 0, 1, 1
617  }, {
618    0, 0, 1, 1
619  }, {
620    0, 0, 1, 1
621  }, {
622    0, 0, 1, 1
623  }, {
624    0, 0, 1, 1
625  }, {
626    0, 0, 1, 1
627  }, {
628    0, 0, 1, 1
629  }, {
630    0, 0, 1, 1
631  }, {
632    0, 0, 0, 0
633  }, {
634    1, 0, 0, 0
635  }, {
636    0, 0, 0, 0
637  }, {
638    0, 0, 0, 0
639  }, {
640    0, 0, 0, 0
641  }, {
642    1, 0, 0, 0
643  }, {
644    0, 0, 0, 0
645  }, {
646    0, 0, 0, 0
647  }, {
648    0, 0, 0, 0
649  }, {
650    0, 0, 0, 0
651  }, {
652    0, 0, 0, 0
653  }, {
654    0, 0, 0, 0
655  }, {
656    0, 0, 0, 0
657  }, {
658    0, 0, 0, 0
659  }, {
660    0, 0, 0, 0
661  }, {
662    0, 0, 0, 0
663  }
664};
665
666static void RtemsBarrierReqWait_Action( RtemsBarrierReqWait_Context *ctx )
667{
668  ctx->status = rtems_barrier_wait( ctx->id, ctx->timeout );
669}
670
671/**
672 * @fn void T_case_body_RtemsBarrierReqWait( void )
673 */
674T_TEST_CASE_FIXTURE( RtemsBarrierReqWait, &RtemsBarrierReqWait_Fixture )
675{
676  RtemsBarrierReqWait_Context *ctx;
677  size_t index;
678
679  ctx = T_fixture_context();
680  ctx->in_action_loop = true;
681  index = 0;
682
683  for (
684    ctx->pcs[ 0 ] = RtemsBarrierReqWait_Pre_Barrier_NoObj;
685    ctx->pcs[ 0 ] < RtemsBarrierReqWait_Pre_Barrier_NA;
686    ++ctx->pcs[ 0 ]
687  ) {
688    if ( RtemsBarrierReqWait_TransitionInfo[ index ].Pre_Barrier_NA ) {
689      ctx->pcs[ 0 ] = RtemsBarrierReqWait_Pre_Barrier_NA;
690      index += ( RtemsBarrierReqWait_Pre_Barrier_NA - 1 )
691        * RtemsBarrierReqWait_Pre_Timeout_NA
692        * RtemsBarrierReqWait_Pre_Satisfy_NA;
693    }
694
695    for (
696      ctx->pcs[ 1 ] = RtemsBarrierReqWait_Pre_Timeout_Ticks;
697      ctx->pcs[ 1 ] < RtemsBarrierReqWait_Pre_Timeout_NA;
698      ++ctx->pcs[ 1 ]
699    ) {
700      if ( RtemsBarrierReqWait_TransitionInfo[ index ].Pre_Timeout_NA ) {
701        ctx->pcs[ 1 ] = RtemsBarrierReqWait_Pre_Timeout_NA;
702        index += ( RtemsBarrierReqWait_Pre_Timeout_NA - 1 )
703          * RtemsBarrierReqWait_Pre_Satisfy_NA;
704      }
705
706      for (
707        ctx->pcs[ 2 ] = RtemsBarrierReqWait_Pre_Satisfy_Never;
708        ctx->pcs[ 2 ] < RtemsBarrierReqWait_Pre_Satisfy_NA;
709        ++ctx->pcs[ 2 ]
710      ) {
711        if ( RtemsBarrierReqWait_TransitionInfo[ index ].Pre_Satisfy_NA ) {
712          ctx->pcs[ 2 ] = RtemsBarrierReqWait_Pre_Satisfy_NA;
713          index += ( RtemsBarrierReqWait_Pre_Satisfy_NA - 1 );
714        }
715
716        if ( RtemsBarrierReqWait_TransitionInfo[ index ].Skip ) {
717          ++index;
718          continue;
719        }
720
721        RtemsBarrierReqWait_Pre_Barrier_Prepare( ctx, ctx->pcs[ 0 ] );
722        RtemsBarrierReqWait_Pre_Timeout_Prepare( ctx, ctx->pcs[ 1 ] );
723        RtemsBarrierReqWait_Pre_Satisfy_Prepare( ctx, ctx->pcs[ 2 ] );
724        RtemsBarrierReqWait_Action( ctx );
725        RtemsBarrierReqWait_Post_Status_Check(
726          ctx,
727          RtemsBarrierReqWait_TransitionMap[ index ][ 0 ]
728        );
729        ++index;
730      }
731    }
732  }
733}
734
735/** @} */
Note: See TracBrowser for help on using the repository browser.