/*! * Select ready thread with highest priority as active * - if different from current, move current into ready queue (id not NULL) and * move selected thread from ready queue to active queue */ void kthreads_schedule () { kthread_t *curr, *next = NULL; curr = kthread_get_active(); next = get_first_ready (); /* must exist an thread to return to, 'curr' or first from 'ready' */ ASSERT ( ( curr && kthread_is_active ( curr ) ) || next ); if ( !sys__feature ( FEATURE_SCHEDULER, FEATURE_GET, 0 ) && curr && kthread_is_active ( curr ) ) return;/*scheduler disabled, don't switch from current thread */ if ( !curr || !kthread_is_active ( curr ) || kthread_get_prio ( curr ) < kthread_get_prio ( next ) ) { if ( curr && !kthread_is_passive (curr) ) /* deactivate curr */ { /* move last active to ready queue, if still ready */ if ( kthread_is_active ( curr ) ) kthread_move_to_ready ( curr, LAST ); /* deactivation might change ready thread list */ next = get_first_ready (); ASSERT (next); } /* activate next */ next = kthread_remove_from_ready ( next ); ASSERT ( next ); kthread_set_active ( next ); } /* process pending signals (if any) */ ksignal_process_pending ( kthread_get_active() ); if ( curr != kthread_get_active() ) kthread_switch_to_thread ( curr, kthread_get_active() ); /* else => continue with current thread */ }
/*! * Simple Round-Robin scheduler: * - on timer tick move active into ready queue and pick next ready task */ static void ksched_rr_tick ( sigval_t sigval ) { if ( sys__feature ( FEATURE_SCHED_RR, FEATURE_GET, 0 ) == 0 ) return; kthread_t *active_thread = kthread_get_active(); if ( kthread_is_active ( active_thread ) ) { kthread_move_to_ready ( active_thread, LAST ); kthreads_schedule (); } }
static int k_edf_schedule () { kthread_t *first, *next, *edf_active; kthread_sched_data_t *sch_first, *sch_next; ksched_t *gsched = ksched_get ( SCHED_EDF ); int retval = 0; edf_active = gsched->params.edf.active; first = kthreadq_get ( &gsched->params.edf.ready ); LOG( DEBUG, "%x [active]", edf_active ); LOG( DEBUG, "%x [first]", first ); //LOG( DEBUG, "%x [next]", next ); if ( !first ) return 0; /* no threads in edf.ready queue, edf.active unch. */ if ( edf_active ) { next = first; first = edf_active; LOG( DEBUG, "%x [next]", kthreadq_get_next ( next ) ); } else { next = kthreadq_get_next ( first ); LOG( DEBUG, "%x [next]", next ); } while ( first && next ) { sch_first = kthread_get_sched_param ( first ); sch_next = kthread_get_sched_param ( next ); if ( time_cmp ( &sch_first->params.edf.active_deadline, &sch_next->params.edf.active_deadline ) > 0 ) { first = next; } next = kthreadq_get_next ( next ); } if ( first && first != edf_active ) { next = kthreadq_remove ( &gsched->params.edf.ready, first ); LOG ( DEBUG, "%x removed, %x is now first", next, kthreadq_get ( &gsched->params.edf.ready ) ); if ( edf_active ) { LOG( DEBUG, "%x=>%x [EDF_SCHED_PREEMPT]", edf_active, first ); /* * change active EDF thread: * -remove it from active/ready list * -put it into edf.ready list */ if ( kthread_is_ready (edf_active) ) { if ( !kthread_is_active (edf_active) ) { kthread_remove_from_ready (edf_active); /* * set "deactivated" flag, don't need * another call to "edf_schedule" */ } else { kthread_get_sched_param (edf_active) ->activated = 0; } kthread_enqueue ( edf_active, &gsched->params.edf.ready ); } /* else = thread is blocked - leave it there */ } gsched->params.edf.active = first; LOG( DEBUG, "%x [new active]", first ); kthread_move_to_ready ( first, LAST ); retval = 1; } return retval; }
static int edf_schedule ( ksched_t *ksched ) { kthread_t *first, *next, *edf_active; kthread_sched2_t *sch_first, *sch_next, *ea; edf_active = ksched->params.edf.active; if ( edf_active && !kthread_is_ready ( edf_active ) ) { ksched->params.edf.active = edf_active = NULL; } first = kthreadq_get ( &ksched->params.edf.ready ); EDF_LOG ( "%x %x [active, first in queue]", edf_active, first ); if ( !first ) { kthreads_schedule (); return 0; /* no threads in edf.ready queue, edf.active unch. */ } if ( edf_active ) { next = first; first = edf_active; } else { next = kthreadq_get_next ( first ); } while ( first && next ) { sch_first = kthread_get_sched2_param ( first ); sch_next = kthread_get_sched2_param ( next ); if ( time_cmp ( &sch_first->params.edf.active_deadline, &sch_next->params.edf.active_deadline ) > 0 ) { first = next; } next = kthreadq_get_next ( next ); } if ( first && first != edf_active ) { next = kthreadq_remove ( &ksched->params.edf.ready, first ); EDF_LOG ( "%x removed, %x is now first", next, kthreadq_get ( &ksched->params.edf.ready ) ); if ( edf_active ) { EDF_LOG ( "%x=>%x [EDF_SCHED_PREEMPT]", edf_active, first ); /* * change active EDF thread: * -remove it from active/ready list * -put it into edf.ready list */ if ( kthread_is_ready (edf_active) ) { if ( !kthread_is_active (edf_active) ) { kthread_remove_from_ready (edf_active); /* * set "deactivated" flag, don't need * another call to "edf_schedule" */ } else { ea = kthread_get_sched2_param (edf_active); ea->activated = 0; } kthread_enqueue ( edf_active, &ksched->params.edf.ready ); } /* else = thread is blocked - leave it there */ } ksched->params.edf.active = first; EDF_LOG ( "%x [new active]", first ); kthread_move_to_ready ( first, LAST ); } kthreads_schedule (); return 0; }