C++ (Cpp) _Thread_Is_heir 예제들

예제 #1

파일: schedulerpriorityyield.c 프로젝트: cotodevel/rtems-gsoc2012

void _Scheduler_priority_Yield(void)
{
  Scheduler_priority_Per_thread *sched_info;
  ISR_Level                      level;
  Thread_Control                *executing;
  Chain_Control                 *ready;

  executing  = _Thread_Executing;
  sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
  ready      = sched_info->ready_chain;
  _ISR_Disable( level );
    if ( !_Chain_Has_only_one_node( ready ) ) {
      _Chain_Extract_unprotected( &executing->Object.Node );
      _Chain_Append_unprotected( ready, &executing->Object.Node );

      _ISR_Flash( level );

      if ( _Thread_Is_heir( executing ) )
        _Thread_Heir = (Thread_Control *) _Chain_First( ready );
      _Thread_Dispatch_necessary = true;
    }
    else if ( !_Thread_Is_heir( executing ) )
      _Thread_Dispatch_necessary = true;

  _ISR_Enable( level );
}

예제 #2

파일: threadresettimeslice.c 프로젝트: epicsdeb/rtems

void _Thread_Reset_timeslice( void )
{
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
  ready     = executing->ready;
  _ISR_Disable( level );
    if ( _Chain_Has_only_one_node( ready ) ) {
      _ISR_Enable( level );
      return;
    }
    _Chain_Extract_unprotected( &executing->Object.Node );
    _Chain_Append_unprotected( ready, &executing->Object.Node );

  _ISR_Flash( level );

    if ( _Thread_Is_heir( executing ) )
      _Thread_Heir = (Thread_Control *) ready->first;

    _Context_Switch_necessary = true;

  _ISR_Enable( level );
}

예제 #3

파일: taskmode.c 프로젝트: riteshharjani/rtems-gsoc2013

static void _RTEMS_Tasks_Dispatch_if_necessary(
  Thread_Control *executing,
  bool            needs_asr_dispatching
)
{
  if ( _Thread_Dispatch_is_enabled() ) {
    bool dispatch_necessary = needs_asr_dispatching;

    /*
     * FIXME: This locking approach is brittle.  It only works since the
     * current simple SMP scheduler has no support for the non-preempt mode.
     */
#if defined( RTEMS_SMP )
    ISR_Level level;

    _ISR_Disable( level );
#endif

    if ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) {
      dispatch_necessary = true;
      _Thread_Dispatch_necessary = dispatch_necessary;
    }

#if defined( RTEMS_SMP )
    _ISR_Enable( level );
#endif

    if ( dispatch_necessary ) {
      _Thread_Dispatch();
    }
  }
}

예제 #4

파일: schedulersimpleblock.c 프로젝트: aniwang2013/leon-rtems

void _Scheduler_simple_Block(
  Thread_Control   *the_thread
)
{
  _Scheduler_simple_Extract(the_thread);

  if ( _Thread_Is_heir( the_thread ) )
    _Scheduler_simple_Schedule();

  if ( _Thread_Is_executing( the_thread ) )
    _Thread_Dispatch_necessary = true;
}

예제 #5

파일: threadevaluatemode.c 프로젝트: FullMentalPanic/RTEMS_NEW_TOOL_CHAIN

bool _Thread_Evaluate_mode( void )
{
  Thread_Control     *executing;

  executing = _Thread_Executing;

  if ( !_States_Is_ready( executing->current_state ) ||
       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
    _Context_Switch_necessary = true;
    return true;
  }

  return false;
}

예제 #6

파일: scheduleredfblock.c 프로젝트: vipulnayyar/rtems

void _Scheduler_EDF_Block(
  Thread_Control    *the_thread
)
{
  _Scheduler_EDF_Extract( the_thread );

  /* TODO: flash critical section? */

  if ( _Thread_Is_heir( the_thread ) )
    _Scheduler_EDF_Schedule();

  if ( _Thread_Is_executing( the_thread ) )
    _Thread_Dispatch_necessary = true;
}

예제 #7

파일: schedulerpriorityblock.c 프로젝트: aniwang2013/leon-rtems

void _Scheduler_priority_Block(
  Thread_Control   *the_thread
)
{
  _Scheduler_priority_Ready_queue_extract( the_thread );

  /* TODO: flash critical section? */

  if ( _Thread_Is_heir( the_thread ) )
     _Scheduler_priority_Schedule_body();

  if ( _Thread_Is_executing( the_thread ) )
    _Thread_Dispatch_necessary = true;

}

예제 #8

파일: schedulersimpleyield.c 프로젝트: aniwang2013/leon-rtems

void _Scheduler_simple_Yield( void )
{
  ISR_Level       level;
  Thread_Control *executing;

  executing = _Thread_Executing;
  _ISR_Disable( level );

    _Scheduler_simple_Ready_queue_requeue(&_Scheduler, executing);

    _ISR_Flash( level );

    _Scheduler_simple_Schedule();

    if ( !_Thread_Is_heir( executing ) )
      _Thread_Dispatch_necessary = true;

  _ISR_Enable( level );
}

예제 #9

파일: threadsuspend.c 프로젝트: FullMentalPanic/RTEMS_NEW_TOOL_CHAIN

void _Thread_Suspend(
  Thread_Control   *the_thread
)
{
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
  #if defined(RTEMS_ITRON_API)
    the_thread->suspend_count++;
  #endif
  if ( !_States_Is_ready( the_thread->current_state ) ) {
    the_thread->current_state =
       _States_Set( STATES_SUSPENDED, the_thread->current_state );
    _ISR_Enable( level );
    return;
  }

  the_thread->current_state = STATES_SUSPENDED;

  if ( _Chain_Has_only_one_node( ready ) ) {

    _Chain_Initialize_empty( ready );
    _Priority_Remove_from_bit_map( &the_thread->Priority_map );

  } else
    _Chain_Extract_unprotected( &the_thread->Object.Node );

  _ISR_Flash( level );

  if ( _Thread_Is_heir( the_thread ) )
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
    _Context_Switch_necessary = true;

  _ISR_Enable( level );
}

예제 #10

파일: threadsetstate.c 프로젝트: jfpmonteiro/rtems-4.8-rhealstone

void _Thread_Set_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
  if ( !_States_Is_ready( the_thread->current_state ) ) {
    the_thread->current_state =
       _States_Set( state, the_thread->current_state );
    _ISR_Enable( level );
    return;
  }

  the_thread->current_state = state;

  if ( _Chain_Has_only_one_node( ready ) ) {

    _Chain_Initialize_empty( ready );
    _Priority_Remove_from_bit_map( &the_thread->Priority_map );

  } else
    _Chain_Extract_unprotected( &the_thread->Object.Node );

  _ISR_Flash( level );

  if ( _Thread_Is_heir( the_thread ) )
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
    _Context_Switch_necessary = TRUE;

  _ISR_Enable( level );
}