RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

score: Move _Scheduler_Unblock_node()

Browse Source 
Move _Scheduler_Unblock_node() into _Scheduler_SMP_Unblock().  This simplifies
the code and makes it easier to review.

Update #4531.
This commit is contained in:
Sebastian Huber
2021-10-29 13:44:04 +02:00
parent dcd8b939ba
commit c6362f640a
2 changed files with 35 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
cpukit/include/rtems/score/schedulerimpl.h
View File

@@ -954,48 +954,6 @@ RTEMS_INLINE_ROUTINE void _Scheduler_Discard_idle_thread(
_Thread_Set_CPU( the_thread, cpu ); _Thread_Set_CPU( the_thread, cpu );
_Thread_Dispatch_update_heir( _Per_CPU_Get(), cpu, the_thread ); _Thread_Dispatch_update_heir( _Per_CPU_Get(), cpu, the_thread );
} }
/**
* @brief Unblocks this scheduler node.
*
* @param context The scheduler instance context.
* @param[in, out] the_thread The thread which wants to get unblocked.
* @param[in, out] node The node which wants to get unblocked.
* @param is_scheduled This node is scheduled.
* @param release_idle_thread Function to release an idle thread.
*
* @retval true Continue with the unblocking operation.
* @retval false Do not continue with the unblocking operation.
*/
RTEMS_INLINE_ROUTINE bool _Scheduler_Unblock_node(
Thread_Control *the_thread,
Scheduler_Node *node,
bool is_scheduled,
Scheduler_Release_idle_node release_idle_node,
void *arg
)
{
bool unblock;
++node->sticky_level;
_Assert( node->sticky_level > 0 );
if ( is_scheduled ) {
_Scheduler_Thread_change_state( the_thread, THREAD_SCHEDULER_SCHEDULED );
_Scheduler_Discard_idle_thread(
the_thread,
node,
release_idle_node,
arg
);
unblock = false;
} else {
_Scheduler_Thread_change_state( the_thread, THREAD_SCHEDULER_READY );
unblock = true;
}
return unblock;
}
#endif #endif
/** /**

64
cpukit/include/rtems/score/schedulersmpimpl.h
View File

@@ -1326,43 +1326,49 @@ static inline void _Scheduler_SMP_Unblock(
) )
{ {
Scheduler_SMP_Node_state node_state; Scheduler_SMP_Node_state node_state;
bool unblock; Priority_Control priority;
bool needs_help;
++node->sticky_level;
_Assert( node->sticky_level > 0 );
node_state = _Scheduler_SMP_Node_state( node ); node_state = _Scheduler_SMP_Node_state( node );
unblock = _Scheduler_Unblock_node(
thread,
node,
node_state == SCHEDULER_SMP_NODE_SCHEDULED,
release_idle_node,
context
);
if ( unblock ) { if ( RTEMS_PREDICT_FALSE( node_state == SCHEDULER_SMP_NODE_SCHEDULED ) ) {
Priority_Control priority; _Scheduler_Thread_change_state( thread, THREAD_SCHEDULER_SCHEDULED );
bool needs_help; _Scheduler_Discard_idle_thread(
thread,
node,
release_idle_node,
context
);
priority = _Scheduler_Node_get_priority( node ); return;
priority = SCHEDULER_PRIORITY_PURIFY( priority ); }
if ( priority != _Scheduler_SMP_Node_priority( node ) ) { _Scheduler_Thread_change_state( thread, THREAD_SCHEDULER_READY );
( *update )( context, node, priority );
}
if ( node_state == SCHEDULER_SMP_NODE_BLOCKED ) { priority = _Scheduler_Node_get_priority( node );
Priority_Control insert_priority; priority = SCHEDULER_PRIORITY_PURIFY( priority );
insert_priority = SCHEDULER_PRIORITY_APPEND( priority ); if ( priority != _Scheduler_SMP_Node_priority( node ) ) {
needs_help = ( *enqueue )( context, node, insert_priority ); ( *update )( context, node, priority );
} else { }
_Assert( node_state == SCHEDULER_SMP_NODE_READY );
_Assert( node->sticky_level > 0 );
_Assert( node->idle == NULL );
needs_help = true;
}
if ( needs_help ) { if ( node_state == SCHEDULER_SMP_NODE_BLOCKED ) {
_Scheduler_Ask_for_help( thread ); Priority_Control insert_priority;
}
insert_priority = SCHEDULER_PRIORITY_APPEND( priority );
needs_help = ( *enqueue )( context, node, insert_priority );
} else {
_Assert( node_state == SCHEDULER_SMP_NODE_READY );
_Assert( node->sticky_level > 0 );
_Assert( node->idle == NULL );
needs_help = true;
}
if ( needs_help ) {
_Scheduler_Ask_for_help( thread );
} }
} }