rtems支持阻塞任务调度，这个名字听起来有点奇怪，按照通俗的理解，就是当任务遇到IO事件或等待事件时，可以将任务设置为阻塞状态，然后将其从就绪队列移除

一、测试程序

对于阻塞任务调度，我们可以两种方式测试

主动等待睡眠
线程任务挂起

对于上面两种程序，主要是两个函数：rtems_task_suspend/rtems_task_wake_after

为了测试阻塞任务调度，本文基于rtems_task_wake_after来测试，rtems_task_suspend方法一致，就不演示了。

测试rtems_task_wake_after，可以借鉴原有的验证程序，我们可以在Process_asr函数中，将rtems_task_wake_after( RTEMS_YIELD_PROCESSOR );设置为status = rtems_task_wake_after( rtems_clock_get_ticks_per_second() );

这里tick是100为1s。修改了0为100后，rtems_task_wake_after会主动block线程，如下代码：


rtems_status_code rtems_task_wake_after(
  rtems_interval ticks
)
{
  /*
   * It is critical to obtain the executing thread after thread dispatching is
   * disabled on SMP configurations.
   */
  Thread_Control  *executing;
  Per_CPU_Control *cpu_self;
 
  cpu_self = _Thread_Dispatch_disable();
    executing = _Per_CPU_Get_executing( cpu_self );
 
    if ( ticks == 0 ) {
      _Thread_Yield( executing );
    } else {
      _Thread_Set_state( executing, STATES_WAITING_FOR_TIME );
      _Thread_Wait_flags_set( executing, THREAD_WAIT_STATE_BLOCKED );
      _Thread_Add_timeout_ticks( executing, cpu_self, ticks );
    }
  _Thread_Dispatch_direct( cpu_self );
  return RTEMS_SUCCESSFUL;
}

我们可以看到，tick是非0时，会调用_Thread_Set_state( executing, STATES_WAITING_FOR_TIME );函数，此函数加锁后调用_Thread_Set_state_locked，_Thread_Set_state_locked的函数实现如下


States_Control _Thread_Set_state_locked(
  Thread_Control *the_thread,
  States_Control  state
)
{
  States_Control previous_state;
  States_Control next_state;
 
  _Assert( state != 0 );
  _Assert( _Thread_State_is_owner( the_thread ) );
 
  previous_state = the_thread->current_state;
  next_state = _States_Set( state, previous_state);
  the_thread->current_state = next_state;
 
  if ( _States_Is_ready( previous_state ) ) {
    _Scheduler_Block( the_thread );
  }
 
  return previous_state;
}

可以发现，其先将block的state赋值给了当前状态


previous_state = the_thread->current_state;
next_state = _States_Set( state, previous_state);
the_thread->current_state = next_state;

然后如果任务状态是就绪的，则直接阻塞任务


_Scheduler_Block( the_thread );

二、阻塞任务调度实现

_Scheduler_Block的实现如下


static inline void _Scheduler_Block( Thread_Control *the_thread )
{
  Chain_Node              *node;
  const Chain_Node        *tail;
  Scheduler_Node          *scheduler_node;
  const Scheduler_Control *scheduler;
  ISR_lock_Context         lock_context;
 
  node = _Chain_First( &the_thread->Scheduler.Scheduler_nodes );
  tail = _Chain_Immutable_tail( &the_thread->Scheduler.Scheduler_nodes );
 
  scheduler_node = SCHEDULER_NODE_OF_THREAD_SCHEDULER_NODE( node );
  scheduler = _Scheduler_Node_get_scheduler( scheduler_node );
 
  _Scheduler_Acquire_critical( scheduler, &lock_context );
  ( *scheduler->Operations.block )(
    scheduler,
    the_thread,
    scheduler_node
  );
  _Scheduler_Release_critical( scheduler, &lock_context );
 
  node = _Chain_Next( node );
 
  while ( node != tail ) {
    scheduler_node = SCHEDULER_NODE_OF_THREAD_SCHEDULER_NODE( node );
    scheduler = _Scheduler_Node_get_scheduler( scheduler_node );
 
    _Scheduler_Acquire_critical( scheduler, &lock_context );
    ( *scheduler->Operations.withdraw_node )(
      scheduler,
      the_thread,
      scheduler_node,
      THREAD_SCHEDULER_BLOCKED
    );
    _Scheduler_Release_critical( scheduler, &lock_context );
 
    node = _Chain_Next( node );
  }
}

这里可以看到，默认情况下从本调度节点上取出Scheduler_Control，然后直接调用调度器的block函数，然后遍历所有的调度节点，逐个调用调度器的withdraw_node回调。

我们可以查看withdraw的实现如下


(gdb) p *(Scheduler_Control *)0x2d248                                                                                        
$18 = {context = 0x100820 <_Configuration_Scheduler_priority_dflt>, Operations = {
    initialize = 0x1eaf0 <_Scheduler_priority_Initialize>, schedule = 0x1ef10 <_Scheduler_priority_Schedule>,
    yield = 0x1f130 <_Scheduler_priority_Yield>, block = 0x1ebd0 <_Scheduler_priority_Block>,
    unblock = 0x1efd0 <_Scheduler_priority_Unblock>, update_priority = 0x1ecf0 <_Scheduler_priority_Update_priority>,
    map_priority = 0x1ea30 <_Scheduler_default_Map_priority>, unmap_priority = 0x1ea40 <_Scheduler_default_Unmap_priority>,
    ask_for_help = 0x0, reconsider_help_request = 0x0, withdraw_node = 0x0,
    make_sticky = 0x22720 <_Scheduler_default_Sticky_do_nothing>,
    clean_sticky = 0x22720 <_Scheduler_default_Sticky_do_nothing>,
    pin = 0x22760 <_Scheduler_default_Pin_or_unpin_do_nothing>,
    unpin = 0x22760 <_Scheduler_default_Pin_or_unpin_do_nothing>, add_processor = 0x0, remove_processor = 0x0,
    node_initialize = 0x1eb40 <_Scheduler_priority_Node_initialize>,
    node_destroy = 0x1ea50 <_Scheduler_default_Node_destroy>, release_job = 0x1ea60 <_Scheduler_default_Release_job>,
    cancel_job = 0x1ea70 <_Scheduler_default_Cancel_job>, start_idle = 0x1ea80 <_Scheduler_default_Start_idle>,
    set_affinity = 0x22770 <_Scheduler_default_Set_affinity>}, maximum_priority = 255, name = 1431323680,
  is_non_preempt_mode_supported = true}

这里withdraw并未实现，而且scheduler_node 是根据线程来创建的，如果只有一个线程，则scheduler_node 就一个。可以查看如下定义


#define _CONFIGURE_SCHEDULER_COUNT RTEMS_ARRAY_SIZE( _Scheduler_Table )
const size_t _Scheduler_Count = _CONFIGURE_SCHEDULER_COUNT;

所以我们在_Thread_Initialize_scheduler_and_wait_nodes可以看到如下调用


do {
......
  } while ( scheduler_index < _Scheduler_Count );

对于block的实现，实际上是将此任务从就绪队列删除。

目录

一、测试程序

二、阻塞任务调度实现