static void
_timer_call_apply_cyclic( void *ignore, void *vTChdl )
{
#pragma unused(ignore)
wrap_timer_call_t *wrapTC = (wrap_timer_call_t *)vTChdl;
(*(wrapTC->hdlr.cyh_func))( wrapTC->hdlr.cyh_arg );
clock_deadline_for_periodic_event( wrapTC->when.cyt_interval, mach_absolute_time(), &(wrapTC->deadline) );
timer_call_enter1( &(wrapTC->call), (void *)wrapTC, wrapTC->deadline );
/* Did timer_call_remove_cyclic request a wakeup call when this timer call was re-armed? */
if (wrapTC->when.cyt_interval == WAKEUP_REAPER)
thread_wakeup((event_t)wrapTC);
}
static cyclic_id_t
timer_call_add_cyclic(wrap_timer_call_t *wrapTC, cyc_handler_t *handler, cyc_time_t *when)
{
uint64_t now;
timer_call_setup( &(wrapTC->call), _timer_call_apply_cyclic, NULL );
wrapTC->hdlr = *handler;
wrapTC->when = *when;
nanoseconds_to_absolutetime( wrapTC->when.cyt_interval, (uint64_t *)&wrapTC->when.cyt_interval );
now = mach_absolute_time();
wrapTC->deadline = now;
clock_deadline_for_periodic_event( wrapTC->when.cyt_interval, now, &(wrapTC->deadline) );
timer_call_enter1( &(wrapTC->call), (void *)wrapTC, wrapTC->deadline );
return (cyclic_id_t)wrapTC;
}
void
thread_quantum_expire(
timer_call_param_t p0,
timer_call_param_t p1)
{
register processor_t myprocessor = p0;
register thread_t thread = p1;
spl_t s;
s = splsched();
thread_lock(thread);
/*
* Check for fail-safe trip.
*/
if (!(thread->sched_mode & TH_MODE_TIMESHARE)) {
extern uint64_t max_unsafe_computation;
uint64_t new_computation;
new_computation = myprocessor->quantum_end;
new_computation -= thread->computation_epoch;
if (new_computation + thread->computation_metered >
max_unsafe_computation) {
extern uint32_t sched_safe_duration;
if (thread->sched_mode & TH_MODE_REALTIME) {
thread->priority = DEPRESSPRI;
thread->safe_mode |= TH_MODE_REALTIME;
thread->sched_mode &= ~TH_MODE_REALTIME;
}
pset_share_incr(thread->processor_set);
thread->safe_release = sched_tick + sched_safe_duration;
thread->sched_mode |= (TH_MODE_FAILSAFE|TH_MODE_TIMESHARE);
thread->sched_mode &= ~TH_MODE_PREEMPT;
}
}
/*
* Recompute scheduled priority if appropriate.
*/
if (thread->sched_stamp != sched_tick)
update_priority(thread);
else
if (thread->sched_mode & TH_MODE_TIMESHARE) {
thread_timer_delta(thread);
thread->sched_usage += thread->sched_delta;
thread->sched_delta = 0;
/*
* Adjust the scheduled priority if
* the thread has not been promoted
* and is not depressed.
*/
if ( !(thread->sched_mode & TH_MODE_PROMOTED) &&
!(thread->sched_mode & TH_MODE_ISDEPRESSED) )
compute_my_priority(thread);
}
/*
* This quantum is up, give this thread another.
*/
if (first_timeslice(myprocessor))
myprocessor->timeslice--;
thread_quantum_init(thread);
myprocessor->quantum_end += thread->current_quantum;
timer_call_enter1(&myprocessor->quantum_timer,
thread, myprocessor->quantum_end);
thread_unlock(thread);
/*
* Check for and schedule ast if needed.
*/
ast_check(myprocessor);
splx(s);
}
