diff options
Diffstat (limited to 'testsuites/validation/tr-tq-timeout-priority-inherit.c')
| -rw-r--r-- | testsuites/validation/tr-tq-timeout-priority-inherit.c | 2160 |
1 files changed, 2160 insertions, 0 deletions
diff --git a/testsuites/validation/tr-tq-timeout-priority-inherit.c b/testsuites/validation/tr-tq-timeout-priority-inherit.c new file mode 100644 index 0000000000..12ac70df90 --- /dev/null +++ b/testsuites/validation/tr-tq-timeout-priority-inherit.c @@ -0,0 +1,2160 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup ScoreTqReqTimeoutPriorityInherit + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems/score/smpimpl.h> +#include <rtems/score/threadimpl.h> + +#include "tr-tq-timeout-priority-inherit.h" +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup ScoreTqReqTimeoutPriorityInherit \ + * spec:/score/tq/req/timeout-priority-inherit + * + * @ingroup TestsuitesValidationNoClock0 + * + * @{ + */ + +typedef struct { + uint32_t Skip : 1; + uint32_t Pre_HomeScheduler_NA : 1; + uint32_t Pre_EligibleScheduler_NA : 1; + uint32_t Pre_Queue_NA : 1; + uint32_t Pre_OwnerPriority_NA : 1; + uint32_t Pre_OwnerState_NA : 1; + uint32_t Pre_OwnerQueue_NA : 1; + uint32_t Pre_OwnerOwnerPriority_NA : 1; + uint32_t Pre_WaitState_NA : 1; + uint32_t Post_Status : 2; + uint32_t Post_Unblock : 2; + uint32_t Post_OwnerPriority : 2; + uint32_t Post_OwnerOwnerPriority : 2; +} ScoreTqReqTimeoutPriorityInherit_Entry; + +/** + * @brief Test context for spec:/score/tq/req/timeout-priority-inherit test + * case. + */ +typedef struct { + /** + * @brief This member contains the call within ISR request. + */ + CallWithinISRRequest request; + + /** + * @brief This member specifies the scheduler of the thread. + */ + rtems_id scheduler_id; + + /** + * @brief If this member is true, then the thread shall have at least two + * eligible scheduler. + */ + bool other_scheduler; + + /** + * @brief This member specifies the queue node kind. + */ + TQNodeKind queue_node; + + /** + * @brief This member specifies the owner priority node kind. + */ + TQNodeKind owner_node; + + /** + * @brief This member specifies which mutex obtain event shall be used to + * block the thread queue owner. + */ + rtems_event_set owner_obtain; + + /** + * @brief This member specifies which mutex release event shall be used to + * unblock the thread queue owner. + */ + rtems_event_set owner_release; + + /** + * @brief This member specifies the owner queue node kind. + */ + TQNodeKind owner_queue_node; + + /** + * @brief This member specifies the kind of the priority node of the owner of + * the thread queue on which the owner of the thread queue is blocked. + */ + TQNodeKind owner_owner_node; + + /** + * @brief This member specifies the wait state. + */ + TQWaitState wait_state; + + /** + * @brief This member contains the thread queue priority. + */ + rtems_task_priority queue_priority; + + /** + * @brief This member contains the owner priority. + */ + rtems_task_priority owner_priority; + + /** + * @brief This member contains the owner priority after the timeout or + * surrender. + */ + rtems_task_priority owner_priority_after; + + /** + * @brief This member contains the priority of the thread queue on which the + * owner is enqueued. + */ + rtems_task_priority owner_queue_priority; + + /** + * @brief This member contains the priority of the owner of the thread queue + * on which the owner is enqueued. + */ + rtems_task_priority owner_owner_priority; + + /** + * @brief This member contains the priority after the timeout or surrender of + * the owner of the thread queue on which the owner is enqueued. + */ + rtems_task_priority owner_owner_priority_after; + + /** + * @brief If this member is true, then the queue helper shall surrender the + * thread queue. + */ + bool queue_helper_surrender; + + /** + * @brief If this member is true, then the owner helper shall release mutex + * A. + */ + bool owner_helper_release; + + /** + * @brief If this member is true, then the owner queue helper shall release + * the mutex on which the owner is blocked. + */ + bool owner_queue_helper_release; + + /** + * @brief If this member is true, then helper of the owner of the mutex which + * the owner blocked shall release mutex B. + */ + bool owner_owner_helper_release; + + /** + * @brief This member contains a copy of the corresponding + * ScoreTqReqTimeoutPriorityInherit_Run() parameter. + */ + TQContext *tq_ctx; + + struct { + /** + * @brief This member defines the pre-condition indices for the next + * action. + */ + size_t pci[ 8 ]; + + /** + * @brief This member defines the pre-condition states for the next action. + */ + size_t pcs[ 8 ]; + + /** + * @brief If this member is true, then the test action loop is executed. + */ + bool in_action_loop; + + /** + * @brief This member contains the next transition map index. + */ + size_t index; + + /** + * @brief This member contains the current transition map entry. + */ + ScoreTqReqTimeoutPriorityInherit_Entry entry; + + /** + * @brief If this member is true, then the current transition variant + * should be skipped. + */ + bool skip; + } Map; +} ScoreTqReqTimeoutPriorityInherit_Context; + +static ScoreTqReqTimeoutPriorityInherit_Context + ScoreTqReqTimeoutPriorityInherit_Instance; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_HomeScheduler[] = { + "Home", + "Helping", + "NA" +}; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_EligibleScheduler[] = { + "One", + "More", + "NA" +}; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_Queue[] = { + "Only", + "Vital", + "Dispensable", + "NA" +}; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerPriority[] = { + "Only", + "Vital", + "Dispensable", + "NA" +}; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerState[] = { + "NotEnqueued", + "FIFO", + "Priority", + "PriorityInherit", + "NA" +}; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerQueue[] = { + "Only", + "Vital", + "Dispensable", + "NA" +}; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerOwnerPriority[] = { + "Only", + "Vital", + "Dispensable", + "NA" +}; + +static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_WaitState[] = { + "Blocked", + "IntendToBlock", + "ReadyAgain", + "NA" +}; + +static const char * const * const ScoreTqReqTimeoutPriorityInherit_PreDesc[] = { + ScoreTqReqTimeoutPriorityInherit_PreDesc_HomeScheduler, + ScoreTqReqTimeoutPriorityInherit_PreDesc_EligibleScheduler, + ScoreTqReqTimeoutPriorityInherit_PreDesc_Queue, + ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerPriority, + ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerState, + ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerQueue, + ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerOwnerPriority, + ScoreTqReqTimeoutPriorityInherit_PreDesc_WaitState, + NULL +}; + +typedef ScoreTqReqTimeoutPriorityInherit_Context Context; + +#define THREAD TQ_BLOCKER_A + +#define THREAD_HELPER_A TQ_HELPER_B + +#define THREAD_HELPER_B TQ_HELPER_C + +#define QUEUE_HELPER TQ_BLOCKER_B + +#define OWNER TQ_BLOCKER_C + +#define OWNER_HELPER TQ_BLOCKER_D + +#define OWNER_QUEUE_HELPER TQ_BLOCKER_E + +#define OWNER_OWNER TQ_WORKER_F + +#define OWNER_OWNER_HELPER TQ_HELPER_A + +static bool GetUnblock( const Context *ctx, size_t *index ) +{ + while ( true ) { + const T_scheduler_event *event; + + event = TQGetNextUnblock( ctx->tq_ctx, index ); + + if ( event == &T_scheduler_event_null ) { + return false; + } + + if ( event->thread == ctx->tq_ctx->worker_tcb[ THREAD ] ) { + return true; + } + } +} + +static void Tick( void *arg ) +{ + Context *ctx; + + ctx = arg; + TQSchedulerRecordStart( ctx->tq_ctx ); + FinalClockTick(); + TQSchedulerRecordStop( ctx->tq_ctx ); +} + +static void SchedulerBlock( + void *arg, + const T_scheduler_event *event, + T_scheduler_when when +) +{ + Context *ctx; + + ctx = arg; + + if ( + when == T_SCHEDULER_BEFORE && + event->operation == T_SCHEDULER_BLOCK && + event->thread == ctx->tq_ctx->worker_tcb[ THREAD ] + ) { + T_scheduler_set_event_handler( NULL, NULL ); + ctx->request.handler = Tick; + CallWithinISRSubmit( &ctx->request ); + } +} + +static void ThreadTimeout( void *arg ) +{ + Context *ctx; + + ctx = arg; + TQSchedulerRecordStart( ctx->tq_ctx ); + _Thread_Timeout( + &ctx->tq_ctx->worker_tcb[ THREAD ]->Timer.Watchdog + ); + TQSchedulerRecordStop( ctx->tq_ctx ); +} + +static void SchedulerUnblock( + void *arg, + const T_scheduler_event *event, + T_scheduler_when when +) +{ + Context *ctx; + + ctx = arg; + + if ( + when == T_SCHEDULER_BEFORE && + event->operation == T_SCHEDULER_UNBLOCK && + event->thread == ctx->tq_ctx->worker_tcb[ THREAD ] + ) { + T_scheduler_set_event_handler( NULL, NULL ); + + if ( ctx->scheduler_id == SCHEDULER_B_ID ) { +#if defined(RTEMS_SMP) + _SMP_Unicast_action( 1, ThreadTimeout, ctx ); +#else + T_unreachable(); +#endif + } else { + ctx->request.handler = ThreadTimeout; + CallWithinISRSubmit( &ctx->request ); + } + } +} + +static void GetPriorities( Context *ctx ) +{ + ctx->owner_priority_after = GetPriorityByScheduler( + ctx->tq_ctx->worker_id[ OWNER ], + ctx->scheduler_id + ); + ctx->owner_owner_priority_after = GetPriorityByScheduler( + ctx->tq_ctx->worker_id[ OWNER_OWNER ], + ctx->scheduler_id + ); +} + +static void PrepareThread( const Context *ctx ) +{ + if ( ctx->other_scheduler ) { + rtems_id other_scheduler_id; + + if ( ctx->scheduler_id == SCHEDULER_A_ID ) { + other_scheduler_id = SCHEDULER_B_ID; + } else { + other_scheduler_id = SCHEDULER_B_ID; + } + + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD, + TQ_EVENT_MUTEX_D_OBTAIN + ); + + TQSetScheduler( + ctx->tq_ctx, + THREAD_HELPER_A, + other_scheduler_id, + PRIO_NEARLY_IDLE - 1 + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD_HELPER_A, + TQ_EVENT_MUTEX_D_OBTAIN + ); + + if ( rtems_scheduler_get_processor_maximum() >= 3 ) { + TQSetScheduler( + ctx->tq_ctx, + THREAD_HELPER_B, + SCHEDULER_C_ID, + PRIO_NORMAL + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD_HELPER_B, + TQ_EVENT_MUTEX_D_OBTAIN + ); + } + } +} + +static rtems_task_priority PrepareQueue( + Context *ctx, + rtems_task_priority priority +) +{ + switch ( ctx->queue_node ) { + case TQ_NODE_ONLY: + ctx->queue_helper_surrender = false; + break; + case TQ_NODE_VITAL: + ctx->queue_helper_surrender = true; + TQSetScheduler( + ctx->tq_ctx, + QUEUE_HELPER, + ctx->scheduler_id, + priority + 1 + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + QUEUE_HELPER, + TQ_EVENT_ENQUEUE + ); + break; + case TQ_NODE_DISPENSABLE: + ctx->queue_helper_surrender = true; + --priority; + TQSetScheduler( + ctx->tq_ctx, + QUEUE_HELPER, + ctx->scheduler_id, + priority + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + QUEUE_HELPER, + TQ_EVENT_ENQUEUE + ); + break; + } + + ctx->queue_priority = priority; + + return priority; +} + +static rtems_task_priority PrepareOwner( + Context *ctx, + rtems_task_priority priority +) +{ + switch ( ctx->owner_node ) { + case TQ_NODE_ONLY: + ctx->owner_helper_release = false; + TQSetPriority( ctx->tq_ctx, OWNER, PRIO_FLEXIBLE ); + break; + case TQ_NODE_VITAL: + if ( ctx->scheduler_id == SCHEDULER_A_ID ) { + ctx->owner_helper_release = false; + TQSetPriority( ctx->tq_ctx, OWNER, priority + 1 ); + } else { + ctx->owner_helper_release = true; + TQSetPriority( ctx->tq_ctx, OWNER, PRIO_FLEXIBLE ); + TQSetScheduler( + ctx->tq_ctx, + OWNER_HELPER, + ctx->scheduler_id, + priority + 1 + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_HELPER, + TQ_EVENT_MUTEX_A_OBTAIN + ); + } + break; + case TQ_NODE_DISPENSABLE: + --priority; + + if ( ctx->scheduler_id == SCHEDULER_A_ID ) { + ctx->owner_helper_release = false; + TQSetPriority( ctx->tq_ctx, OWNER, priority ); + } else { + ctx->owner_helper_release = true; + TQSetPriority( ctx->tq_ctx, OWNER, PRIO_FLEXIBLE ); + TQSetScheduler( + ctx->tq_ctx, + OWNER_HELPER, + ctx->scheduler_id, + priority + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_HELPER, + TQ_EVENT_MUTEX_A_OBTAIN + ); + } + break; + } + + ctx->owner_priority = priority; + + return priority; +} + +static rtems_task_priority PrepareOwnerQueue( + Context *ctx, + rtems_task_priority priority +) +{ + if ( ctx->owner_obtain != 0 ) { + switch ( ctx->owner_queue_node ) { + case TQ_NODE_ONLY: + ctx->owner_queue_helper_release = false; + break; + case TQ_NODE_VITAL: + ctx->owner_queue_helper_release = true; + TQSetScheduler( + ctx->tq_ctx, + OWNER_QUEUE_HELPER, + ctx->scheduler_id, + priority + 1 + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_QUEUE_HELPER, + ctx->owner_obtain + ); + break; + case TQ_NODE_DISPENSABLE: + ctx->owner_queue_helper_release = true; + --priority; + TQSetScheduler( + ctx->tq_ctx, + OWNER_QUEUE_HELPER, + ctx->scheduler_id, + priority + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_QUEUE_HELPER, + ctx->owner_obtain + ); + break; + } + + ctx->owner_queue_priority = priority; + } else { + ctx->owner_queue_helper_release = false; + ctx->owner_queue_priority = PRIO_INVALID; + } + + return priority; +} + +static void PrepareOwnerOwner( Context *ctx, rtems_task_priority priority ) +{ + if ( ctx->owner_obtain != 0 ) { + switch ( ctx->owner_owner_node ) { + case TQ_NODE_ONLY: + ctx->owner_owner_helper_release = false; + TQSetPriority( ctx->tq_ctx, OWNER_OWNER, PRIO_FLEXIBLE ); + break; + case TQ_NODE_VITAL: + if ( ctx->scheduler_id == SCHEDULER_A_ID ) { + ctx->owner_owner_helper_release = false; + TQSetPriority( ctx->tq_ctx, OWNER_OWNER, priority + 1 ); + } else { + ctx->owner_owner_helper_release = true; + TQSetPriority( ctx->tq_ctx, OWNER_OWNER, PRIO_FLEXIBLE ); + TQSetScheduler( + ctx->tq_ctx, + OWNER_OWNER_HELPER, + ctx->scheduler_id, + priority + 1 + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_OWNER_HELPER, + TQ_EVENT_MUTEX_B_OBTAIN + ); + } + break; + case TQ_NODE_DISPENSABLE: + --priority; + + if ( ctx->scheduler_id == SCHEDULER_A_ID ) { + ctx->owner_owner_helper_release = false; + TQSetPriority( ctx->tq_ctx, OWNER_OWNER, priority ); + } else { + ctx->owner_owner_helper_release = true; + TQSetPriority( ctx->tq_ctx, OWNER_OWNER, PRIO_FLEXIBLE ); + TQSetScheduler( + ctx->tq_ctx, + OWNER_OWNER_HELPER, + ctx->scheduler_id, + priority + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_OWNER_HELPER, + TQ_EVENT_MUTEX_B_OBTAIN + ); + } + break; + } + + ctx->owner_owner_priority = priority; + } else { + ctx->owner_owner_helper_release = false; + ctx->owner_owner_priority = PRIO_INVALID; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Home: { + /* + * While the home scheduler of the thread is the home scheduler of the + * thread queue owner. + */ + ctx->scheduler_id = SCHEDULER_A_ID; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Helping: { + /* + * While the home scheduler of the thread is a helping scheduler of the + * thread queue owner. + */ + ctx->scheduler_id = SCHEDULER_B_ID; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_One: { + /* + * While the thread has exactly one eligible scheduler. + */ + ctx->other_scheduler = false; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_More: { + /* + * While the thread has at least two eligible scheduler. + */ + ctx->other_scheduler = true; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_Queue state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Only: { + /* + * While the priority node of the thread is the only priority node in the + * priority queue associated with the scheduler of the thread queue. + */ + ctx->queue_node = TQ_NODE_ONLY; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Vital: { + /* + * While the priority node of the thread is not the only priority node in + * the priority queue associated with the scheduler of the thread queue, + * while the priority node of the thread is the highest priority node in + * the priority queue. + */ + ctx->queue_node = TQ_NODE_VITAL; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Dispensable: { + /* + * While the priority node of the thread is not the only priority node in + * the priority queue associated with the scheduler of the thread queue, + * while the priority node of the thread is not the highest priority node + * in the priority queue. + */ + ctx->queue_node = TQ_NODE_DISPENSABLE; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Only: { + /* + * While the priority node of the thread queue is the only priority node + * associated with the scheduler available to the owner. + */ + ctx->owner_node = TQ_NODE_ONLY; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Vital: { + /* + * While the priority node of the thread queue is not the only priority + * node associated with the scheduler available to the owner, while the + * priority node of the thread queue is the highest priority node + * available to the owner. + */ + ctx->owner_node = TQ_NODE_VITAL; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Dispensable: { + /* + * While the priority node of the thread queue is not the only priority + * node associated with the scheduler available to the owner, while the + * priority node of the thread queue is not the highest priority node + * available to the owner. + */ + ctx->owner_node = TQ_NODE_DISPENSABLE; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NotEnqueued: { + /* + * While the owner of the thread queue is not enqueued on a thread queue. + */ + ctx->owner_obtain = 0; + ctx->owner_release = 0; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_FIFO: { + /* + * While the owner of the thread queue is enqueued on a thread queue in + * FIFO order. + */ + ctx->owner_obtain = TQ_EVENT_MUTEX_FIFO_OBTAIN; + ctx->owner_release = TQ_EVENT_MUTEX_FIFO_RELEASE; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_Priority: { + /* + * While the owner of the thread queue is enqueued on a thread queue in + * priority order. + */ + ctx->owner_obtain = TQ_EVENT_MUTEX_NO_PROTOCOL_OBTAIN; + ctx->owner_release = TQ_EVENT_MUTEX_NO_PROTOCOL_RELEASE; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_PriorityInherit: { + /* + * While the owner of the thread queue is enqueued on a thread queue in + * priority order with priority inheritance. + */ + ctx->owner_obtain = TQ_EVENT_MUTEX_C_OBTAIN; + ctx->owner_release = TQ_EVENT_MUTEX_C_RELEASE; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Only: { + /* + * While the priority node of the owner is the only priority node in the + * priority queue associated with the scheduler of the thread queue on + * which the owner is enqueued. + */ + ctx->owner_queue_node = TQ_NODE_ONLY; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Vital: { + /* + * While the priority node of the owner is not the only priority node in + * the priority queue associated with the scheduler of the thread queue + * on which the owner is enqueued, while the priority node of the owner + * is the highest priority node in the priority queue. + */ + ctx->owner_queue_node = TQ_NODE_VITAL; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Dispensable: { + /* + * While the priority node of the owner is not the only priority node in + * the priority queue associated with the scheduler of the thread queue + * on which the owner is enqueued, while the priority node of the owner + * is not the highest priority node in the priority queue. + */ + ctx->owner_queue_node = TQ_NODE_DISPENSABLE; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Only: { + /* + * While the priority node of the thread queue on which the owner is + * enqueued is the only priority node associated with the scheduler + * available to the owner of the thread queue on which the owner is + * enqueued. + */ + ctx->owner_owner_node = TQ_NODE_ONLY; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Vital: { + /* + * While the priority node of the thread queue on which the owner is + * enqueued is not the only priority node associated with the scheduler + * available to the owner of the thread queue on which the owner is + * enqueued, while the priority node of the thread queue on which the + * owner is enqueued is the highest priority node available to the owner + * of the thread queue on which the owner is enqueued. + */ + ctx->owner_owner_node = TQ_NODE_VITAL; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Dispensable: { + /* + * While the priority node of the thread queue on which the owner is + * enqueued is not the only priority node associated with the scheduler + * available to the owner of the thread queue on which the owner is + * enqueued, while the priority node of the thread queue is on which the + * owner is enqueued not the highest priority node available to the owner + * of the thread queue on which the owner is enqueued. + */ + ctx->owner_owner_node = TQ_NODE_DISPENSABLE; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Pre_WaitState state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Blocked: { + /* + * While the thread is in the blocked wait state. + */ + ctx->wait_state = TQ_WAIT_STATE_BLOCKED; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_IntendToBlock: { + /* + * While the thread is in the intend to block wait state. + */ + ctx->wait_state = TQ_WAIT_STATE_INTEND_TO_BLOCK; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_ReadyAgain: { + /* + * While the thread is in the ready again wait state. + */ + ctx->wait_state = TQ_WAIT_STATE_READY_AGAIN; + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Post_Status_Check( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Post_Status state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok: { + /* + * The return status of the directive call shall be derived from + * STATUS_SUCCESSFUL. + */ + T_eq_int( + ctx->tq_ctx->status[ THREAD ], + TQConvertStatus( ctx->tq_ctx, STATUS_SUCCESSFUL ) + ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout: { + /* + * The return status of the directive call shall be derived from + * STATUS_TIMEOUT. + */ + T_eq_int( + ctx->tq_ctx->status[ THREAD ], + TQConvertStatus( ctx->tq_ctx, STATUS_TIMEOUT ) + ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_Status_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Check( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock state +) +{ + size_t i; + + i = 0; + + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes: { + /* + * The thread shall be unblocked by the timeout operation. + */ + T_true( GetUnblock( ctx, &i ) ); + T_false( GetUnblock( ctx, &i ) ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No: { + /* + * The thread shall not be unblocked by the timeout operation. + */ + T_false( GetUnblock( ctx, &i ) ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Check( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop: { + /* + * The priority of the owner with respect to the scheduler shall not + * change by the timeout operation. + */ + T_eq_u32( ctx->owner_priority_after, ctx->owner_priority ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower: { + /* + * The priority of the owner with respect to the scheduler shall be + * lowered to the next highest priority. + */ + T_eq_u32( ctx->owner_priority_after, ctx->owner_priority + 1 ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop: { + /* + * The owner shall not have a priority with respect to the scheduler. + */ + T_eq_u32( ctx->owner_priority_after, PRIO_INVALID ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Check( + ScoreTqReqTimeoutPriorityInherit_Context *ctx, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority state +) +{ + switch ( state ) { + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop: { + /* + * The priority of the owner of the thread queue on which the owner is + * enqueued with respect to the scheduler shall not change by the timeout + * operation. + */ + T_eq_u32( ctx->owner_owner_priority_after, ctx->owner_owner_priority ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower: { + /* + * The priority of the owner of the thread queue on which the owner is + * enqueued with respect to the scheduler shall be lowered to the next + * highest priority. + */ + T_eq_u32( ctx->owner_owner_priority_after, ctx->owner_owner_priority + 1 ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Drop: { + /* + * The owner of the thread queue on which the owner is enqueued shall not + * have a priority with respect to the scheduler. + */ + T_eq_u32( ctx->owner_owner_priority_after, PRIO_INVALID ); + break; + } + + case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA: + break; + } +} + +static void ScoreTqReqTimeoutPriorityInherit_Setup( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + ctx->request.arg = ctx; + TQReset( ctx->tq_ctx ); + SetSelfPriority( PRIO_NEARLY_IDLE ); +} + +static void ScoreTqReqTimeoutPriorityInherit_Setup_Wrap( void *arg ) +{ + ScoreTqReqTimeoutPriorityInherit_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + ScoreTqReqTimeoutPriorityInherit_Setup( ctx ); +} + +static void ScoreTqReqTimeoutPriorityInherit_Teardown( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + TQReset( ctx->tq_ctx ); +} + +static void ScoreTqReqTimeoutPriorityInherit_Teardown_Wrap( void *arg ) +{ + ScoreTqReqTimeoutPriorityInherit_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + ScoreTqReqTimeoutPriorityInherit_Teardown( ctx ); +} + +static void ScoreTqReqTimeoutPriorityInherit_Prepare( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + ctx->queue_helper_surrender = false; + ctx->owner_helper_release = false; + ctx->owner_queue_helper_release = false; + ctx->owner_owner_helper_release = false; +} + +static void ScoreTqReqTimeoutPriorityInherit_Action( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + rtems_task_priority priority; + + priority = PRIO_FLEXIBLE; + TQSetScheduler( ctx->tq_ctx, THREAD, ctx->scheduler_id, priority ); + + TQSend( + ctx->tq_ctx, + OWNER, + TQ_EVENT_MUTEX_A_OBTAIN | TQ_EVENT_ENQUEUE + ); + + if ( ctx->owner_obtain != 0 ) { + TQSend( + ctx->tq_ctx, + OWNER_OWNER, + TQ_EVENT_MUTEX_B_OBTAIN | ctx->owner_obtain + ); + TQSend( ctx->tq_ctx, OWNER, ctx->owner_obtain | ctx->owner_release ); + } + + PrepareThread( ctx ); + priority = PrepareQueue( ctx, priority ); + priority = PrepareOwner( ctx, priority ); + priority = PrepareOwnerQueue( ctx, priority ); + PrepareOwnerOwner( ctx, priority ); + + TQClearDone( ctx->tq_ctx, THREAD ); + + switch ( ctx->wait_state ) { + case TQ_WAIT_STATE_BLOCKED: + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD, + TQ_EVENT_ENQUEUE_TIMED + ); + Tick( ctx ); + GetPriorities( ctx ); + TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_SURRENDER ); + break; + case TQ_WAIT_STATE_INTEND_TO_BLOCK: + T_scheduler_set_event_handler( SchedulerBlock, ctx ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD, + TQ_EVENT_ENQUEUE_TIMED + ); + GetPriorities( ctx ); + TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_SURRENDER ); + break; + case TQ_WAIT_STATE_READY_AGAIN: + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD, + TQ_EVENT_ENQUEUE_TIMED + ); + T_scheduler_set_event_handler( SchedulerUnblock, ctx ); + TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_SURRENDER ); + GetPriorities( ctx ); + TQSend( ctx->tq_ctx, THREAD, TQ_EVENT_SURRENDER ); + break; + } + + TQWaitForDone( ctx->tq_ctx, THREAD ); + TQWaitForExecutionStop( ctx->tq_ctx, THREAD ); +} + +static void ScoreTqReqTimeoutPriorityInherit_Cleanup( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + if ( ctx->owner_obtain != 0 ) { + TQSend( + ctx->tq_ctx, + OWNER_OWNER, + TQ_EVENT_MUTEX_B_RELEASE | ctx->owner_release + ); + + if ( ctx->owner_queue_helper_release ) { + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_QUEUE_HELPER, + ctx->owner_release + ); + } + + if ( ctx->owner_owner_helper_release ) { + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_OWNER_HELPER, + TQ_EVENT_MUTEX_B_RELEASE + ); + } + } + + TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_MUTEX_A_RELEASE ); + + if ( ctx->queue_helper_surrender ) { + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + QUEUE_HELPER, + TQ_EVENT_SURRENDER + ); + } + + if ( ctx->owner_helper_release ) { + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + OWNER_HELPER, + TQ_EVENT_MUTEX_A_RELEASE + ); + } + + if ( ctx->other_scheduler ) { + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD, + TQ_EVENT_MUTEX_D_RELEASE + ); + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD_HELPER_A, + TQ_EVENT_MUTEX_D_RELEASE + ); + + if ( rtems_scheduler_get_processor_maximum() >= 3 ) { + TQSendAndWaitForExecutionStop( + ctx->tq_ctx, + THREAD_HELPER_B, + TQ_EVENT_MUTEX_D_RELEASE + ); + } + } +} + +static const ScoreTqReqTimeoutPriorityInherit_Entry +ScoreTqReqTimeoutPriorityInherit_Entries[] = { +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower }, +#endif + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#endif + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 0, 0, 0, 0, 0, 0, 1, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, +#endif + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 0, 0, 0, 0, 0, 0, 0, 1, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower }, +#endif + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower }, + { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Drop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA } +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, + ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout, + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop, + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Drop } +#endif +}; + +static const uint8_t +ScoreTqReqTimeoutPriorityInherit_Map[] = { + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, + 1, 2, 2, 2, 2, 2, 2, 24, 25, 31, 24, 25, 31, 2, 2, 2, 24, 25, 31, 24, 25, 31, + 2, 2, 2, 1, 1, 1, 24, 25, 31, 2, 2, 2, 24, 25, 11, 24, 25, 11, 2, 2, 2, 24, + 25, 11, 24, 25, 11, 2, 2, 2, 1, 1, 1, 24, 25, 11, 2, 2, 2, 32, 33, 11, 32, + 33, 11, 2, 2, 2, 32, 33, 11, 32, 33, 11, 2, 2, 2, 1, 1, 1, 32, 33, 11, 2, 2, + 2, 44, 45, 11, 36, 37, 11, 2, 2, 2, 44, 45, 11, 36, 37, 11, 2, 2, 2, 1, 1, 1, + 36, 37, 11, 2, 2, 2, 1, 1, 1, 29, 30, 46, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, + 1, 1, 1, 29, 30, 46, 2, 2, 2, 1, 1, 1, 29, 30, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 1, 1, 1, 29, 30, 11, 2, 2, 2, 1, 1, 1, 38, 39, 11, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 2, 2, 2, 1, 1, 1, 38, 39, 11, 2, 2, 2, 1, 1, 1, 40, 41, 11, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 40, 41, 11, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 24, 25, + 31, 24, 25, 31, 2, 2, 2, 24, 25, 31, 24, 25, 31, 2, 2, 2, 1, 1, 1, 24, 25, + 31, 2, 2, 2, 24, 25, 11, 24, 25, 11, 2, 2, 2, 24, 25, 11, 24, 25, 11, 2, 2, + 2, 1, 1, 1, 24, 25, 11, 2, 2, 2, 32, 33, 11, 32, 33, 11, 2, 2, 2, 32, 33, 11, + 32, 33, 11, 2, 2, 2, 1, 1, 1, 32, 33, 11, 2, 2, 2, 44, 45, 11, 36, 37, 11, 2, + 2, 2, 44, 45, 11, 36, 37, 11, 2, 2, 2, 1, 1, 1, 36, 37, 11, 2, 2, 2, 1, 1, 1, + 29, 30, 46, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 46, 2, 2, 2, + 1, 1, 1, 29, 30, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11, + 2, 2, 2, 1, 1, 1, 38, 39, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, + 38, 39, 11, 2, 2, 2, 1, 1, 1, 40, 41, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, + 1, 1, 1, 40, 41, 11, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11, 2, 2, 2, 1, 1, 1, 29, + 30, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11, 2, 2, 2, 1, + 1, 1, 38, 39, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 38, 39, 11, 2, + 2, 2, 1, 1, 1, 40, 41, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 40, + 41, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, + 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 0, 0, 0, 3, 3, 3, 3, 3, 3, 5, 6, 12, 5, 6, 12, 3, 3, 3, 5, 6, 12, 5, 6, + 12, 3, 3, 3, 0, 0, 0, 5, 6, 12, 3, 3, 3, 5, 6, 4, 5, 6, 4, 3, 3, 3, 5, 6, 4, + 5, 6, 4, 3, 3, 3, 0, 0, 0, 5, 6, 4, 3, 3, 3, 9, 10, 4, 9, 10, 4, 3, 3, 3, 9, + 10, 4, 9, 10, 4, 3, 3, 3, 0, 0, 0, 9, 10, 4, 3, 3, 3, 22, 23, 4, 20, 21, 4, + 3, 3, 3, 22, 23, 4, 20, 21, 4, 3, 3, 3, 0, 0, 0, 20, 21, 4, 3, 3, 3, 0, 0, 0, + 7, 8, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 26, 3, 3, 3, 0, + 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3, + 0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 13, 14, 4, + 3, 3, 3, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 15, + 16, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, + 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 0, 0, 0, 3, 3, 3, 3, 3, 3, 5, 6, 12, 5, 6, 12, 3, 3, 3, 5, 6, 12, 5, 6, + 12, 3, 3, 3, 0, 0, 0, 5, 6, 12, 3, 3, 3, 5, 6, 4, 5, 6, 4, 3, 3, 3, 5, 6, 4, + 5, 6, 4, 3, 3, 3, 0, 0, 0, 5, 6, 4, 3, 3, 3, 9, 10, 4, 9, 10, 4, 3, 3, 3, 9, + 10, 4, 9, 10, 4, 3, 3, 3, 0, 0, 0, 9, 10, 4, 3, 3, 3, 22, 23, 4, 20, 21, 4, + 3, 3, 3, 22, 23, 4, 20, 21, 4, 3, 3, 3, 0, 0, 0, 20, 21, 4, 3, 3, 3, 0, 0, 0, + 7, 8, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 26, 3, 3, 3, 0, + 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3, + 0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 13, 14, 4, + 3, 3, 3, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 15, + 16, 4, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, + 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, + 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, + 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, + 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3, 0, 0, 0, 13, 14, 4, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 13, 14, 4, 3, 3, 3, 0, 0, 0, 15, 16, 4, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 15, 16, 4, 17, 18, 19, 17, 18, + 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 0, 0, 0, 17, + 18, 19, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, + 18, 4, 0, 0, 0, 17, 18, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4, 27, + 28, 4, 27, 28, 4, 27, 28, 4, 0, 0, 0, 27, 28, 4, 47, 48, 4, 42, 43, 4, 34, + 35, 4, 42, 43, 4, 42, 43, 4, 34, 35, 4, 34, 35, 4, 0, 0, 0, 34, 35, 4, 5, 6, + 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0, 5, + 6, 12, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0, 0, + 0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, + 10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23, + 4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, + 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, + 4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, + 4, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 0, + 0, 0, 5, 6, 19, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, + 4, 0, 0, 0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, + 4, 9, 10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, + 22, 23, 4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 5, 6, 12, 5, 6, 12, 5, + 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0, 5, 6, 12, 5, 6, 4, 5, + 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0, 0, 0, 5, 6, 4, 9, 10, + 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 0, 0, 0, 9, + 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 20, + 21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15, + 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4, 7, 8, 4, 0, + 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4, + 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, + 14, 4, 0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, + 14, 4, 15, 16, 4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, + 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15, + 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4, 17, 18, 19, + 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 0, 0, + 0, 17, 18, 19, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, + 4, 17, 18, 4, 0, 0, 0, 17, 18, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4, + 27, 28, 4, 27, 28, 4, 27, 28, 4, 0, 0, 0, 27, 28, 4, 47, 48, 4, 42, 43, 4, + 34, 35, 4, 42, 43, 4, 42, 43, 4, 34, 35, 4, 34, 35, 4, 0, 0, 0, 34, 35, 4, 5, + 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0, + 5, 6, 12, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0, + 0, 0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, + 10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23, + 4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8, + 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, + 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, + 4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, + 4, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 0, + 0, 0, 5, 6, 19, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, + 4, 0, 0, 0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, + 4, 9, 10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, + 22, 23, 4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 5, 6, 12, 5, 6, 12, 5, + 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0, 5, 6, 12, 5, 6, 4, 5, + 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0, 0, 0, 5, 6, 4, 9, 10, + 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 0, 0, 0, 9, + 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 20, + 21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15, + 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4, 7, 8, 4, 0, + 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4, + 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, + 14, 4, 0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, + 14, 4, 15, 16, 4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, + 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15, + 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4 +}; + +static size_t ScoreTqReqTimeoutPriorityInherit_Scope( + void *arg, + char *buf, + size_t n +) +{ + ScoreTqReqTimeoutPriorityInherit_Context *ctx; + + ctx = arg; + + if ( ctx->Map.in_action_loop ) { + return T_get_scope( + ScoreTqReqTimeoutPriorityInherit_PreDesc, + buf, + n, + ctx->Map.pcs + ); + } + + return 0; +} + +static T_fixture ScoreTqReqTimeoutPriorityInherit_Fixture = { + .setup = ScoreTqReqTimeoutPriorityInherit_Setup_Wrap, + .stop = NULL, + .teardown = ScoreTqReqTimeoutPriorityInherit_Teardown_Wrap, + .scope = ScoreTqReqTimeoutPriorityInherit_Scope, + .initial_context = &ScoreTqReqTimeoutPriorityInherit_Instance +}; + +static inline ScoreTqReqTimeoutPriorityInherit_Entry +ScoreTqReqTimeoutPriorityInherit_PopEntry( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + size_t index; + + index = ctx->Map.index; + ctx->Map.index = index + 1; + return ScoreTqReqTimeoutPriorityInherit_Entries[ + ScoreTqReqTimeoutPriorityInherit_Map[ index ] + ]; +} + +static void ScoreTqReqTimeoutPriorityInherit_SetPreConditionStates( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ]; + ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ]; + ctx->Map.pcs[ 2 ] = ctx->Map.pci[ 2 ]; + ctx->Map.pcs[ 3 ] = ctx->Map.pci[ 3 ]; + ctx->Map.pcs[ 4 ] = ctx->Map.pci[ 4 ]; + + if ( ctx->Map.entry.Pre_OwnerQueue_NA ) { + ctx->Map.pcs[ 5 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_NA; + } else { + ctx->Map.pcs[ 5 ] = ctx->Map.pci[ 5 ]; + } + + if ( ctx->Map.entry.Pre_OwnerOwnerPriority_NA ) { + ctx->Map.pcs[ 6 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA; + } else { + ctx->Map.pcs[ 6 ] = ctx->Map.pci[ 6 ]; + } + + ctx->Map.pcs[ 7 ] = ctx->Map.pci[ 7 ]; +} + +static void ScoreTqReqTimeoutPriorityInherit_TestVariant( + ScoreTqReqTimeoutPriorityInherit_Context *ctx +) +{ + ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Prepare( + ctx, + ctx->Map.pcs[ 0 ] + ); + ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_Prepare( + ctx, + ctx->Map.pcs[ 1 ] + ); + ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Prepare( ctx, ctx->Map.pcs[ 2 ] ); + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Prepare( + ctx, + ctx->Map.pcs[ 3 ] + ); + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_Prepare( + ctx, + ctx->Map.pcs[ 4 ] + ); + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Prepare( + ctx, + ctx->Map.pcs[ 5 ] + ); + ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Prepare( + ctx, + ctx->Map.pcs[ 6 ] + ); + ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Prepare( + ctx, + ctx->Map.pcs[ 7 ] + ); + ScoreTqReqTimeoutPriorityInherit_Action( ctx ); + ScoreTqReqTimeoutPriorityInherit_Post_Status_Check( + ctx, + ctx->Map.entry.Post_Status + ); + ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Check( + ctx, + ctx->Map.entry.Post_Unblock + ); + ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Check( + ctx, + ctx->Map.entry.Post_OwnerPriority + ); + ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Check( + ctx, + ctx->Map.entry.Post_OwnerOwnerPriority + ); +} + +static T_fixture_node ScoreTqReqTimeoutPriorityInherit_Node; + +static T_remark ScoreTqReqTimeoutPriorityInherit_Remark = { + .next = NULL, + .remark = "ScoreTqReqTimeoutPriorityInherit" +}; + +void ScoreTqReqTimeoutPriorityInherit_Run( TQContext *tq_ctx ) +{ + ScoreTqReqTimeoutPriorityInherit_Context *ctx; + + ctx = &ScoreTqReqTimeoutPriorityInherit_Instance; + ctx->tq_ctx = tq_ctx; + + ctx = T_push_fixture( + &ScoreTqReqTimeoutPriorityInherit_Node, + &ScoreTqReqTimeoutPriorityInherit_Fixture + ); + ctx->Map.in_action_loop = true; + ctx->Map.index = 0; + + for ( + ctx->Map.pci[ 0 ] = ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Home; + ctx->Map.pci[ 0 ] < ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_NA; + ++ctx->Map.pci[ 0 ] + ) { + for ( + ctx->Map.pci[ 1 ] = ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_One; + ctx->Map.pci[ 1 ] < ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_NA; + ++ctx->Map.pci[ 1 ] + ) { + for ( + ctx->Map.pci[ 2 ] = ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Only; + ctx->Map.pci[ 2 ] < ScoreTqReqTimeoutPriorityInherit_Pre_Queue_NA; + ++ctx->Map.pci[ 2 ] + ) { + for ( + ctx->Map.pci[ 3 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Only; + ctx->Map.pci[ 3 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_NA; + ++ctx->Map.pci[ 3 ] + ) { + for ( + ctx->Map.pci[ 4 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NotEnqueued; + ctx->Map.pci[ 4 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NA; + ++ctx->Map.pci[ 4 ] + ) { + for ( + ctx->Map.pci[ 5 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Only; + ctx->Map.pci[ 5 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_NA; + ++ctx->Map.pci[ 5 ] + ) { + for ( + ctx->Map.pci[ 6 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Only; + ctx->Map.pci[ 6 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA; + ++ctx->Map.pci[ 6 ] + ) { + for ( + ctx->Map.pci[ 7 ] = ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Blocked; + ctx->Map.pci[ 7 ] < ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_NA; + ++ctx->Map.pci[ 7 ] + ) { + ctx->Map.entry = ScoreTqReqTimeoutPriorityInherit_PopEntry( + ctx + ); + + if ( ctx->Map.entry.Skip ) { + continue; + } + + ScoreTqReqTimeoutPriorityInherit_SetPreConditionStates( + ctx + ); + ScoreTqReqTimeoutPriorityInherit_Prepare( ctx ); + ScoreTqReqTimeoutPriorityInherit_TestVariant( ctx ); + ScoreTqReqTimeoutPriorityInherit_Cleanup( ctx ); + } + } + } + } + } + } + } + } + + T_add_remark( &ScoreTqReqTimeoutPriorityInherit_Remark ); + T_pop_fixture(); +} + +/** @} */ |