X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/1c79356b52d46aa6b508fb032f5ae709b1f2897b..HEAD:/osfmk/kern/sched_prim.c?ds=sidebyside diff --git a/osfmk/kern/sched_prim.c b/osfmk/kern/sched_prim.c index ae49e69ca..adcec01c6 100644 --- a/osfmk/kern/sched_prim.c +++ b/osfmk/kern/sched_prim.c @@ -1,49 +1,55 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. - * - * @APPLE_LICENSE_HEADER_START@ - * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. - * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * Copyright (c) 2000-2016 Apple Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. - * - * @APPLE_LICENSE_HEADER_END@ + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * @OSF_FREE_COPYRIGHT@ */ -/* +/* * Mach Operating System * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University * All Rights Reserved. - * + * * Permission to use, copy, modify and distribute this software and its * documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. - * + * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. - * + * * Carnegie Mellon requests users of this software to return to - * + * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 - * + * * any improvements or extensions that they make and grant Carnegie Mellon * the rights to redistribute these changes. */ @@ -59,2620 +65,6917 @@ */ #include -#include -#include -#include -#include -#include -#include +#include #include +#include +#include +#include + #include #include -#include +#include +#include +#include + +#include + +#include +#include #include -#include #include #include -#include -#include +#include +#include #include #include #include +#if MONOTONIC +#include +#endif /* MONOTONIC */ #include #include #include #include +#include #include #include #include -#include +#include +#include +#include +#include +#include + #include #include #include -#include -#include -#include -#include /*** ??? fix so this can be removed ***/ +#include + +#include +#include +#include + #include +#include +#include +#include +#include +#include +#include -#if TASK_SWAPPER -#include -extern int task_swap_on; -#endif /* TASK_SWAPPER */ +struct sched_statistics PERCPU_DATA(sched_stats); +bool sched_stats_active; -extern int hz; +int +rt_runq_count(processor_set_t pset) +{ + return atomic_load_explicit(&SCHED(rt_runq)(pset)->count, memory_order_relaxed); +} -#define DEFAULT_PREEMPTION_RATE 100 /* (1/s) */ -int default_preemption_rate = DEFAULT_PREEMPTION_RATE; +void +rt_runq_count_incr(processor_set_t pset) +{ + atomic_fetch_add_explicit(&SCHED(rt_runq)(pset)->count, 1, memory_order_relaxed); +} -#define NO_KERNEL_PREEMPT 0 -#define KERNEL_PREEMPT 1 -int kernel_preemption_mode = KERNEL_PREEMPT; +void +rt_runq_count_decr(processor_set_t pset) +{ + atomic_fetch_sub_explicit(&SCHED(rt_runq)(pset)->count, 1, memory_order_relaxed); +} -int min_quantum; -natural_t min_quantum_ms; +#define DEFAULT_PREEMPTION_RATE 100 /* (1/s) */ +TUNABLE(int, default_preemption_rate, "preempt", DEFAULT_PREEMPTION_RATE); -unsigned sched_tick; +#define DEFAULT_BG_PREEMPTION_RATE 400 /* (1/s) */ +TUNABLE(int, default_bg_preemption_rate, "bg_preempt", DEFAULT_BG_PREEMPTION_RATE); -#if SIMPLE_CLOCK -int sched_usec; -#endif /* SIMPLE_CLOCK */ +#define MAX_UNSAFE_QUANTA 800 +TUNABLE(int, max_unsafe_quanta, "unsafe", MAX_UNSAFE_QUANTA); -/* Forwards */ -void thread_continue(thread_t); +#define MAX_POLL_QUANTA 2 +TUNABLE(int, max_poll_quanta, "poll", MAX_POLL_QUANTA); -void wait_queues_init(void); +#define SCHED_POLL_YIELD_SHIFT 4 /* 1/16 */ +int sched_poll_yield_shift = SCHED_POLL_YIELD_SHIFT; -void set_pri( - thread_t thread, - int pri, - int resched); +uint64_t max_poll_computation; -thread_t choose_pset_thread( - processor_t myprocessor, - processor_set_t pset); +uint64_t max_unsafe_computation; +uint64_t sched_safe_duration; -thread_t choose_thread( - processor_t myprocessor); +#if defined(CONFIG_SCHED_TIMESHARE_CORE) -int run_queue_enqueue( - run_queue_t runq, - thread_t thread, - boolean_t tail); +uint32_t std_quantum; +uint32_t min_std_quantum; +uint32_t bg_quantum; -void idle_thread_continue(void); -void do_thread_scan(void); +uint32_t std_quantum_us; +uint32_t bg_quantum_us; -void clear_wait_internal( - thread_t thread, - int result); +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ -#if DEBUG -void dump_run_queues( - run_queue_t rq); -void dump_run_queue_struct( - run_queue_t rq); -void dump_processor( - processor_t p); -void dump_processor_set( - processor_set_t ps); +uint32_t thread_depress_time; +uint32_t default_timeshare_computation; +uint32_t default_timeshare_constraint; -void checkrq( - run_queue_t rq, - char *msg); +uint32_t max_rt_quantum; +uint32_t min_rt_quantum; -void thread_check( - thread_t thread, - run_queue_t runq); -#endif /*DEBUG*/ +uint32_t rt_constraint_threshold; -boolean_t thread_runnable( - thread_t thread); +#if defined(CONFIG_SCHED_TIMESHARE_CORE) -/* - * State machine - * - * states are combinations of: - * R running - * W waiting (or on wait queue) - * N non-interruptible - * O swapped out - * I being swapped in - * - * init action - * assert_wait thread_block clear_wait swapout swapin - * - * R RW, RWN R; setrun - - - * RN RWN RN; setrun - - - * - * RW W R - - * RWN WN RN - - * - * W R; setrun WO - * WN RN; setrun - - * - * RO - - R - * - */ +unsigned sched_tick; +uint32_t sched_tick_interval; -/* - * Waiting protocols and implementation: - * - * Each thread may be waiting for exactly one event; this event - * is set using assert_wait(). That thread may be awakened either - * by performing a thread_wakeup_prim() on its event, - * or by directly waking that thread up with clear_wait(). - * - * The implementation of wait events uses a hash table. Each - * bucket is queue of threads having the same hash function - * value; the chain for the queue (linked list) is the run queue - * field. [It is not possible to be waiting and runnable at the - * same time.] - * - * Locks on both the thread and on the hash buckets govern the - * wait event field and the queue chain field. Because wakeup - * operations only have the event as an argument, the event hash - * bucket must be locked before any thread. - * - * Scheduling operations may also occur at interrupt level; therefore, - * interrupts below splsched() must be prevented when holding - * thread or hash bucket locks. - * - * The wait event hash table declarations are as follows: - */ +/* Timeshare load calculation interval (15ms) */ +uint32_t sched_load_compute_interval_us = 15000; +uint64_t sched_load_compute_interval_abs; +static _Atomic uint64_t sched_load_compute_deadline; -#define NUMQUEUES 59 +uint32_t sched_pri_shifts[TH_BUCKET_MAX]; +uint32_t sched_fixed_shift; -struct wait_queue wait_queues[NUMQUEUES]; +uint32_t sched_decay_usage_age_factor = 1; /* accelerate 5/8^n usage aging */ -#define wait_hash(event) \ - ((((int)(event) < 0)? ~(int)(event): (int)(event)) % NUMQUEUES) +/* Allow foreground to decay past default to resolve inversions */ +#define DEFAULT_DECAY_BAND_LIMIT ((BASEPRI_FOREGROUND - BASEPRI_DEFAULT) + 2) +int sched_pri_decay_band_limit = DEFAULT_DECAY_BAND_LIMIT; -void -sched_init(void) -{ - /* - * Calculate the minimum quantum - * in ticks. - */ - if (default_preemption_rate < 1) - default_preemption_rate = DEFAULT_PREEMPTION_RATE; - min_quantum = hz / default_preemption_rate; +/* Defaults for timer deadline profiling */ +#define TIMER_DEADLINE_TRACKING_BIN_1_DEFAULT 2000000 /* Timers with deadlines <= + * 2ms */ +#define TIMER_DEADLINE_TRACKING_BIN_2_DEFAULT 5000000 /* Timers with deadlines + * <= 5ms */ - /* - * Round up result (4/5) to an - * integral number of ticks. - */ - if (((hz * 10) / default_preemption_rate) - (min_quantum * 10) >= 5) - min_quantum++; - if (min_quantum < 1) - min_quantum = 1; +uint64_t timer_deadline_tracking_bin_1; +uint64_t timer_deadline_tracking_bin_2; - min_quantum_ms = (1000 / hz) * min_quantum; +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ - printf("scheduling quantum is %d ms\n", min_quantum_ms); +thread_t sched_maintenance_thread; - wait_queues_init(); - pset_sys_bootstrap(); /* initialize processor mgmt. */ - processor_action(); - sched_tick = 0; -#if SIMPLE_CLOCK - sched_usec = 0; -#endif /* SIMPLE_CLOCK */ - ast_init(); - sf_init(); -} +/* interrupts disabled lock to guard recommended cores state */ +decl_simple_lock_data(static, sched_recommended_cores_lock); +static uint64_t usercontrol_requested_recommended_cores = ALL_CORES_RECOMMENDED; +static void sched_update_recommended_cores(uint64_t recommended_cores); -void -wait_queues_init(void) -{ - register int i; +#if __arm__ || __arm64__ +static void sched_recommended_cores_maintenance(void); +uint64_t perfcontrol_failsafe_starvation_threshold; +extern char *proc_name_address(struct proc *p); +#endif /* __arm__ || __arm64__ */ - for (i = 0; i < NUMQUEUES; i++) { - wait_queue_init(&wait_queues[i], SYNC_POLICY_FIFO); - } -} +uint64_t sched_one_second_interval; +boolean_t allow_direct_handoff = TRUE; -/* - * Thread timeout routine, called when timer expires. - */ -void -thread_timer_expire( - timer_call_param_t p0, - timer_call_param_t p1) -{ - thread_t thread = p0; - spl_t s; +/* Forwards */ - s = splsched(); - wake_lock(thread); - if ( thread->wait_timer_is_set && - !timer_call_is_delayed(&thread->wait_timer, NULL) ) { - thread->wait_timer_active--; - thread->wait_timer_is_set = FALSE; - thread_lock(thread); - if (thread->active) - clear_wait_internal(thread, THREAD_TIMED_OUT); - thread_unlock(thread); - } - else - if (--thread->wait_timer_active == 0) - thread_wakeup_one(&thread->wait_timer_active); - wake_unlock(thread); - splx(s); -} +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + +static void load_shift_init(void); +static void preempt_pri_init(void); + +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + +thread_t processor_idle( + thread_t thread, + processor_t processor); + +static ast_t +csw_check_locked( + thread_t thread, + processor_t processor, + processor_set_t pset, + ast_t check_reason); + +static void processor_setrun( + processor_t processor, + thread_t thread, + integer_t options); + +static void +sched_realtime_timebase_init(void); + +static void +sched_timer_deadline_tracking_init(void); + +#if DEBUG +extern int debug_task; +#define TLOG(a, fmt, args...) if(debug_task & a) kprintf(fmt, ## args) +#else +#define TLOG(a, fmt, args...) do {} while (0) +#endif + +static processor_t +thread_bind_internal( + thread_t thread, + processor_t processor); + +static void +sched_vm_group_maintenance(void); + +#if defined(CONFIG_SCHED_TIMESHARE_CORE) +int8_t sched_load_shifts[NRQS]; +bitmap_t sched_preempt_pri[BITMAP_LEN(NRQS_MAX)]; +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ /* - * thread_set_timer: + * Statically allocate a buffer to hold the longest possible + * scheduler description string, as currently implemented. + * bsd/kern/kern_sysctl.c has a corresponding definition in bsd/ + * to export to userspace via sysctl(3). If either version + * changes, update the other. * - * Set a timer for the current thread, if the thread - * is ready to wait. Must be called between assert_wait() - * and thread_block(). + * Note that in addition to being an upper bound on the strings + * in the kernel, it's also an exact parameter to PE_get_default(), + * which interrogates the device tree on some platforms. That + * API requires the caller know the exact size of the device tree + * property, so we need both a legacy size (32) and the current size + * (48) to deal with old and new device trees. The device tree property + * is similarly padded to a fixed size so that the same kernel image + * can run on multiple devices with different schedulers configured + * in the device tree. */ -void -thread_set_timer( - natural_t interval, - natural_t scale_factor) -{ - thread_t thread = current_thread(); - AbsoluteTime deadline; - spl_t s; +char sched_string[SCHED_STRING_MAX_LENGTH]; - s = splsched(); - wake_lock(thread); - thread_lock(thread); - if ((thread->state & TH_WAIT) != 0) { - clock_interval_to_deadline(interval, scale_factor, &deadline); - timer_call_enter(&thread->wait_timer, deadline); - assert(!thread->wait_timer_is_set); - thread->wait_timer_active++; - thread->wait_timer_is_set = TRUE; - } - thread_unlock(thread); - wake_unlock(thread); - splx(s); -} +uint32_t sched_debug_flags = SCHED_DEBUG_FLAG_CHOOSE_PROCESSOR_TRACEPOINTS; + +/* Global flag which indicates whether Background Stepper Context is enabled */ +static int cpu_throttle_enabled = 1; void -thread_set_timer_deadline( - AbsoluteTime deadline) +sched_init(void) { - thread_t thread = current_thread(); - spl_t s; - - s = splsched(); - wake_lock(thread); - thread_lock(thread); - if ((thread->state & TH_WAIT) != 0) { - timer_call_enter(&thread->wait_timer, deadline); - assert(!thread->wait_timer_is_set); - thread->wait_timer_active++; - thread->wait_timer_is_set = TRUE; + boolean_t direct_handoff = FALSE; + kprintf("Scheduler: Default of %s\n", SCHED(sched_name)); + + if (!PE_parse_boot_argn("sched_pri_decay_limit", &sched_pri_decay_band_limit, sizeof(sched_pri_decay_band_limit))) { + /* No boot-args, check in device tree */ + if (!PE_get_default("kern.sched_pri_decay_limit", + &sched_pri_decay_band_limit, + sizeof(sched_pri_decay_band_limit))) { + /* Allow decay all the way to normal limits */ + sched_pri_decay_band_limit = DEFAULT_DECAY_BAND_LIMIT; + } } - thread_unlock(thread); - wake_unlock(thread); - splx(s); -} -void -thread_cancel_timer(void) -{ - thread_t thread = current_thread(); - spl_t s; + kprintf("Setting scheduler priority decay band limit %d\n", sched_pri_decay_band_limit); - s = splsched(); - wake_lock(thread); - if (thread->wait_timer_is_set) { - if (timer_call_cancel(&thread->wait_timer)) - thread->wait_timer_active--; - thread->wait_timer_is_set = FALSE; + if (PE_parse_boot_argn("sched_debug", &sched_debug_flags, sizeof(sched_debug_flags))) { + kprintf("Scheduler: Debug flags 0x%08x\n", sched_debug_flags); } - wake_unlock(thread); - splx(s); -} + strlcpy(sched_string, SCHED(sched_name), sizeof(sched_string)); -/* - * thread_depress_timeout: - * - * Timeout routine for priority depression. - */ -void -thread_depress_timeout( - thread_call_param_t p0, - thread_call_param_t p1) -{ - thread_t thread = p0; - sched_policy_t *policy; - spl_t s; + cpu_quiescent_counter_init(); - s = splsched(); - thread_lock(thread); - policy = policy_id_to_sched_policy(thread->policy); - thread_unlock(thread); - splx(s); + SCHED(init)(); + SCHED(rt_init)(&pset0); + sched_timer_deadline_tracking_init(); - if (policy != SCHED_POLICY_NULL) - policy->sp_ops.sp_thread_depress_timeout(policy, thread); + SCHED(pset_init)(&pset0); + SCHED(processor_init)(master_processor); - thread_deallocate(thread); + if (PE_parse_boot_argn("direct_handoff", &direct_handoff, sizeof(direct_handoff))) { + allow_direct_handoff = direct_handoff; + } } -/* - * Set up thread timeout element when thread is created. - */ void -thread_timer_setup( - thread_t thread) +sched_timebase_init(void) { - timer_call_setup(&thread->wait_timer, thread_timer_expire, thread); - thread->wait_timer_is_set = FALSE; - thread->wait_timer_active = 1; - thread->ref_count++; + uint64_t abstime; - thread_call_setup(&thread->depress_timer, thread_depress_timeout, thread); + clock_interval_to_absolutetime_interval(1, NSEC_PER_SEC, &abstime); + sched_one_second_interval = abstime; + + SCHED(timebase_init)(); + sched_realtime_timebase_init(); } +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + void -thread_timer_terminate(void) +sched_timeshare_init(void) { - thread_t thread = current_thread(); - spl_t s; - - s = splsched(); - wake_lock(thread); - if (thread->wait_timer_is_set) { - if (timer_call_cancel(&thread->wait_timer)) - thread->wait_timer_active--; - thread->wait_timer_is_set = FALSE; + /* + * Calculate the timeslicing quantum + * in us. + */ + if (default_preemption_rate < 1) { + default_preemption_rate = DEFAULT_PREEMPTION_RATE; } + std_quantum_us = (1000 * 1000) / default_preemption_rate; - thread->wait_timer_active--; - - while (thread->wait_timer_active > 0) { - assert_wait((event_t)&thread->wait_timer_active, THREAD_UNINT); - wake_unlock(thread); - splx(s); - - thread_block((void (*)(void)) 0); + printf("standard timeslicing quantum is %d us\n", std_quantum_us); - s = splsched(); - wake_lock(thread); + if (default_bg_preemption_rate < 1) { + default_bg_preemption_rate = DEFAULT_BG_PREEMPTION_RATE; } + bg_quantum_us = (1000 * 1000) / default_bg_preemption_rate; - wake_unlock(thread); - splx(s); + printf("standard background quantum is %d us\n", bg_quantum_us); - thread_deallocate(thread); + load_shift_init(); + preempt_pri_init(); + sched_tick = 0; } -/* - * Routine: thread_go_locked - * Purpose: - * Start a thread running. - * Conditions: - * thread lock held, IPC locks may be held. - * thread must have been pulled from wait queue under same lock hold. - */ void -thread_go_locked( - thread_t thread, - int result) +sched_timeshare_timebase_init(void) { - int state; - sched_policy_t *policy; - sf_return_t sfr; - - assert(thread->at_safe_point == FALSE); - assert(thread->wait_event == NO_EVENT); - assert(thread->wait_queue == WAIT_QUEUE_NULL); - - if (thread->state & TH_WAIT) { + uint64_t abstime; + uint32_t shift; + + /* standard timeslicing quantum */ + clock_interval_to_absolutetime_interval( + std_quantum_us, NSEC_PER_USEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + std_quantum = (uint32_t)abstime; + + /* smallest remaining quantum (250 us) */ + clock_interval_to_absolutetime_interval(250, NSEC_PER_USEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + min_std_quantum = (uint32_t)abstime; + + /* quantum for background tasks */ + clock_interval_to_absolutetime_interval( + bg_quantum_us, NSEC_PER_USEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + bg_quantum = (uint32_t)abstime; + + /* scheduler tick interval */ + clock_interval_to_absolutetime_interval(USEC_PER_SEC >> SCHED_TICK_SHIFT, + NSEC_PER_USEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + sched_tick_interval = (uint32_t)abstime; + + /* timeshare load calculation interval & deadline initialization */ + clock_interval_to_absolutetime_interval(sched_load_compute_interval_us, NSEC_PER_USEC, &sched_load_compute_interval_abs); + os_atomic_init(&sched_load_compute_deadline, sched_load_compute_interval_abs); - thread->state &= ~(TH_WAIT|TH_UNINT); - if (!(thread->state & TH_RUN)) { - thread->state |= TH_RUN; -#if THREAD_SWAPPER - if (thread->state & TH_SWAPPED_OUT) - thread_swapin(thread->top_act, FALSE); - else -#endif /* THREAD_SWAPPER */ - { - policy = &sched_policy[thread->policy]; - sfr = policy->sp_ops.sp_thread_unblock(policy, thread); - assert(sfr == SF_SUCCESS); - } - } - thread->wait_result = result; + /* + * Compute conversion factor from usage to + * timesharing priorities with 5/8 ** n aging. + */ + abstime = (abstime * 5) / 3; + for (shift = 0; abstime > BASEPRI_DEFAULT; ++shift) { + abstime >>= 1; } + sched_fixed_shift = shift; - - /* - * The next few lines are a major hack. Hopefully this will get us - * around all of the scheduling framework hooha. We can't call - * sp_thread_unblock yet because we could still be finishing up the - * durn two stage block on another processor and thread_setrun - * could be called by s_t_u and we'll really be messed up then. - */ - /* Don't mess with this if we are still swapped out */ - if (!(thread->state & TH_SWAPPED_OUT)) - thread->sp_state = MK_SP_RUNNABLE; - -} + for (uint32_t i = 0; i < TH_BUCKET_MAX; i++) { + sched_pri_shifts[i] = INT8_MAX; + } -void -thread_mark_wait_locked( - thread_t thread, - int interruptible) -{ + max_unsafe_computation = ((uint64_t)max_unsafe_quanta) * std_quantum; + sched_safe_duration = 2 * ((uint64_t)max_unsafe_quanta) * std_quantum; - assert(thread == current_thread()); + max_poll_computation = ((uint64_t)max_poll_quanta) * std_quantum; + thread_depress_time = 1 * std_quantum; + default_timeshare_computation = std_quantum / 2; + default_timeshare_constraint = std_quantum; - thread->wait_result = -1; /* JMM - Needed for non-assert kernel */ - thread->state |= (interruptible && thread->interruptible) ? - TH_WAIT : (TH_WAIT | TH_UNINT); - thread->at_safe_point = (interruptible == THREAD_ABORTSAFE) && (thread->interruptible); - thread->sleep_stamp = sched_tick; +#if __arm__ || __arm64__ + perfcontrol_failsafe_starvation_threshold = (2 * sched_tick_interval); +#endif /* __arm__ || __arm64__ */ } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ +void +pset_rt_init(processor_set_t pset) +{ + os_atomic_init(&pset->rt_runq.count, 0); + queue_init(&pset->rt_runq.queue); + memset(&pset->rt_runq.runq_stats, 0, sizeof pset->rt_runq.runq_stats); +} -/* - * Routine: assert_wait_timeout - * Purpose: - * Assert that the thread intends to block, - * waiting for a timeout (no user known event). - */ -unsigned int assert_wait_timeout_event; +static void +sched_realtime_timebase_init(void) +{ + uint64_t abstime; + + /* smallest rt computaton (50 us) */ + clock_interval_to_absolutetime_interval(50, NSEC_PER_USEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + min_rt_quantum = (uint32_t)abstime; + + /* maximum rt computation (50 ms) */ + clock_interval_to_absolutetime_interval( + 50, 1000 * NSEC_PER_USEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + max_rt_quantum = (uint32_t)abstime; + + /* constraint threshold for sending backup IPIs (4 ms) */ + clock_interval_to_absolutetime_interval(4, NSEC_PER_MSEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + rt_constraint_threshold = (uint32_t)abstime; +} void -assert_wait_timeout( - mach_msg_timeout_t msecs, - int interruptible) +sched_check_spill(processor_set_t pset, thread_t thread) { - spl_t s; + (void)pset; + (void)thread; - assert_wait((event_t)&assert_wait_timeout_event, interruptible); - thread_set_timer(msecs, 1000*NSEC_PER_USEC); + return; } -/* - * Check to see if an assert wait is possible, without actually doing one. - * This is used by debug code in locks and elsewhere to verify that it is - * always OK to block when trying to take a blocking lock (since waiting - * for the actual assert_wait to catch the case may make it hard to detect - * this case. - */ -boolean_t -assert_wait_possible(void) +bool +sched_thread_should_yield(processor_t processor, thread_t thread) { + (void)thread; - thread_t thread; - extern unsigned int debug_mode; + return !SCHED(processor_queue_empty)(processor) || rt_runq_count(processor->processor_set) > 0; +} -#if DEBUG - if(debug_mode) return TRUE; /* Always succeed in debug mode */ -#endif - - thread = current_thread(); +/* Default implementations of .steal_thread_enabled */ +bool +sched_steal_thread_DISABLED(processor_set_t pset) +{ + (void)pset; + return false; +} - return (thread == NULL || wait_queue_assert_possible(thread)); +bool +sched_steal_thread_enabled(processor_set_t pset) +{ + return bit_count(pset->node->pset_map) > 1; } +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + /* - * assert_wait: - * - * Assert that the current thread is about to go to - * sleep until the specified event occurs. + * Set up values for timeshare + * loading factors. */ -void -assert_wait( - event_t event, - int interruptible) +static void +load_shift_init(void) { - register wait_queue_t wq; - register int index; + int8_t k, *p = sched_load_shifts; + uint32_t i, j; - assert(event != NO_EVENT); - assert(assert_wait_possible()); + uint32_t sched_decay_penalty = 1; - index = wait_hash(event); - wq = &wait_queues[index]; - wait_queue_assert_wait(wq, - event, - interruptible); -} + if (PE_parse_boot_argn("sched_decay_penalty", &sched_decay_penalty, sizeof(sched_decay_penalty))) { + kprintf("Overriding scheduler decay penalty %u\n", sched_decay_penalty); + } - -/* - * thread_[un]stop(thread) - * Once a thread has blocked interruptibly (via assert_wait) prevent - * it from running until thread_unstop. - * - * If someone else has already stopped the thread, wait for the - * stop to be cleared, and then stop it again. - * - * Return FALSE if interrupted. - * - * NOTE: thread_hold/thread_suspend should be called on the activation - * before calling thread_stop. TH_SUSP is only recognized when - * a thread blocks and only prevents clear_wait/thread_wakeup - * from restarting an interruptible wait. The wake_active flag is - * used to indicate that someone is waiting on the thread. - */ -boolean_t -thread_stop( - thread_t thread) -{ - spl_t s; + if (PE_parse_boot_argn("sched_decay_usage_age_factor", &sched_decay_usage_age_factor, sizeof(sched_decay_usage_age_factor))) { + kprintf("Overriding scheduler decay usage age factor %u\n", sched_decay_usage_age_factor); + } - s = splsched(); - wake_lock(thread); + if (sched_decay_penalty == 0) { + /* + * There is no penalty for timeshare threads for using too much + * CPU, so set all load shifts to INT8_MIN. Even under high load, + * sched_pri_shift will be >INT8_MAX, and there will be no + * penalty applied to threads (nor will sched_usage be updated per + * thread). + */ + for (i = 0; i < NRQS; i++) { + sched_load_shifts[i] = INT8_MIN; + } - while (thread->state & TH_SUSP) { - thread->wake_active = TRUE; - assert_wait((event_t)&thread->wake_active, THREAD_ABORTSAFE); - wake_unlock(thread); - splx(s); + return; + } - thread_block((void (*)(void)) 0); - if (current_thread()->wait_result != THREAD_AWAKENED) - return (FALSE); + *p++ = INT8_MIN; *p++ = 0; - s = splsched(); - wake_lock(thread); + /* + * For a given system load "i", the per-thread priority + * penalty per quantum of CPU usage is ~2^k priority + * levels. "sched_decay_penalty" can cause more + * array entries to be filled with smaller "k" values + */ + for (i = 2, j = 1 << sched_decay_penalty, k = 1; i < NRQS; ++k) { + for (j <<= 1; (i < j) && (i < NRQS); ++i) { + *p++ = k; + } } - thread_lock(thread); - thread->state |= TH_SUSP; - thread_unlock(thread); +} - wake_unlock(thread); - splx(s); +static void +preempt_pri_init(void) +{ + bitmap_t *p = sched_preempt_pri; + + for (int i = BASEPRI_FOREGROUND; i < MINPRI_KERNEL; ++i) { + bitmap_set(p, i); + } - return (TRUE); + for (int i = BASEPRI_PREEMPT; i <= MAXPRI; ++i) { + bitmap_set(p, i); + } } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + /* - * Clear TH_SUSP and if the thread has been stopped and is now runnable, - * put it back on the run queue. + * Thread wait timer expiration. */ void -thread_unstop( - thread_t thread) +thread_timer_expire( + void *p0, + __unused void *p1) { - sched_policy_t *policy; - sf_return_t sfr; - spl_t s; + thread_t thread = p0; + spl_t s; + + assert_thread_magic(thread); s = splsched(); - wake_lock(thread); thread_lock(thread); - - if ((thread->state & (TH_RUN|TH_WAIT|TH_SUSP/*|TH_UNINT*/)) == TH_SUSP) { - thread->state = (thread->state & ~TH_SUSP) | TH_RUN; -#if THREAD_SWAPPER - if (thread->state & TH_SWAPPED_OUT) - thread_swapin(thread->top_act, FALSE); - else -#endif /* THREAD_SWAPPER */ - { - policy = &sched_policy[thread->policy]; - sfr = policy->sp_ops.sp_thread_unblock(policy, thread); - assert(sfr == SF_SUCCESS); - } - } - else - if (thread->state & TH_SUSP) { - thread->state &= ~TH_SUSP; - - if (thread->wake_active) { - thread->wake_active = FALSE; - thread_unlock(thread); - wake_unlock(thread); - splx(s); - thread_wakeup((event_t)&thread->wake_active); - - return; + if (--thread->wait_timer_active == 0) { + if (thread->wait_timer_is_set) { + thread->wait_timer_is_set = FALSE; + clear_wait_internal(thread, THREAD_TIMED_OUT); } } - thread_unlock(thread); - wake_unlock(thread); splx(s); } /* - * Wait for the thread's RUN bit to clear - */ -boolean_t + * thread_unblock: + * + * Unblock thread on wake up. + * + * Returns TRUE if the thread should now be placed on the runqueue. + * + * Thread must be locked. + * + * Called at splsched(). + */ +boolean_t +thread_unblock( + thread_t thread, + wait_result_t wresult) +{ + boolean_t ready_for_runq = FALSE; + thread_t cthread = current_thread(); + uint32_t new_run_count; + int old_thread_state; + + /* + * Set wait_result. + */ + thread->wait_result = wresult; + + /* + * Cancel pending wait timer. + */ + if (thread->wait_timer_is_set) { + if (timer_call_cancel(&thread->wait_timer)) { + thread->wait_timer_active--; + } + thread->wait_timer_is_set = FALSE; + } + + boolean_t aticontext, pidle; + ml_get_power_state(&aticontext, &pidle); + + /* + * Update scheduling state: not waiting, + * set running. + */ + old_thread_state = thread->state; + thread->state = (old_thread_state | TH_RUN) & + ~(TH_WAIT | TH_UNINT | TH_WAIT_REPORT); + + if ((old_thread_state & TH_RUN) == 0) { + uint64_t ctime = mach_approximate_time(); + thread->last_made_runnable_time = thread->last_basepri_change_time = ctime; + timer_start(&thread->runnable_timer, ctime); + + ready_for_runq = TRUE; + + if (old_thread_state & TH_WAIT_REPORT) { + (*thread->sched_call)(SCHED_CALL_UNBLOCK, thread); + } + + /* Update the runnable thread count */ + new_run_count = SCHED(run_count_incr)(thread); + +#if CONFIG_SCHED_AUTO_JOIN + if (aticontext == FALSE && work_interval_should_propagate(cthread, thread)) { + work_interval_auto_join_propagate(cthread, thread); + } +#endif /*CONFIG_SCHED_AUTO_JOIN */ + } else { + /* + * Either the thread is idling in place on another processor, + * or it hasn't finished context switching yet. + */ + assert((thread->state & TH_IDLE) == 0); + /* + * The run count is only dropped after the context switch completes + * and the thread is still waiting, so we should not run_incr here + */ + new_run_count = os_atomic_load(&sched_run_buckets[TH_BUCKET_RUN], relaxed); + } + + /* + * Calculate deadline for real-time threads. + */ + if (thread->sched_mode == TH_MODE_REALTIME) { + uint64_t ctime; + + ctime = mach_absolute_time(); + thread->realtime.deadline = thread->realtime.constraint + ctime; + KDBG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SET_RT_DEADLINE) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), thread->realtime.deadline, thread->realtime.computation, 0); + } + + /* + * Clear old quantum, fail-safe computation, etc. + */ + thread->quantum_remaining = 0; + thread->computation_metered = 0; + thread->reason = AST_NONE; + thread->block_hint = kThreadWaitNone; + + /* Obtain power-relevant interrupt and "platform-idle exit" statistics. + * We also account for "double hop" thread signaling via + * the thread callout infrastructure. + * DRK: consider removing the callout wakeup counters in the future + * they're present for verification at the moment. + */ + + if (__improbable(aticontext && !(thread_get_tag_internal(thread) & THREAD_TAG_CALLOUT))) { + DTRACE_SCHED2(iwakeup, struct thread *, thread, struct proc *, thread->task->bsd_info); + + uint64_t ttd = current_processor()->timer_call_ttd; + + if (ttd) { + if (ttd <= timer_deadline_tracking_bin_1) { + thread->thread_timer_wakeups_bin_1++; + } else if (ttd <= timer_deadline_tracking_bin_2) { + thread->thread_timer_wakeups_bin_2++; + } + } + + ledger_credit_thread(thread, thread->t_ledger, + task_ledgers.interrupt_wakeups, 1); + if (pidle) { + ledger_credit_thread(thread, thread->t_ledger, + task_ledgers.platform_idle_wakeups, 1); + } + } else if (thread_get_tag_internal(cthread) & THREAD_TAG_CALLOUT) { + /* TODO: what about an interrupt that does a wake taken on a callout thread? */ + if (cthread->callout_woken_from_icontext) { + ledger_credit_thread(thread, thread->t_ledger, + task_ledgers.interrupt_wakeups, 1); + thread->thread_callout_interrupt_wakeups++; + + if (cthread->callout_woken_from_platform_idle) { + ledger_credit_thread(thread, thread->t_ledger, + task_ledgers.platform_idle_wakeups, 1); + thread->thread_callout_platform_idle_wakeups++; + } + + cthread->callout_woke_thread = TRUE; + } + } + + if (thread_get_tag_internal(thread) & THREAD_TAG_CALLOUT) { + thread->callout_woken_from_icontext = !!aticontext; + thread->callout_woken_from_platform_idle = !!pidle; + thread->callout_woke_thread = FALSE; + } + +#if KPERF + if (ready_for_runq) { + kperf_make_runnable(thread, aticontext); + } +#endif /* KPERF */ + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_MAKE_RUNNABLE) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), thread->sched_pri, thread->wait_result, + sched_run_buckets[TH_BUCKET_RUN], 0); + + DTRACE_SCHED2(wakeup, struct thread *, thread, struct proc *, thread->task->bsd_info); + + return ready_for_runq; +} + +/* + * Routine: thread_allowed_for_handoff + * Purpose: + * Check if the thread is allowed for handoff operation + * Conditions: + * thread lock held, IPC locks may be held. + * TODO: In future, do not allow handoff if threads have different cluster + * recommendations. + */ +boolean_t +thread_allowed_for_handoff( + thread_t thread) +{ + thread_t self = current_thread(); + + if (allow_direct_handoff && + thread->sched_mode == TH_MODE_REALTIME && + self->sched_mode == TH_MODE_REALTIME) { + return TRUE; + } + + return FALSE; +} + +/* + * Routine: thread_go + * Purpose: + * Unblock and dispatch thread. + * Conditions: + * thread lock held, IPC locks may be held. + * thread must have been pulled from wait queue under same lock hold. + * thread must have been waiting + * Returns: + * KERN_SUCCESS - Thread was set running + * + * TODO: This should return void + */ +kern_return_t +thread_go( + thread_t thread, + wait_result_t wresult, + waitq_options_t option) +{ + thread_t self = current_thread(); + + assert_thread_magic(thread); + + assert(thread->at_safe_point == FALSE); + assert(thread->wait_event == NO_EVENT64); + assert(thread->waitq == NULL); + + assert(!(thread->state & (TH_TERMINATE | TH_TERMINATE2))); + assert(thread->state & TH_WAIT); + + + if (thread_unblock(thread, wresult)) { +#if SCHED_TRACE_THREAD_WAKEUPS + backtrace(&thread->thread_wakeup_bt[0], + (sizeof(thread->thread_wakeup_bt) / sizeof(uintptr_t)), NULL); +#endif + if ((option & WQ_OPTION_HANDOFF) && + thread_allowed_for_handoff(thread)) { + thread_reference(thread); + assert(self->handoff_thread == NULL); + self->handoff_thread = thread; + } else { + thread_setrun(thread, SCHED_PREEMPT | SCHED_TAILQ); + } + } + + return KERN_SUCCESS; +} + +/* + * Routine: thread_mark_wait_locked + * Purpose: + * Mark a thread as waiting. If, given the circumstances, + * it doesn't want to wait (i.e. already aborted), then + * indicate that in the return value. + * Conditions: + * at splsched() and thread is locked. + */ +__private_extern__ +wait_result_t +thread_mark_wait_locked( + thread_t thread, + wait_interrupt_t interruptible_orig) +{ + boolean_t at_safe_point; + wait_interrupt_t interruptible = interruptible_orig; + + if (thread->state & TH_IDLE) { + panic("Invalid attempt to wait while running the idle thread"); + } + + assert(!(thread->state & (TH_WAIT | TH_IDLE | TH_UNINT | TH_TERMINATE2 | TH_WAIT_REPORT))); + + /* + * The thread may have certain types of interrupts/aborts masked + * off. Even if the wait location says these types of interrupts + * are OK, we have to honor mask settings (outer-scoped code may + * not be able to handle aborts at the moment). + */ + interruptible &= TH_OPT_INTMASK; + if (interruptible > (thread->options & TH_OPT_INTMASK)) { + interruptible = thread->options & TH_OPT_INTMASK; + } + + at_safe_point = (interruptible == THREAD_ABORTSAFE); + + if (interruptible == THREAD_UNINT || + !(thread->sched_flags & TH_SFLAG_ABORT) || + (!at_safe_point && + (thread->sched_flags & TH_SFLAG_ABORTSAFELY))) { + if (!(thread->state & TH_TERMINATE)) { + DTRACE_SCHED(sleep); + } + + int state_bits = TH_WAIT; + if (!interruptible) { + state_bits |= TH_UNINT; + } + if (thread->sched_call) { + wait_interrupt_t mask = THREAD_WAIT_NOREPORT_USER; + if (is_kerneltask(thread->task)) { + mask = THREAD_WAIT_NOREPORT_KERNEL; + } + if ((interruptible_orig & mask) == 0) { + state_bits |= TH_WAIT_REPORT; + } + } + thread->state |= state_bits; + thread->at_safe_point = at_safe_point; + + /* TODO: pass this through assert_wait instead, have + * assert_wait just take a struct as an argument */ + assert(!thread->block_hint); + thread->block_hint = thread->pending_block_hint; + thread->pending_block_hint = kThreadWaitNone; + + return thread->wait_result = THREAD_WAITING; + } else { + if (thread->sched_flags & TH_SFLAG_ABORTSAFELY) { + thread->sched_flags &= ~TH_SFLAG_ABORTED_MASK; + } + } + thread->pending_block_hint = kThreadWaitNone; + + return thread->wait_result = THREAD_INTERRUPTED; +} + +/* + * Routine: thread_interrupt_level + * Purpose: + * Set the maximum interruptible state for the + * current thread. The effective value of any + * interruptible flag passed into assert_wait + * will never exceed this. + * + * Useful for code that must not be interrupted, + * but which calls code that doesn't know that. + * Returns: + * The old interrupt level for the thread. + */ +__private_extern__ +wait_interrupt_t +thread_interrupt_level( + wait_interrupt_t new_level) +{ + thread_t thread = current_thread(); + wait_interrupt_t result = thread->options & TH_OPT_INTMASK; + + thread->options = (thread->options & ~TH_OPT_INTMASK) | (new_level & TH_OPT_INTMASK); + + return result; +} + +/* + * assert_wait: + * + * Assert that the current thread is about to go to + * sleep until the specified event occurs. + */ +wait_result_t +assert_wait( + event_t event, + wait_interrupt_t interruptible) +{ + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT) | DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE_OR_PERM(event), 0, 0, 0, 0); + + struct waitq *waitq; + waitq = global_eventq(event); + return waitq_assert_wait64(waitq, CAST_EVENT64_T(event), interruptible, TIMEOUT_WAIT_FOREVER); +} + +/* + * assert_wait_queue: + * + * Return the global waitq for the specified event + */ +struct waitq * +assert_wait_queue( + event_t event) +{ + return global_eventq(event); +} + +wait_result_t +assert_wait_timeout( + event_t event, + wait_interrupt_t interruptible, + uint32_t interval, + uint32_t scale_factor) +{ + thread_t thread = current_thread(); + wait_result_t wresult; + uint64_t deadline; + spl_t s; + + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + struct waitq *waitq; + waitq = global_eventq(event); + + s = splsched(); + waitq_lock(waitq); + + clock_interval_to_deadline(interval, scale_factor, &deadline); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT) | DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE_OR_PERM(event), interruptible, deadline, 0, 0); + + wresult = waitq_assert_wait64_locked(waitq, CAST_EVENT64_T(event), + interruptible, + TIMEOUT_URGENCY_SYS_NORMAL, + deadline, TIMEOUT_NO_LEEWAY, + thread); + + waitq_unlock(waitq); + splx(s); + return wresult; +} + +wait_result_t +assert_wait_timeout_with_leeway( + event_t event, + wait_interrupt_t interruptible, + wait_timeout_urgency_t urgency, + uint32_t interval, + uint32_t leeway, + uint32_t scale_factor) +{ + thread_t thread = current_thread(); + wait_result_t wresult; + uint64_t deadline; + uint64_t abstime; + uint64_t slop; + uint64_t now; + spl_t s; + + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + now = mach_absolute_time(); + clock_interval_to_absolutetime_interval(interval, scale_factor, &abstime); + deadline = now + abstime; + + clock_interval_to_absolutetime_interval(leeway, scale_factor, &slop); + + struct waitq *waitq; + waitq = global_eventq(event); + + s = splsched(); + waitq_lock(waitq); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT) | DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE_OR_PERM(event), interruptible, deadline, 0, 0); + + wresult = waitq_assert_wait64_locked(waitq, CAST_EVENT64_T(event), + interruptible, + urgency, deadline, slop, + thread); + + waitq_unlock(waitq); + splx(s); + return wresult; +} + +wait_result_t +assert_wait_deadline( + event_t event, + wait_interrupt_t interruptible, + uint64_t deadline) +{ + thread_t thread = current_thread(); + wait_result_t wresult; + spl_t s; + + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + struct waitq *waitq; + waitq = global_eventq(event); + + s = splsched(); + waitq_lock(waitq); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT) | DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE_OR_PERM(event), interruptible, deadline, 0, 0); + + wresult = waitq_assert_wait64_locked(waitq, CAST_EVENT64_T(event), + interruptible, + TIMEOUT_URGENCY_SYS_NORMAL, deadline, + TIMEOUT_NO_LEEWAY, thread); + waitq_unlock(waitq); + splx(s); + return wresult; +} + +wait_result_t +assert_wait_deadline_with_leeway( + event_t event, + wait_interrupt_t interruptible, + wait_timeout_urgency_t urgency, + uint64_t deadline, + uint64_t leeway) +{ + thread_t thread = current_thread(); + wait_result_t wresult; + spl_t s; + + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + struct waitq *waitq; + waitq = global_eventq(event); + + s = splsched(); + waitq_lock(waitq); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT) | DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE_OR_PERM(event), interruptible, deadline, 0, 0); + + wresult = waitq_assert_wait64_locked(waitq, CAST_EVENT64_T(event), + interruptible, + urgency, deadline, leeway, + thread); + waitq_unlock(waitq); + splx(s); + return wresult; +} + +/* + * thread_isoncpu: + * + * Return TRUE if a thread is running on a processor such that an AST + * is needed to pull it out of userspace execution, or if executing in + * the kernel, bring to a context switch boundary that would cause + * thread state to be serialized in the thread PCB. + * + * Thread locked, returns the same way. While locked, fields + * like "state" cannot change. "runq" can change only from set to unset. + */ +static inline boolean_t +thread_isoncpu(thread_t thread) +{ + /* Not running or runnable */ + if (!(thread->state & TH_RUN)) { + return FALSE; + } + + /* Waiting on a runqueue, not currently running */ + /* TODO: This is invalid - it can get dequeued without thread lock, but not context switched. */ + if (thread->runq != PROCESSOR_NULL) { + return FALSE; + } + + /* + * Thread does not have a stack yet + * It could be on the stack alloc queue or preparing to be invoked + */ + if (!thread->kernel_stack) { + return FALSE; + } + + /* + * Thread must be running on a processor, or + * about to run, or just did run. In all these + * cases, an AST to the processor is needed + * to guarantee that the thread is kicked out + * of userspace and the processor has + * context switched (and saved register state). + */ + return TRUE; +} + +/* + * thread_stop: + * + * Force a preemption point for a thread and wait + * for it to stop running on a CPU. If a stronger + * guarantee is requested, wait until no longer + * runnable. Arbitrates access among + * multiple stop requests. (released by unstop) + * + * The thread must enter a wait state and stop via a + * separate means. + * + * Returns FALSE if interrupted. + */ +boolean_t +thread_stop( + thread_t thread, + boolean_t until_not_runnable) +{ + wait_result_t wresult; + spl_t s = splsched(); + boolean_t oncpu; + + wake_lock(thread); + thread_lock(thread); + + while (thread->state & TH_SUSP) { + thread->wake_active = TRUE; + thread_unlock(thread); + + wresult = assert_wait(&thread->wake_active, THREAD_ABORTSAFE); + wake_unlock(thread); + splx(s); + + if (wresult == THREAD_WAITING) { + wresult = thread_block(THREAD_CONTINUE_NULL); + } + + if (wresult != THREAD_AWAKENED) { + return FALSE; + } + + s = splsched(); + wake_lock(thread); + thread_lock(thread); + } + + thread->state |= TH_SUSP; + + while ((oncpu = thread_isoncpu(thread)) || + (until_not_runnable && (thread->state & TH_RUN))) { + processor_t processor; + + if (oncpu) { + assert(thread->state & TH_RUN); + processor = thread->chosen_processor; + cause_ast_check(processor); + } + + thread->wake_active = TRUE; + thread_unlock(thread); + + wresult = assert_wait(&thread->wake_active, THREAD_ABORTSAFE); + wake_unlock(thread); + splx(s); + + if (wresult == THREAD_WAITING) { + wresult = thread_block(THREAD_CONTINUE_NULL); + } + + if (wresult != THREAD_AWAKENED) { + thread_unstop(thread); + return FALSE; + } + + s = splsched(); + wake_lock(thread); + thread_lock(thread); + } + + thread_unlock(thread); + wake_unlock(thread); + splx(s); + + /* + * We return with the thread unlocked. To prevent it from + * transitioning to a runnable state (or from TH_RUN to + * being on the CPU), the caller must ensure the thread + * is stopped via an external means (such as an AST) + */ + + return TRUE; +} + +/* + * thread_unstop: + * + * Release a previous stop request and set + * the thread running if appropriate. + * + * Use only after a successful stop operation. + */ +void +thread_unstop( + thread_t thread) +{ + spl_t s = splsched(); + + wake_lock(thread); + thread_lock(thread); + + assert((thread->state & (TH_RUN | TH_WAIT | TH_SUSP)) != TH_SUSP); + + if (thread->state & TH_SUSP) { + thread->state &= ~TH_SUSP; + + if (thread->wake_active) { + thread->wake_active = FALSE; + thread_unlock(thread); + + thread_wakeup(&thread->wake_active); + wake_unlock(thread); + splx(s); + + return; + } + } + + thread_unlock(thread); + wake_unlock(thread); + splx(s); +} + +/* + * thread_wait: + * + * Wait for a thread to stop running. (non-interruptible) + * + */ +void thread_wait( - thread_t thread) + thread_t thread, + boolean_t until_not_runnable) +{ + wait_result_t wresult; + boolean_t oncpu; + processor_t processor; + spl_t s = splsched(); + + wake_lock(thread); + thread_lock(thread); + + /* + * Wait until not running on a CPU. If stronger requirement + * desired, wait until not runnable. Assumption: if thread is + * on CPU, then TH_RUN is set, so we're not waiting in any case + * where the original, pure "TH_RUN" check would have let us + * finish. + */ + while ((oncpu = thread_isoncpu(thread)) || + (until_not_runnable && (thread->state & TH_RUN))) { + if (oncpu) { + assert(thread->state & TH_RUN); + processor = thread->chosen_processor; + cause_ast_check(processor); + } + + thread->wake_active = TRUE; + thread_unlock(thread); + + wresult = assert_wait(&thread->wake_active, THREAD_UNINT); + wake_unlock(thread); + splx(s); + + if (wresult == THREAD_WAITING) { + thread_block(THREAD_CONTINUE_NULL); + } + + s = splsched(); + wake_lock(thread); + thread_lock(thread); + } + + thread_unlock(thread); + wake_unlock(thread); + splx(s); +} + +/* + * Routine: clear_wait_internal + * + * Clear the wait condition for the specified thread. + * Start the thread executing if that is appropriate. + * Arguments: + * thread thread to awaken + * result Wakeup result the thread should see + * Conditions: + * At splsched + * the thread is locked. + * Returns: + * KERN_SUCCESS thread was rousted out a wait + * KERN_FAILURE thread was waiting but could not be rousted + * KERN_NOT_WAITING thread was not waiting + */ +__private_extern__ kern_return_t +clear_wait_internal( + thread_t thread, + wait_result_t wresult) +{ + uint32_t i = LockTimeOutUsec; + struct waitq *waitq = thread->waitq; + + do { + if (wresult == THREAD_INTERRUPTED && (thread->state & TH_UNINT)) { + return KERN_FAILURE; + } + + if (waitq != NULL) { + if (!waitq_pull_thread_locked(waitq, thread)) { + thread_unlock(thread); + delay(1); + if (i > 0 && !machine_timeout_suspended()) { + i--; + } + thread_lock(thread); + if (waitq != thread->waitq) { + return KERN_NOT_WAITING; + } + continue; + } + } + + /* TODO: Can we instead assert TH_TERMINATE is not set? */ + if ((thread->state & (TH_WAIT | TH_TERMINATE)) == TH_WAIT) { + return thread_go(thread, wresult, WQ_OPTION_NONE); + } else { + return KERN_NOT_WAITING; + } + } while (i > 0); + + panic("clear_wait_internal: deadlock: thread=%p, wq=%p, cpu=%d\n", + thread, waitq, cpu_number()); + + return KERN_FAILURE; +} + + +/* + * clear_wait: + * + * Clear the wait condition for the specified thread. Start the thread + * executing if that is appropriate. + * + * parameters: + * thread thread to awaken + * result Wakeup result the thread should see + */ +kern_return_t +clear_wait( + thread_t thread, + wait_result_t result) +{ + kern_return_t ret; + spl_t s; + + s = splsched(); + thread_lock(thread); + ret = clear_wait_internal(thread, result); + thread_unlock(thread); + splx(s); + return ret; +} + + +/* + * thread_wakeup_prim: + * + * Common routine for thread_wakeup, thread_wakeup_with_result, + * and thread_wakeup_one. + * + */ +kern_return_t +thread_wakeup_prim( + event_t event, + boolean_t one_thread, + wait_result_t result) +{ + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + struct waitq *wq = global_eventq(event); + + if (one_thread) { + return waitq_wakeup64_one(wq, CAST_EVENT64_T(event), result, WAITQ_ALL_PRIORITIES); + } else { + return waitq_wakeup64_all(wq, CAST_EVENT64_T(event), result, WAITQ_ALL_PRIORITIES); + } +} + +/* + * Wakeup a specified thread if and only if it's waiting for this event + */ +kern_return_t +thread_wakeup_thread( + event_t event, + thread_t thread) +{ + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + if (__improbable(thread == THREAD_NULL)) { + panic("%s() called with THREAD_NULL", __func__); + } + + struct waitq *wq = global_eventq(event); + + return waitq_wakeup64_thread(wq, CAST_EVENT64_T(event), thread, THREAD_AWAKENED); +} + +/* + * Wakeup a thread waiting on an event and promote it to a priority. + * + * Requires woken thread to un-promote itself when done. + */ +kern_return_t +thread_wakeup_one_with_pri( + event_t event, + int priority) +{ + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + struct waitq *wq = global_eventq(event); + + return waitq_wakeup64_one(wq, CAST_EVENT64_T(event), THREAD_AWAKENED, priority); +} + +/* + * Wakeup a thread waiting on an event, + * promote it to a priority, + * and return a reference to the woken thread. + * + * Requires woken thread to un-promote itself when done. + */ +thread_t +thread_wakeup_identify(event_t event, + int priority) +{ + if (__improbable(event == NO_EVENT)) { + panic("%s() called with NO_EVENT", __func__); + } + + struct waitq *wq = global_eventq(event); + + return waitq_wakeup64_identify(wq, CAST_EVENT64_T(event), THREAD_AWAKENED, priority); +} + +/* + * thread_bind: + * + * Force the current thread to execute on the specified processor. + * Takes effect after the next thread_block(). + * + * Returns the previous binding. PROCESSOR_NULL means + * not bound. + * + * XXX - DO NOT export this to users - XXX + */ +processor_t +thread_bind( + processor_t processor) +{ + thread_t self = current_thread(); + processor_t prev; + spl_t s; + + s = splsched(); + thread_lock(self); + + prev = thread_bind_internal(self, processor); + + thread_unlock(self); + splx(s); + + return prev; +} + +/* + * thread_bind_internal: + * + * If the specified thread is not the current thread, and it is currently + * running on another CPU, a remote AST must be sent to that CPU to cause + * the thread to migrate to its bound processor. Otherwise, the migration + * will occur at the next quantum expiration or blocking point. + * + * When the thread is the current thread, and explicit thread_block() should + * be used to force the current processor to context switch away and + * let the thread migrate to the bound processor. + * + * Thread must be locked, and at splsched. + */ + +static processor_t +thread_bind_internal( + thread_t thread, + processor_t processor) +{ + processor_t prev; + + /* */ + assert(thread->sched_pri < BASEPRI_RTQUEUES); + /* A thread can't be bound if it's sitting on a (potentially incorrect) runqueue */ + assert(thread->runq == PROCESSOR_NULL); + + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_THREAD_BIND), thread_tid(thread), processor ? (uintptr_t)processor->cpu_id : (uintptr_t)-1, 0, 0, 0); + + prev = thread->bound_processor; + thread->bound_processor = processor; + + return prev; +} + +/* + * thread_vm_bind_group_add: + * + * The "VM bind group" is a special mechanism to mark a collection + * of threads from the VM subsystem that, in general, should be scheduled + * with only one CPU of parallelism. To accomplish this, we initially + * bind all the threads to the master processor, which has the effect + * that only one of the threads in the group can execute at once, including + * preempting threads in the group that are a lower priority. Future + * mechanisms may use more dynamic mechanisms to prevent the collection + * of VM threads from using more CPU time than desired. + * + * The current implementation can result in priority inversions where + * compute-bound priority 95 or realtime threads that happen to have + * landed on the master processor prevent the VM threads from running. + * When this situation is detected, we unbind the threads for one + * scheduler tick to allow the scheduler to run the threads an + * additional CPUs, before restoring the binding (assuming high latency + * is no longer a problem). + */ + +/* + * The current max is provisioned for: + * vm_compressor_swap_trigger_thread (92) + * 2 x vm_pageout_iothread_internal (92) when vm_restricted_to_single_processor==TRUE + * vm_pageout_continue (92) + * memorystatus_thread (95) + */ +#define MAX_VM_BIND_GROUP_COUNT (5) +decl_simple_lock_data(static, sched_vm_group_list_lock); +static thread_t sched_vm_group_thread_list[MAX_VM_BIND_GROUP_COUNT]; +static int sched_vm_group_thread_count; +static boolean_t sched_vm_group_temporarily_unbound = FALSE; + +void +thread_vm_bind_group_add(void) +{ + thread_t self = current_thread(); + + thread_reference_internal(self); + self->options |= TH_OPT_SCHED_VM_GROUP; + + simple_lock(&sched_vm_group_list_lock, LCK_GRP_NULL); + assert(sched_vm_group_thread_count < MAX_VM_BIND_GROUP_COUNT); + sched_vm_group_thread_list[sched_vm_group_thread_count++] = self; + simple_unlock(&sched_vm_group_list_lock); + + thread_bind(master_processor); + + /* Switch to bound processor if not already there */ + thread_block(THREAD_CONTINUE_NULL); +} + +static void +sched_vm_group_maintenance(void) +{ + uint64_t ctime = mach_absolute_time(); + uint64_t longtime = ctime - sched_tick_interval; + int i; + spl_t s; + boolean_t high_latency_observed = FALSE; + boolean_t runnable_and_not_on_runq_observed = FALSE; + boolean_t bind_target_changed = FALSE; + processor_t bind_target = PROCESSOR_NULL; + + /* Make sure nobody attempts to add new threads while we are enumerating them */ + simple_lock(&sched_vm_group_list_lock, LCK_GRP_NULL); + + s = splsched(); + + for (i = 0; i < sched_vm_group_thread_count; i++) { + thread_t thread = sched_vm_group_thread_list[i]; + assert(thread != THREAD_NULL); + thread_lock(thread); + if ((thread->state & (TH_RUN | TH_WAIT)) == TH_RUN) { + if (thread->runq != PROCESSOR_NULL && thread->last_made_runnable_time < longtime) { + high_latency_observed = TRUE; + } else if (thread->runq == PROCESSOR_NULL) { + /* There are some cases where a thread be transitiong that also fall into this case */ + runnable_and_not_on_runq_observed = TRUE; + } + } + thread_unlock(thread); + + if (high_latency_observed && runnable_and_not_on_runq_observed) { + /* All the things we are looking for are true, stop looking */ + break; + } + } + + splx(s); + + if (sched_vm_group_temporarily_unbound) { + /* If we turned off binding, make sure everything is OK before rebinding */ + if (!high_latency_observed) { + /* rebind */ + bind_target_changed = TRUE; + bind_target = master_processor; + sched_vm_group_temporarily_unbound = FALSE; /* might be reset to TRUE if change cannot be completed */ + } + } else { + /* + * Check if we're in a bad state, which is defined by high + * latency with no core currently executing a thread. If a + * single thread is making progress on a CPU, that means the + * binding concept to reduce parallelism is working as + * designed. + */ + if (high_latency_observed && !runnable_and_not_on_runq_observed) { + /* unbind */ + bind_target_changed = TRUE; + bind_target = PROCESSOR_NULL; + sched_vm_group_temporarily_unbound = TRUE; + } + } + + if (bind_target_changed) { + s = splsched(); + for (i = 0; i < sched_vm_group_thread_count; i++) { + thread_t thread = sched_vm_group_thread_list[i]; + boolean_t removed; + assert(thread != THREAD_NULL); + + thread_lock(thread); + removed = thread_run_queue_remove(thread); + if (removed || ((thread->state & (TH_RUN | TH_WAIT)) == TH_WAIT)) { + thread_bind_internal(thread, bind_target); + } else { + /* + * Thread was in the middle of being context-switched-to, + * or was in the process of blocking. To avoid switching the bind + * state out mid-flight, defer the change if possible. + */ + if (bind_target == PROCESSOR_NULL) { + thread_bind_internal(thread, bind_target); + } else { + sched_vm_group_temporarily_unbound = TRUE; /* next pass will try again */ + } + } + + if (removed) { + thread_run_queue_reinsert(thread, SCHED_PREEMPT | SCHED_TAILQ); + } + thread_unlock(thread); + } + splx(s); + } + + simple_unlock(&sched_vm_group_list_lock); +} + +/* Invoked prior to idle entry to determine if, on SMT capable processors, an SMT + * rebalancing opportunity exists when a core is (instantaneously) idle, but + * other SMT-capable cores may be over-committed. TODO: some possible negatives: + * IPI thrash if this core does not remain idle following the load balancing ASTs + * Idle "thrash", when IPI issue is followed by idle entry/core power down + * followed by a wakeup shortly thereafter. + */ + +#if (DEVELOPMENT || DEBUG) +int sched_smt_balance = 1; +#endif + +/* Invoked with pset locked, returns with pset unlocked */ +void +sched_SMT_balance(processor_t cprocessor, processor_set_t cpset) +{ + processor_t ast_processor = NULL; + +#if (DEVELOPMENT || DEBUG) + if (__improbable(sched_smt_balance == 0)) { + goto smt_balance_exit; + } +#endif + + assert(cprocessor == current_processor()); + if (cprocessor->is_SMT == FALSE) { + goto smt_balance_exit; + } + + processor_t sib_processor = cprocessor->processor_secondary ? cprocessor->processor_secondary : cprocessor->processor_primary; + + /* Determine if both this processor and its sibling are idle, + * indicating an SMT rebalancing opportunity. + */ + if (sib_processor->state != PROCESSOR_IDLE) { + goto smt_balance_exit; + } + + processor_t sprocessor; + + sched_ipi_type_t ipi_type = SCHED_IPI_NONE; + uint64_t running_secondary_map = (cpset->cpu_state_map[PROCESSOR_RUNNING] & + ~cpset->primary_map); + for (int cpuid = lsb_first(running_secondary_map); cpuid >= 0; cpuid = lsb_next(running_secondary_map, cpuid)) { + sprocessor = processor_array[cpuid]; + if ((sprocessor->processor_primary->state == PROCESSOR_RUNNING) && + (sprocessor->current_pri < BASEPRI_RTQUEUES)) { + ipi_type = sched_ipi_action(sprocessor, NULL, false, SCHED_IPI_EVENT_SMT_REBAL); + if (ipi_type != SCHED_IPI_NONE) { + assert(sprocessor != cprocessor); + ast_processor = sprocessor; + break; + } + } + } + +smt_balance_exit: + pset_unlock(cpset); + + if (ast_processor) { + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_SMT_BALANCE), ast_processor->cpu_id, ast_processor->state, ast_processor->processor_primary->state, 0, 0); + sched_ipi_perform(ast_processor, ipi_type); + } +} + +static cpumap_t +pset_available_cpumap(processor_set_t pset) +{ + return (pset->cpu_state_map[PROCESSOR_IDLE] | pset->cpu_state_map[PROCESSOR_DISPATCHING] | pset->cpu_state_map[PROCESSOR_RUNNING]) & + pset->recommended_bitmask; +} + +static cpumap_t +pset_available_but_not_running_cpumap(processor_set_t pset) +{ + return (pset->cpu_state_map[PROCESSOR_IDLE] | pset->cpu_state_map[PROCESSOR_DISPATCHING]) & + pset->recommended_bitmask; +} + +bool +pset_has_stealable_threads(processor_set_t pset) +{ + pset_assert_locked(pset); + + cpumap_t avail_map = pset_available_but_not_running_cpumap(pset); + /* + * Secondary CPUs never steal, so allow stealing of threads if there are more threads than + * available primary CPUs + */ + avail_map &= pset->primary_map; + + return (pset->pset_runq.count > 0) && ((pset->pset_runq.count + rt_runq_count(pset)) > bit_count(avail_map)); +} + +/* + * Called with pset locked, on a processor that is committing to run a new thread + * Will transition an idle or dispatching processor to running as it picks up + * the first new thread from the idle thread. + */ +static void +pset_commit_processor_to_new_thread(processor_set_t pset, processor_t processor, thread_t new_thread) +{ + pset_assert_locked(pset); + + if (processor->state == PROCESSOR_DISPATCHING || processor->state == PROCESSOR_IDLE) { + assert(current_thread() == processor->idle_thread); + + /* + * Dispatching processor is now committed to running new_thread, + * so change its state to PROCESSOR_RUNNING. + */ + pset_update_processor_state(pset, processor, PROCESSOR_RUNNING); + } else { + assert((processor->state == PROCESSOR_RUNNING) || (processor->state == PROCESSOR_SHUTDOWN)); + } + + processor_state_update_from_thread(processor, new_thread); + + if (new_thread->sched_pri >= BASEPRI_RTQUEUES) { + bit_set(pset->realtime_map, processor->cpu_id); + } else { + bit_clear(pset->realtime_map, processor->cpu_id); + } + + pset_node_t node = pset->node; + + if (bit_count(node->pset_map) == 1) { + /* Node has only a single pset, so skip node pset map updates */ + return; + } + + cpumap_t avail_map = pset_available_cpumap(pset); + + if (new_thread->sched_pri >= BASEPRI_RTQUEUES) { + if ((avail_map & pset->realtime_map) == avail_map) { + /* No more non-RT CPUs in this pset */ + atomic_bit_clear(&node->pset_non_rt_map, pset->pset_id, memory_order_relaxed); + } + avail_map &= pset->primary_map; + if ((avail_map & pset->realtime_map) == avail_map) { + /* No more non-RT primary CPUs in this pset */ + atomic_bit_clear(&node->pset_non_rt_primary_map, pset->pset_id, memory_order_relaxed); + } + } else { + if ((avail_map & pset->realtime_map) != avail_map) { + if (!bit_test(atomic_load(&node->pset_non_rt_map), pset->pset_id)) { + atomic_bit_set(&node->pset_non_rt_map, pset->pset_id, memory_order_relaxed); + } + } + avail_map &= pset->primary_map; + if ((avail_map & pset->realtime_map) != avail_map) { + if (!bit_test(atomic_load(&node->pset_non_rt_primary_map), pset->pset_id)) { + atomic_bit_set(&node->pset_non_rt_primary_map, pset->pset_id, memory_order_relaxed); + } + } + } +} + +static processor_t choose_processor_for_realtime_thread(processor_set_t pset, processor_t skip_processor, bool consider_secondaries); +static bool all_available_primaries_are_running_realtime_threads(processor_set_t pset); +#if defined(__x86_64__) +static bool these_processors_are_running_realtime_threads(processor_set_t pset, uint64_t these_map); +#endif +static bool sched_ok_to_run_realtime_thread(processor_set_t pset, processor_t processor); +static bool processor_is_fast_track_candidate_for_realtime_thread(processor_set_t pset, processor_t processor); +int sched_allow_rt_smt = 1; +int sched_avoid_cpu0 = 1; + +/* + * thread_select: + * + * Select a new thread for the current processor to execute. + * + * May select the current thread, which must be locked. + */ +static thread_t +thread_select(thread_t thread, + processor_t processor, + ast_t *reason) +{ + processor_set_t pset = processor->processor_set; + thread_t new_thread = THREAD_NULL; + + assert(processor == current_processor()); + assert((thread->state & (TH_RUN | TH_TERMINATE2)) == TH_RUN); + + do { + /* + * Update the priority. + */ + if (SCHED(can_update_priority)(thread)) { + SCHED(update_priority)(thread); + } + + pset_lock(pset); + + processor_state_update_from_thread(processor, thread); + +restart: + /* Acknowledge any pending IPIs here with pset lock held */ + bit_clear(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id); + bit_clear(pset->pending_AST_PREEMPT_cpu_mask, processor->cpu_id); + +#if defined(CONFIG_SCHED_DEFERRED_AST) + bit_clear(pset->pending_deferred_AST_cpu_mask, processor->cpu_id); +#endif + + bool secondary_can_only_run_realtime_thread = false; + + assert(processor->state != PROCESSOR_OFF_LINE); + + if (!processor->is_recommended) { + /* + * The performance controller has provided a hint to not dispatch more threads, + * unless they are bound to us (and thus we are the only option + */ + if (!SCHED(processor_bound_count)(processor)) { + goto idle; + } + } else if (processor->processor_primary != processor) { + /* + * Should this secondary SMT processor attempt to find work? For pset runqueue systems, + * we should look for work only under the same conditions that choose_processor() + * would have assigned work, which is when all primary processors have been assigned work. + * + * An exception is that bound threads are dispatched to a processor without going through + * choose_processor(), so in those cases we should continue trying to dequeue work. + */ + if (!SCHED(processor_bound_count)(processor)) { + if ((pset->recommended_bitmask & pset->primary_map & pset->cpu_state_map[PROCESSOR_IDLE]) != 0) { + goto idle; + } + + /* + * TODO: What if a secondary core beat an idle primary to waking up from an IPI? + * Should it dequeue immediately, or spin waiting for the primary to wake up? + */ + + /* There are no idle primaries */ + + if (processor->processor_primary->current_pri >= BASEPRI_RTQUEUES) { + bool secondary_can_run_realtime_thread = sched_allow_rt_smt && rt_runq_count(pset) && all_available_primaries_are_running_realtime_threads(pset); + if (!secondary_can_run_realtime_thread) { + goto idle; + } + secondary_can_only_run_realtime_thread = true; + } + } + } + + /* + * Test to see if the current thread should continue + * to run on this processor. Must not be attempting to wait, and not + * bound to a different processor, nor be in the wrong + * processor set, nor be forced to context switch by TH_SUSP. + * + * Note that there are never any RT threads in the regular runqueue. + * + * This code is very insanely tricky. + */ + + /* i.e. not waiting, not TH_SUSP'ed */ + bool still_running = ((thread->state & (TH_TERMINATE | TH_IDLE | TH_WAIT | TH_RUN | TH_SUSP)) == TH_RUN); + + /* + * Threads running on SMT processors are forced to context switch. Don't rebalance realtime threads. + * TODO: This should check if it's worth it to rebalance, i.e. 'are there any idle primary processors' + * + * + * A yielding thread shouldn't be forced to context switch. + */ + + bool is_yielding = (*reason & AST_YIELD) == AST_YIELD; + + bool needs_smt_rebalance = !is_yielding && thread->sched_pri < BASEPRI_RTQUEUES && processor->processor_primary != processor; + + bool affinity_mismatch = thread->affinity_set != AFFINITY_SET_NULL && thread->affinity_set->aset_pset != pset; + + bool bound_elsewhere = thread->bound_processor != PROCESSOR_NULL && thread->bound_processor != processor; + + bool avoid_processor = !is_yielding && SCHED(avoid_processor_enabled) && SCHED(thread_avoid_processor)(processor, thread); + + if (still_running && !needs_smt_rebalance && !affinity_mismatch && !bound_elsewhere && !avoid_processor) { + /* + * This thread is eligible to keep running on this processor. + * + * RT threads with un-expired quantum stay on processor, + * unless there's a valid RT thread with an earlier deadline. + */ + if (thread->sched_pri >= BASEPRI_RTQUEUES && processor->first_timeslice) { + if (rt_runq_count(pset) > 0) { + thread_t next_rt = qe_queue_first(&SCHED(rt_runq)(pset)->queue, struct thread, runq_links); + + if (next_rt->realtime.deadline < processor->deadline && + (next_rt->bound_processor == PROCESSOR_NULL || + next_rt->bound_processor == processor)) { + /* The next RT thread is better, so pick it off the runqueue. */ + goto pick_new_rt_thread; + } + } + + /* This is still the best RT thread to run. */ + processor->deadline = thread->realtime.deadline; + + sched_update_pset_load_average(pset, 0); + + processor_t next_rt_processor = PROCESSOR_NULL; + sched_ipi_type_t next_rt_ipi_type = SCHED_IPI_NONE; + + if (rt_runq_count(pset) - bit_count(pset->pending_AST_URGENT_cpu_mask) > 0) { + next_rt_processor = choose_processor_for_realtime_thread(pset, processor, true); + if (next_rt_processor) { + SCHED_DEBUG_CHOOSE_PROCESSOR_KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHOOSE_PROCESSOR) | DBG_FUNC_NONE, + (uintptr_t)0, (uintptr_t)-4, next_rt_processor->cpu_id, next_rt_processor->state, 0); + if (next_rt_processor->state == PROCESSOR_IDLE) { + pset_update_processor_state(pset, next_rt_processor, PROCESSOR_DISPATCHING); + } + next_rt_ipi_type = sched_ipi_action(next_rt_processor, NULL, false, SCHED_IPI_EVENT_PREEMPT); + } + } + pset_unlock(pset); + + if (next_rt_processor) { + sched_ipi_perform(next_rt_processor, next_rt_ipi_type); + } + + return thread; + } + + if ((rt_runq_count(pset) == 0) && + SCHED(processor_queue_has_priority)(processor, thread->sched_pri, TRUE) == FALSE) { + /* This thread is still the highest priority runnable (non-idle) thread */ + processor->deadline = UINT64_MAX; + + sched_update_pset_load_average(pset, 0); + pset_unlock(pset); + + return thread; + } + } else { + /* + * This processor must context switch. + * If it's due to a rebalance, we should aggressively find this thread a new home. + */ + if (needs_smt_rebalance || affinity_mismatch || bound_elsewhere || avoid_processor) { + *reason |= AST_REBALANCE; + } + } + + bool secondary_forced_idle = ((processor->processor_secondary != PROCESSOR_NULL) && + (thread_no_smt(thread) || (thread->sched_pri >= BASEPRI_RTQUEUES)) && + (processor->processor_secondary->state == PROCESSOR_IDLE)); + + /* OK, so we're not going to run the current thread. Look at the RT queue. */ + bool ok_to_run_realtime_thread = sched_ok_to_run_realtime_thread(pset, processor); + if ((rt_runq_count(pset) > 0) && ok_to_run_realtime_thread) { + thread_t next_rt = qe_queue_first(&SCHED(rt_runq)(pset)->queue, struct thread, runq_links); + + if (__probable((next_rt->bound_processor == PROCESSOR_NULL || + (next_rt->bound_processor == processor)))) { +pick_new_rt_thread: + new_thread = qe_dequeue_head(&SCHED(rt_runq)(pset)->queue, struct thread, runq_links); + + new_thread->runq = PROCESSOR_NULL; + SCHED_STATS_RUNQ_CHANGE(&SCHED(rt_runq)(pset)->runq_stats, rt_runq_count(pset)); + rt_runq_count_decr(pset); + + processor->deadline = new_thread->realtime.deadline; + + pset_commit_processor_to_new_thread(pset, processor, new_thread); + + sched_update_pset_load_average(pset, 0); + + processor_t ast_processor = PROCESSOR_NULL; + processor_t next_rt_processor = PROCESSOR_NULL; + sched_ipi_type_t ipi_type = SCHED_IPI_NONE; + sched_ipi_type_t next_rt_ipi_type = SCHED_IPI_NONE; + + if (processor->processor_secondary != NULL) { + processor_t sprocessor = processor->processor_secondary; + if ((sprocessor->state == PROCESSOR_RUNNING) || (sprocessor->state == PROCESSOR_DISPATCHING)) { + ipi_type = sched_ipi_action(sprocessor, NULL, false, SCHED_IPI_EVENT_SMT_REBAL); + ast_processor = sprocessor; + } + } + if (rt_runq_count(pset) - bit_count(pset->pending_AST_URGENT_cpu_mask) > 0) { + next_rt_processor = choose_processor_for_realtime_thread(pset, processor, true); + if (next_rt_processor) { + SCHED_DEBUG_CHOOSE_PROCESSOR_KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHOOSE_PROCESSOR) | DBG_FUNC_NONE, + (uintptr_t)0, (uintptr_t)-5, next_rt_processor->cpu_id, next_rt_processor->state, 0); + if (next_rt_processor->state == PROCESSOR_IDLE) { + pset_update_processor_state(pset, next_rt_processor, PROCESSOR_DISPATCHING); + } + next_rt_ipi_type = sched_ipi_action(next_rt_processor, NULL, false, SCHED_IPI_EVENT_PREEMPT); + } + } + pset_unlock(pset); + + if (ast_processor) { + sched_ipi_perform(ast_processor, ipi_type); + } + + if (next_rt_processor) { + sched_ipi_perform(next_rt_processor, next_rt_ipi_type); + } + + return new_thread; + } + } + if (secondary_can_only_run_realtime_thread) { + goto idle; + } + + processor->deadline = UINT64_MAX; + + /* No RT threads, so let's look at the regular threads. */ + if ((new_thread = SCHED(choose_thread)(processor, MINPRI, *reason)) != THREAD_NULL) { + pset_commit_processor_to_new_thread(pset, processor, new_thread); + sched_update_pset_load_average(pset, 0); + + processor_t ast_processor = PROCESSOR_NULL; + sched_ipi_type_t ipi_type = SCHED_IPI_NONE; + + processor_t sprocessor = processor->processor_secondary; + if ((sprocessor != NULL) && (sprocessor->state == PROCESSOR_RUNNING)) { + if (thread_no_smt(new_thread)) { + ipi_type = sched_ipi_action(sprocessor, NULL, false, SCHED_IPI_EVENT_SMT_REBAL); + ast_processor = sprocessor; + } + } else if (secondary_forced_idle && !thread_no_smt(new_thread) && pset_has_stealable_threads(pset)) { + pset_update_processor_state(pset, sprocessor, PROCESSOR_DISPATCHING); + ipi_type = sched_ipi_action(sprocessor, NULL, true, SCHED_IPI_EVENT_PREEMPT); + ast_processor = sprocessor; + } + pset_unlock(pset); + + if (ast_processor) { + sched_ipi_perform(ast_processor, ipi_type); + } + return new_thread; + } + + if (processor->must_idle) { + processor->must_idle = false; + goto idle; + } + + if (SCHED(steal_thread_enabled)(pset) && (processor->processor_primary == processor)) { + /* + * No runnable threads, attempt to steal + * from other processors. Returns with pset lock dropped. + */ + + if ((new_thread = SCHED(steal_thread)(pset)) != THREAD_NULL) { + /* + * Avoid taking the pset_lock unless it is necessary to change state. + * It's safe to read processor->state here, as only the current processor can change state + * from this point (interrupts are disabled and this processor is committed to run new_thread). + */ + if (processor->state == PROCESSOR_DISPATCHING || processor->state == PROCESSOR_IDLE) { + pset_lock(pset); + pset_commit_processor_to_new_thread(pset, processor, new_thread); + pset_unlock(pset); + } else { + assert((processor->state == PROCESSOR_RUNNING) || (processor->state == PROCESSOR_SHUTDOWN)); + processor_state_update_from_thread(processor, new_thread); + } + + return new_thread; + } + + /* + * If other threads have appeared, shortcut + * around again. + */ + if (!SCHED(processor_queue_empty)(processor) || (ok_to_run_realtime_thread && (rt_runq_count(pset) > 0))) { + continue; + } + + pset_lock(pset); + + /* Someone selected this processor while we had dropped the lock */ + if (bit_test(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id)) { + goto restart; + } + } + +idle: + /* + * Nothing is runnable, so set this processor idle if it + * was running. + */ + if ((processor->state == PROCESSOR_RUNNING) || (processor->state == PROCESSOR_DISPATCHING)) { + pset_update_processor_state(pset, processor, PROCESSOR_IDLE); + processor_state_update_idle(processor); + } + + /* Invoked with pset locked, returns with pset unlocked */ + SCHED(processor_balance)(processor, pset); + + new_thread = processor->idle_thread; + } while (new_thread == THREAD_NULL); + + return new_thread; +} + +/* + * thread_invoke + * + * Called at splsched with neither thread locked. + * + * Perform a context switch and start executing the new thread. + * + * Returns FALSE when the context switch didn't happen. + * The reference to the new thread is still consumed. + * + * "self" is what is currently running on the processor, + * "thread" is the new thread to context switch to + * (which may be the same thread in some cases) + */ +static boolean_t +thread_invoke( + thread_t self, + thread_t thread, + ast_t reason) +{ + if (__improbable(get_preemption_level() != 0)) { + int pl = get_preemption_level(); + panic("thread_invoke: preemption_level %d, possible cause: %s", + pl, (pl < 0 ? "unlocking an unlocked mutex or spinlock" : + "blocking while holding a spinlock, or within interrupt context")); + } + + thread_continue_t continuation = self->continuation; + void *parameter = self->parameter; + processor_t processor; + + uint64_t ctime = mach_absolute_time(); + +#ifdef CONFIG_MACH_APPROXIMATE_TIME + commpage_update_mach_approximate_time(ctime); +#endif + +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + if (!((thread->state & TH_IDLE) != 0 || + ((reason & AST_HANDOFF) && self->sched_mode == TH_MODE_REALTIME))) { + sched_timeshare_consider_maintenance(ctime); + } +#endif + +#if MONOTONIC + mt_sched_update(self); +#endif /* MONOTONIC */ + + assert_thread_magic(self); + assert(self == current_thread()); + assert(self->runq == PROCESSOR_NULL); + assert((self->state & (TH_RUN | TH_TERMINATE2)) == TH_RUN); + + thread_lock(thread); + + assert_thread_magic(thread); + assert((thread->state & (TH_RUN | TH_WAIT | TH_UNINT | TH_TERMINATE | TH_TERMINATE2)) == TH_RUN); + assert(thread->bound_processor == PROCESSOR_NULL || thread->bound_processor == current_processor()); + assert(thread->runq == PROCESSOR_NULL); + + /* Reload precise timing global policy to thread-local policy */ + thread->precise_user_kernel_time = use_precise_user_kernel_time(thread); + + /* Update SFI class based on other factors */ + thread->sfi_class = sfi_thread_classify(thread); + + /* Update the same_pri_latency for the thread (used by perfcontrol callouts) */ + thread->same_pri_latency = ctime - thread->last_basepri_change_time; + /* + * In case a base_pri update happened between the timestamp and + * taking the thread lock + */ + if (ctime <= thread->last_basepri_change_time) { + thread->same_pri_latency = ctime - thread->last_made_runnable_time; + } + + /* Allow realtime threads to hang onto a stack. */ + if ((self->sched_mode == TH_MODE_REALTIME) && !self->reserved_stack) { + self->reserved_stack = self->kernel_stack; + } + + /* Prepare for spin debugging */ +#if INTERRUPT_MASKED_DEBUG + ml_spin_debug_clear(thread); +#endif + + if (continuation != NULL) { + if (!thread->kernel_stack) { + /* + * If we are using a privileged stack, + * check to see whether we can exchange it with + * that of the other thread. + */ + if (self->kernel_stack == self->reserved_stack && !thread->reserved_stack) { + goto need_stack; + } + + /* + * Context switch by performing a stack handoff. + * Requires both threads to be parked in a continuation. + */ + continuation = thread->continuation; + parameter = thread->parameter; + + processor = current_processor(); + processor->active_thread = thread; + processor_state_update_from_thread(processor, thread); + + if (thread->last_processor != processor && thread->last_processor != NULL) { + if (thread->last_processor->processor_set != processor->processor_set) { + thread->ps_switch++; + } + thread->p_switch++; + } + thread->last_processor = processor; + thread->c_switch++; + ast_context(thread); + + thread_unlock(thread); + + self->reason = reason; + + processor->last_dispatch = ctime; + self->last_run_time = ctime; + processor_timer_switch_thread(ctime, &thread->system_timer); + timer_update(&thread->runnable_timer, ctime); + processor->kernel_timer = &thread->system_timer; + + /* + * Since non-precise user/kernel time doesn't update the state timer + * during privilege transitions, synthesize an event now. + */ + if (!thread->precise_user_kernel_time) { + timer_update(processor->current_state, ctime); + } + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_STACK_HANDOFF) | DBG_FUNC_NONE, + self->reason, (uintptr_t)thread_tid(thread), self->sched_pri, thread->sched_pri, 0); + + if ((thread->chosen_processor != processor) && (thread->chosen_processor != PROCESSOR_NULL)) { + SCHED_DEBUG_CHOOSE_PROCESSOR_KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_MOVED) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), (uintptr_t)thread->chosen_processor->cpu_id, 0, 0, 0); + } + + DTRACE_SCHED2(off__cpu, struct thread *, thread, struct proc *, thread->task->bsd_info); + + SCHED_STATS_CSW(processor, self->reason, self->sched_pri, thread->sched_pri); + +#if KPERF + kperf_off_cpu(self); +#endif /* KPERF */ + + /* + * This is where we actually switch thread identity, + * and address space if required. However, register + * state is not switched - this routine leaves the + * stack and register state active on the current CPU. + */ + TLOG(1, "thread_invoke: calling stack_handoff\n"); + stack_handoff(self, thread); + + /* 'self' is now off core */ + assert(thread == current_thread_volatile()); + + DTRACE_SCHED(on__cpu); + +#if KPERF + kperf_on_cpu(thread, continuation, NULL); +#endif /* KPERF */ + + thread_dispatch(self, thread); + +#if KASAN + /* Old thread's stack has been moved to the new thread, so explicitly + * unpoison it. */ + kasan_unpoison_stack(thread->kernel_stack, kernel_stack_size); +#endif + + thread->continuation = thread->parameter = NULL; + + boolean_t enable_interrupts = TRUE; + + /* idle thread needs to stay interrupts-disabled */ + if ((thread->state & TH_IDLE)) { + enable_interrupts = FALSE; + } + + assert(continuation); + call_continuation(continuation, parameter, + thread->wait_result, enable_interrupts); + /*NOTREACHED*/ + } else if (thread == self) { + /* same thread but with continuation */ + ast_context(self); + + thread_unlock(self); + +#if KPERF + kperf_on_cpu(thread, continuation, NULL); +#endif /* KPERF */ + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED) | DBG_FUNC_NONE, + self->reason, (uintptr_t)thread_tid(thread), self->sched_pri, thread->sched_pri, 0); + +#if KASAN + /* stack handoff to self - no thread_dispatch(), so clear the stack + * and free the fakestack directly */ + kasan_fakestack_drop(self); + kasan_fakestack_gc(self); + kasan_unpoison_stack(self->kernel_stack, kernel_stack_size); +#endif + + self->continuation = self->parameter = NULL; + + boolean_t enable_interrupts = TRUE; + + /* idle thread needs to stay interrupts-disabled */ + if ((self->state & TH_IDLE)) { + enable_interrupts = FALSE; + } + + call_continuation(continuation, parameter, + self->wait_result, enable_interrupts); + /*NOTREACHED*/ + } + } else { + /* + * Check that the other thread has a stack + */ + if (!thread->kernel_stack) { +need_stack: + if (!stack_alloc_try(thread)) { + thread_unlock(thread); + thread_stack_enqueue(thread); + return FALSE; + } + } else if (thread == self) { + ast_context(self); + thread_unlock(self); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED) | DBG_FUNC_NONE, + self->reason, (uintptr_t)thread_tid(thread), self->sched_pri, thread->sched_pri, 0); + + return TRUE; + } + } + + /* + * Context switch by full context save. + */ + processor = current_processor(); + processor->active_thread = thread; + processor_state_update_from_thread(processor, thread); + + if (thread->last_processor != processor && thread->last_processor != NULL) { + if (thread->last_processor->processor_set != processor->processor_set) { + thread->ps_switch++; + } + thread->p_switch++; + } + thread->last_processor = processor; + thread->c_switch++; + ast_context(thread); + + thread_unlock(thread); + + self->reason = reason; + + processor->last_dispatch = ctime; + self->last_run_time = ctime; + processor_timer_switch_thread(ctime, &thread->system_timer); + timer_update(&thread->runnable_timer, ctime); + processor->kernel_timer = &thread->system_timer; + + /* + * Since non-precise user/kernel time doesn't update the state timer + * during privilege transitions, synthesize an event now. + */ + if (!thread->precise_user_kernel_time) { + timer_update(processor->current_state, ctime); + } + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED) | DBG_FUNC_NONE, + self->reason, (uintptr_t)thread_tid(thread), self->sched_pri, thread->sched_pri, 0); + + if ((thread->chosen_processor != processor) && (thread->chosen_processor != NULL)) { + SCHED_DEBUG_CHOOSE_PROCESSOR_KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_MOVED) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), (uintptr_t)thread->chosen_processor->cpu_id, 0, 0, 0); + } + + DTRACE_SCHED2(off__cpu, struct thread *, thread, struct proc *, thread->task->bsd_info); + + SCHED_STATS_CSW(processor, self->reason, self->sched_pri, thread->sched_pri); + +#if KPERF + kperf_off_cpu(self); +#endif /* KPERF */ + + /* + * This is where we actually switch register context, + * and address space if required. We will next run + * as a result of a subsequent context switch. + * + * Once registers are switched and the processor is running "thread", + * the stack variables and non-volatile registers will contain whatever + * was there the last time that thread blocked. No local variables should + * be used after this point, except for the special case of "thread", which + * the platform layer returns as the previous thread running on the processor + * via the function call ABI as a return register, and "self", which may have + * been stored on the stack or a non-volatile register, but a stale idea of + * what was on the CPU is newly-accurate because that thread is again + * running on the CPU. + * + * If one of the threads is using a continuation, thread_continue + * is used to stitch up its context. + * + * If we are invoking a thread which is resuming from a continuation, + * the CPU will invoke thread_continue next. + * + * If the current thread is parking in a continuation, then its state + * won't be saved and the stack will be discarded. When the stack is + * re-allocated, it will be configured to resume from thread_continue. + */ + assert(continuation == self->continuation); + thread = machine_switch_context(self, continuation, thread); + assert(self == current_thread_volatile()); + TLOG(1, "thread_invoke: returning machine_switch_context: self %p continuation %p thread %p\n", self, continuation, thread); + + assert(continuation == NULL && self->continuation == NULL); + + DTRACE_SCHED(on__cpu); + +#if KPERF + kperf_on_cpu(self, NULL, __builtin_frame_address(0)); +#endif /* KPERF */ + + /* We have been resumed and are set to run. */ + thread_dispatch(thread, self); + + return TRUE; +} + +#if defined(CONFIG_SCHED_DEFERRED_AST) +/* + * pset_cancel_deferred_dispatch: + * + * Cancels all ASTs that we can cancel for the given processor set + * if the current processor is running the last runnable thread in the + * system. + * + * This function assumes the current thread is runnable. This must + * be called with the pset unlocked. + */ +static void +pset_cancel_deferred_dispatch( + processor_set_t pset, + processor_t processor) +{ + processor_t active_processor = NULL; + uint32_t sampled_sched_run_count; + + pset_lock(pset); + sampled_sched_run_count = os_atomic_load(&sched_run_buckets[TH_BUCKET_RUN], relaxed); + + /* + * If we have emptied the run queue, and our current thread is runnable, we + * should tell any processors that are still DISPATCHING that they will + * probably not have any work to do. In the event that there are no + * pending signals that we can cancel, this is also uninteresting. + * + * In the unlikely event that another thread becomes runnable while we are + * doing this (sched_run_count is atomically updated, not guarded), the + * codepath making it runnable SHOULD (a dangerous word) need the pset lock + * in order to dispatch it to a processor in our pset. So, the other + * codepath will wait while we squash all cancelable ASTs, get the pset + * lock, and then dispatch the freshly runnable thread. So this should be + * correct (we won't accidentally have a runnable thread that hasn't been + * dispatched to an idle processor), if not ideal (we may be restarting the + * dispatch process, which could have some overhead). + */ + + if ((sampled_sched_run_count == 1) && (pset->pending_deferred_AST_cpu_mask)) { + uint64_t dispatching_map = (pset->cpu_state_map[PROCESSOR_DISPATCHING] & + pset->pending_deferred_AST_cpu_mask & + ~pset->pending_AST_URGENT_cpu_mask); + for (int cpuid = lsb_first(dispatching_map); cpuid >= 0; cpuid = lsb_next(dispatching_map, cpuid)) { + active_processor = processor_array[cpuid]; + /* + * If a processor is DISPATCHING, it could be because of + * a cancelable signal. + * + * IF the processor is not our + * current processor (the current processor should not + * be DISPATCHING, so this is a bit paranoid), AND there + * is a cancelable signal pending on the processor, AND + * there is no non-cancelable signal pending (as there is + * no point trying to backtrack on bringing the processor + * up if a signal we cannot cancel is outstanding), THEN + * it should make sense to roll back the processor state + * to the IDLE state. + * + * If the racey nature of this approach (as the signal + * will be arbitrated by hardware, and can fire as we + * roll back state) results in the core responding + * despite being pushed back to the IDLE state, it + * should be no different than if the core took some + * interrupt while IDLE. + */ + if (active_processor != processor) { + /* + * Squash all of the processor state back to some + * reasonable facsimile of PROCESSOR_IDLE. + */ + + processor_state_update_idle(active_processor); + active_processor->deadline = UINT64_MAX; + pset_update_processor_state(pset, active_processor, PROCESSOR_IDLE); + bit_clear(pset->pending_deferred_AST_cpu_mask, active_processor->cpu_id); + machine_signal_idle_cancel(active_processor); + } + } + } + + pset_unlock(pset); +} +#else +/* We don't support deferred ASTs; everything is candycanes and sunshine. */ +#endif + +static void +thread_csw_callout( + thread_t old, + thread_t new, + uint64_t timestamp) +{ + perfcontrol_event event = (new->state & TH_IDLE) ? IDLE : CONTEXT_SWITCH; + uint64_t same_pri_latency = (new->state & TH_IDLE) ? 0 : new->same_pri_latency; + machine_switch_perfcontrol_context(event, timestamp, 0, + same_pri_latency, old, new); +} + + +/* + * thread_dispatch: + * + * Handle threads at context switch. Re-dispatch other thread + * if still running, otherwise update run state and perform + * special actions. Update quantum for other thread and begin + * the quantum for ourselves. + * + * "thread" is the old thread that we have switched away from. + * "self" is the new current thread that we have context switched to + * + * Called at splsched. + * + */ +void +thread_dispatch( + thread_t thread, + thread_t self) +{ + processor_t processor = self->last_processor; + bool was_idle = false; + + assert(processor == current_processor()); + assert(self == current_thread_volatile()); + assert(thread != self); + + if (thread != THREAD_NULL) { + /* + * Do the perfcontrol callout for context switch. + * The reason we do this here is: + * - thread_dispatch() is called from various places that are not + * the direct context switch path for eg. processor shutdown etc. + * So adding the callout here covers all those cases. + * - We want this callout as early as possible to be close + * to the timestamp taken in thread_invoke() + * - We want to avoid holding the thread lock while doing the + * callout + * - We do not want to callout if "thread" is NULL. + */ + thread_csw_callout(thread, self, processor->last_dispatch); + +#if KASAN + if (thread->continuation != NULL) { + /* + * Thread has a continuation and the normal stack is going away. + * Unpoison the stack and mark all fakestack objects as unused. + */ + kasan_fakestack_drop(thread); + if (thread->kernel_stack) { + kasan_unpoison_stack(thread->kernel_stack, kernel_stack_size); + } + } + + /* + * Free all unused fakestack objects. + */ + kasan_fakestack_gc(thread); +#endif + + /* + * If blocked at a continuation, discard + * the stack. + */ + if (thread->continuation != NULL && thread->kernel_stack != 0) { + stack_free(thread); + } + + if (thread->state & TH_IDLE) { + was_idle = true; + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_DISPATCH) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), 0, thread->state, + sched_run_buckets[TH_BUCKET_RUN], 0); + } else { + int64_t consumed; + int64_t remainder = 0; + + if (processor->quantum_end > processor->last_dispatch) { + remainder = processor->quantum_end - + processor->last_dispatch; + } + + consumed = thread->quantum_remaining - remainder; + + if ((thread->reason & AST_LEDGER) == 0) { + /* + * Bill CPU time to both the task and + * the individual thread. + */ + ledger_credit_thread(thread, thread->t_ledger, + task_ledgers.cpu_time, consumed); + ledger_credit_thread(thread, thread->t_threadledger, + thread_ledgers.cpu_time, consumed); + if (thread->t_bankledger) { + ledger_credit_thread(thread, thread->t_bankledger, + bank_ledgers.cpu_time, + (consumed - thread->t_deduct_bank_ledger_time)); + } + thread->t_deduct_bank_ledger_time = 0; + if (consumed > 0) { + /* + * This should never be negative, but in traces we are seeing some instances + * of consumed being negative. + * thread_dispatch() thread CPU consumed calculation sometimes results in negative value + */ + sched_update_pset_avg_execution_time(current_processor()->processor_set, consumed, processor->last_dispatch, thread->th_sched_bucket); + } + } + + wake_lock(thread); + thread_lock(thread); + + /* + * Apply a priority floor if the thread holds a kernel resource + * Do this before checking starting_pri to avoid overpenalizing + * repeated rwlock blockers. + */ + if (__improbable(thread->rwlock_count != 0)) { + lck_rw_set_promotion_locked(thread); + } + + boolean_t keep_quantum = processor->first_timeslice; + + /* + * Treat a thread which has dropped priority since it got on core + * as having expired its quantum. + */ + if (processor->starting_pri > thread->sched_pri) { + keep_quantum = FALSE; + } + + /* Compute remainder of current quantum. */ + if (keep_quantum && + processor->quantum_end > processor->last_dispatch) { + thread->quantum_remaining = (uint32_t)remainder; + } else { + thread->quantum_remaining = 0; + } + + if (thread->sched_mode == TH_MODE_REALTIME) { + /* + * Cancel the deadline if the thread has + * consumed the entire quantum. + */ + if (thread->quantum_remaining == 0) { + KDBG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_CANCEL_RT_DEADLINE) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), thread->realtime.deadline, thread->realtime.computation, 0); + thread->realtime.deadline = UINT64_MAX; + } + } else { +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + /* + * For non-realtime threads treat a tiny + * remaining quantum as an expired quantum + * but include what's left next time. + */ + if (thread->quantum_remaining < min_std_quantum) { + thread->reason |= AST_QUANTUM; + thread->quantum_remaining += SCHED(initial_quantum_size)(thread); + } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + } + + /* + * If we are doing a direct handoff then + * take the remainder of the quantum. + */ + if ((thread->reason & (AST_HANDOFF | AST_QUANTUM)) == AST_HANDOFF) { + self->quantum_remaining = thread->quantum_remaining; + thread->reason |= AST_QUANTUM; + thread->quantum_remaining = 0; + } else { +#if defined(CONFIG_SCHED_MULTIQ) + if (SCHED(sched_groups_enabled) && + thread->sched_group == self->sched_group) { + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_QUANTUM_HANDOFF), + self->reason, (uintptr_t)thread_tid(thread), + self->quantum_remaining, thread->quantum_remaining, 0); + + self->quantum_remaining = thread->quantum_remaining; + thread->quantum_remaining = 0; + /* Don't set AST_QUANTUM here - old thread might still want to preempt someone else */ + } +#endif /* defined(CONFIG_SCHED_MULTIQ) */ + } + + thread->computation_metered += (processor->last_dispatch - thread->computation_epoch); + + if (!(thread->state & TH_WAIT)) { + /* + * Still runnable. + */ + thread->last_made_runnable_time = thread->last_basepri_change_time = processor->last_dispatch; + + machine_thread_going_off_core(thread, FALSE, processor->last_dispatch, TRUE); + + ast_t reason = thread->reason; + sched_options_t options = SCHED_NONE; + + if (reason & AST_REBALANCE) { + options |= SCHED_REBALANCE; + if (reason & AST_QUANTUM) { + /* + * Having gone to the trouble of forcing this thread off a less preferred core, + * we should force the preferable core to reschedule immediately to give this + * thread a chance to run instead of just sitting on the run queue where + * it may just be stolen back by the idle core we just forced it off. + * But only do this at the end of a quantum to prevent cascading effects. + */ + options |= SCHED_PREEMPT; + } + } + + if (reason & AST_QUANTUM) { + options |= SCHED_TAILQ; + } else if (reason & AST_PREEMPT) { + options |= SCHED_HEADQ; + } else { + options |= (SCHED_PREEMPT | SCHED_TAILQ); + } + + thread_setrun(thread, options); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_DISPATCH) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), thread->reason, thread->state, + sched_run_buckets[TH_BUCKET_RUN], 0); + + if (thread->wake_active) { + thread->wake_active = FALSE; + thread_unlock(thread); + + thread_wakeup(&thread->wake_active); + } else { + thread_unlock(thread); + } + + wake_unlock(thread); + } else { + /* + * Waiting. + */ + boolean_t should_terminate = FALSE; + uint32_t new_run_count; + int thread_state = thread->state; + + /* Only the first call to thread_dispatch + * after explicit termination should add + * the thread to the termination queue + */ + if ((thread_state & (TH_TERMINATE | TH_TERMINATE2)) == TH_TERMINATE) { + should_terminate = TRUE; + thread_state |= TH_TERMINATE2; + } + + timer_stop(&thread->runnable_timer, processor->last_dispatch); + + thread_state &= ~TH_RUN; + thread->state = thread_state; + + thread->last_made_runnable_time = thread->last_basepri_change_time = THREAD_NOT_RUNNABLE; + thread->chosen_processor = PROCESSOR_NULL; + + new_run_count = SCHED(run_count_decr)(thread); + +#if CONFIG_SCHED_AUTO_JOIN + if ((thread->sched_flags & TH_SFLAG_THREAD_GROUP_AUTO_JOIN) != 0) { + work_interval_auto_join_unwind(thread); + } +#endif /* CONFIG_SCHED_AUTO_JOIN */ + +#if CONFIG_SCHED_SFI + if (thread->reason & AST_SFI) { + thread->wait_sfi_begin_time = processor->last_dispatch; + } +#endif + machine_thread_going_off_core(thread, should_terminate, processor->last_dispatch, FALSE); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_DISPATCH) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), thread->reason, thread_state, + new_run_count, 0); + + if (thread_state & TH_WAIT_REPORT) { + (*thread->sched_call)(SCHED_CALL_BLOCK, thread); + } + + if (thread->wake_active) { + thread->wake_active = FALSE; + thread_unlock(thread); + + thread_wakeup(&thread->wake_active); + } else { + thread_unlock(thread); + } + + wake_unlock(thread); + + if (should_terminate) { + thread_terminate_enqueue(thread); + } + } + } + /* + * The thread could have been added to the termination queue, so it's + * unsafe to use after this point. + */ + thread = THREAD_NULL; + } + + int urgency = THREAD_URGENCY_NONE; + uint64_t latency = 0; + + /* Update (new) current thread and reprogram running timers */ + thread_lock(self); + + if (!(self->state & TH_IDLE)) { + uint64_t arg1, arg2; + +#if CONFIG_SCHED_SFI + ast_t new_ast; + + new_ast = sfi_thread_needs_ast(self, NULL); + + if (new_ast != AST_NONE) { + ast_on(new_ast); + } +#endif + + assertf(processor->last_dispatch >= self->last_made_runnable_time, + "Non-monotonic time? dispatch at 0x%llx, runnable at 0x%llx", + processor->last_dispatch, self->last_made_runnable_time); + + assert(self->last_made_runnable_time <= self->last_basepri_change_time); + + latency = processor->last_dispatch - self->last_made_runnable_time; + assert(latency >= self->same_pri_latency); + + urgency = thread_get_urgency(self, &arg1, &arg2); + + thread_tell_urgency(urgency, arg1, arg2, latency, self); + + /* + * Get a new quantum if none remaining. + */ + if (self->quantum_remaining == 0) { + thread_quantum_init(self); + } + + /* + * Set up quantum timer and timeslice. + */ + processor->quantum_end = processor->last_dispatch + + self->quantum_remaining; + + running_timer_setup(processor, RUNNING_TIMER_QUANTUM, self, + processor->quantum_end, processor->last_dispatch); + if (was_idle) { + /* + * kperf's running timer is active whenever the idle thread for a + * CPU is not running. + */ + kperf_running_setup(processor, processor->last_dispatch); + } + running_timers_activate(processor); + processor->first_timeslice = TRUE; + } else { + running_timers_deactivate(processor); + processor->first_timeslice = FALSE; + thread_tell_urgency(THREAD_URGENCY_NONE, 0, 0, 0, self); + } + + assert(self->block_hint == kThreadWaitNone); + self->computation_epoch = processor->last_dispatch; + self->reason = AST_NONE; + processor->starting_pri = self->sched_pri; + + thread_unlock(self); + + machine_thread_going_on_core(self, urgency, latency, self->same_pri_latency, + processor->last_dispatch); + +#if defined(CONFIG_SCHED_DEFERRED_AST) + /* + * TODO: Can we state that redispatching our old thread is also + * uninteresting? + */ + if ((os_atomic_load(&sched_run_buckets[TH_BUCKET_RUN], relaxed) == 1) && !(self->state & TH_IDLE)) { + pset_cancel_deferred_dispatch(processor->processor_set, processor); + } +#endif +} + +/* + * thread_block_reason: + * + * Forces a reschedule, blocking the caller if a wait + * has been asserted. + * + * If a continuation is specified, then thread_invoke will + * attempt to discard the thread's kernel stack. When the + * thread resumes, it will execute the continuation function + * on a new kernel stack. + */ +wait_result_t +thread_block_reason( + thread_continue_t continuation, + void *parameter, + ast_t reason) +{ + thread_t self = current_thread(); + processor_t processor; + thread_t new_thread; + spl_t s; + + s = splsched(); + + processor = current_processor(); + + /* If we're explicitly yielding, force a subsequent quantum */ + if (reason & AST_YIELD) { + processor->first_timeslice = FALSE; + } + + /* We're handling all scheduling AST's */ + ast_off(AST_SCHEDULING); + +#if PROC_REF_DEBUG + if ((continuation != NULL) && (self->task != kernel_task)) { + if (uthread_get_proc_refcount(self->uthread) != 0) { + panic("thread_block_reason with continuation uthread %p with uu_proc_refcount != 0", self->uthread); + } + } +#endif + + self->continuation = continuation; + self->parameter = parameter; + + if (self->state & ~(TH_RUN | TH_IDLE)) { + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_BLOCK), + reason, VM_KERNEL_UNSLIDE(continuation), 0, 0, 0); + } + + do { + thread_lock(self); + new_thread = thread_select(self, processor, &reason); + thread_unlock(self); + } while (!thread_invoke(self, new_thread, reason)); + + splx(s); + + return self->wait_result; +} + +/* + * thread_block: + * + * Block the current thread if a wait has been asserted. + */ +wait_result_t +thread_block( + thread_continue_t continuation) +{ + return thread_block_reason(continuation, NULL, AST_NONE); +} + +wait_result_t +thread_block_parameter( + thread_continue_t continuation, + void *parameter) +{ + return thread_block_reason(continuation, parameter, AST_NONE); +} + +/* + * thread_run: + * + * Switch directly from the current thread to the + * new thread, handing off our quantum if appropriate. + * + * New thread must be runnable, and not on a run queue. + * + * Called at splsched. + */ +int +thread_run( + thread_t self, + thread_continue_t continuation, + void *parameter, + thread_t new_thread) +{ + ast_t reason = AST_NONE; + + if ((self->state & TH_IDLE) == 0) { + reason = AST_HANDOFF; + } + + /* + * If this thread hadn't been setrun'ed, it + * might not have a chosen processor, so give it one + */ + if (new_thread->chosen_processor == NULL) { + new_thread->chosen_processor = current_processor(); + } + + self->continuation = continuation; + self->parameter = parameter; + + while (!thread_invoke(self, new_thread, reason)) { + /* the handoff failed, so we have to fall back to the normal block path */ + processor_t processor = current_processor(); + + reason = AST_NONE; + + thread_lock(self); + new_thread = thread_select(self, processor, &reason); + thread_unlock(self); + } + + return self->wait_result; +} + +/* + * thread_continue: + * + * Called at splsched when a thread first receives + * a new stack after a continuation. + * + * Called with THREAD_NULL as the old thread when + * invoked by machine_load_context. + */ +void +thread_continue( + thread_t thread) +{ + thread_t self = current_thread(); + thread_continue_t continuation; + void *parameter; + + DTRACE_SCHED(on__cpu); + + continuation = self->continuation; + parameter = self->parameter; + + assert(continuation != NULL); + +#if KPERF + kperf_on_cpu(self, continuation, NULL); +#endif + + thread_dispatch(thread, self); + + self->continuation = self->parameter = NULL; + +#if INTERRUPT_MASKED_DEBUG + /* Reset interrupt-masked spin debugging timeout */ + ml_spin_debug_clear(self); +#endif + + TLOG(1, "thread_continue: calling call_continuation\n"); + + boolean_t enable_interrupts = TRUE; + + /* bootstrap thread, idle thread need to stay interrupts-disabled */ + if (thread == THREAD_NULL || (self->state & TH_IDLE)) { + enable_interrupts = FALSE; + } + + call_continuation(continuation, parameter, self->wait_result, enable_interrupts); + /*NOTREACHED*/ +} + +void +thread_quantum_init(thread_t thread) +{ + if (thread->sched_mode == TH_MODE_REALTIME) { + thread->quantum_remaining = thread->realtime.computation; + } else { + thread->quantum_remaining = SCHED(initial_quantum_size)(thread); + } +} + +uint32_t +sched_timeshare_initial_quantum_size(thread_t thread) +{ + if ((thread != THREAD_NULL) && thread->th_sched_bucket == TH_BUCKET_SHARE_BG) { + return bg_quantum; + } else { + return std_quantum; + } +} + +/* + * run_queue_init: + * + * Initialize a run queue before first use. + */ +void +run_queue_init( + run_queue_t rq) +{ + rq->highq = NOPRI; + for (u_int i = 0; i < BITMAP_LEN(NRQS); i++) { + rq->bitmap[i] = 0; + } + rq->urgency = rq->count = 0; + for (int i = 0; i < NRQS; i++) { + circle_queue_init(&rq->queues[i]); + } +} + +/* + * run_queue_dequeue: + * + * Perform a dequeue operation on a run queue, + * and return the resulting thread. + * + * The run queue must be locked (see thread_run_queue_remove() + * for more info), and not empty. + */ +thread_t +run_queue_dequeue( + run_queue_t rq, + sched_options_t options) +{ + thread_t thread; + circle_queue_t queue = &rq->queues[rq->highq]; + + if (options & SCHED_HEADQ) { + thread = cqe_dequeue_head(queue, struct thread, runq_links); + } else { + thread = cqe_dequeue_tail(queue, struct thread, runq_links); + } + + assert(thread != THREAD_NULL); + assert_thread_magic(thread); + + thread->runq = PROCESSOR_NULL; + SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count); + rq->count--; + if (SCHED(priority_is_urgent)(rq->highq)) { + rq->urgency--; assert(rq->urgency >= 0); + } + if (circle_queue_empty(queue)) { + bitmap_clear(rq->bitmap, rq->highq); + rq->highq = bitmap_first(rq->bitmap, NRQS); + } + + return thread; +} + +/* + * run_queue_enqueue: + * + * Perform a enqueue operation on a run queue. + * + * The run queue must be locked (see thread_run_queue_remove() + * for more info). + */ +boolean_t +run_queue_enqueue( + run_queue_t rq, + thread_t thread, + sched_options_t options) +{ + circle_queue_t queue = &rq->queues[thread->sched_pri]; + boolean_t result = FALSE; + + assert_thread_magic(thread); + + if (circle_queue_empty(queue)) { + circle_enqueue_tail(queue, &thread->runq_links); + + rq_bitmap_set(rq->bitmap, thread->sched_pri); + if (thread->sched_pri > rq->highq) { + rq->highq = thread->sched_pri; + result = TRUE; + } + } else { + if (options & SCHED_TAILQ) { + circle_enqueue_tail(queue, &thread->runq_links); + } else { + circle_enqueue_head(queue, &thread->runq_links); + } + } + if (SCHED(priority_is_urgent)(thread->sched_pri)) { + rq->urgency++; + } + SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count); + rq->count++; + + return result; +} + +/* + * run_queue_remove: + * + * Remove a specific thread from a runqueue. + * + * The run queue must be locked. + */ +void +run_queue_remove( + run_queue_t rq, + thread_t thread) +{ + circle_queue_t queue = &rq->queues[thread->sched_pri]; + + assert(thread->runq != PROCESSOR_NULL); + assert_thread_magic(thread); + + circle_dequeue(queue, &thread->runq_links); + SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count); + rq->count--; + if (SCHED(priority_is_urgent)(thread->sched_pri)) { + rq->urgency--; assert(rq->urgency >= 0); + } + + if (circle_queue_empty(queue)) { + /* update run queue status */ + bitmap_clear(rq->bitmap, thread->sched_pri); + rq->highq = bitmap_first(rq->bitmap, NRQS); + } + + thread->runq = PROCESSOR_NULL; +} + +/* + * run_queue_peek + * + * Peek at the runq and return the highest + * priority thread from the runq. + * + * The run queue must be locked. + */ +thread_t +run_queue_peek( + run_queue_t rq) +{ + if (rq->count > 0) { + circle_queue_t queue = &rq->queues[rq->highq]; + thread_t thread = cqe_queue_first(queue, struct thread, runq_links); + assert_thread_magic(thread); + return thread; + } else { + return THREAD_NULL; + } +} + +rt_queue_t +sched_rtlocal_runq(processor_set_t pset) +{ + return &pset->rt_runq; +} + +void +sched_rtlocal_init(processor_set_t pset) +{ + pset_rt_init(pset); +} + +void +sched_rtlocal_queue_shutdown(processor_t processor) +{ + processor_set_t pset = processor->processor_set; + thread_t thread; + queue_head_t tqueue; + + pset_lock(pset); + + /* We only need to migrate threads if this is the last active or last recommended processor in the pset */ + if ((pset->online_processor_count > 0) && pset_is_recommended(pset)) { + pset_unlock(pset); + return; + } + + queue_init(&tqueue); + + while (rt_runq_count(pset) > 0) { + thread = qe_dequeue_head(&pset->rt_runq.queue, struct thread, runq_links); + thread->runq = PROCESSOR_NULL; + SCHED_STATS_RUNQ_CHANGE(&pset->rt_runq.runq_stats, rt_runq_count(pset)); + rt_runq_count_decr(pset); + enqueue_tail(&tqueue, &thread->runq_links); + } + sched_update_pset_load_average(pset, 0); + pset_unlock(pset); + + qe_foreach_element_safe(thread, &tqueue, runq_links) { + remqueue(&thread->runq_links); + + thread_lock(thread); + + thread_setrun(thread, SCHED_TAILQ); + + thread_unlock(thread); + } +} + +/* Assumes RT lock is not held, and acquires splsched/rt_lock itself */ +void +sched_rtlocal_runq_scan(sched_update_scan_context_t scan_context) +{ + thread_t thread; + + pset_node_t node = &pset_node0; + processor_set_t pset = node->psets; + + spl_t s = splsched(); + do { + while (pset != NULL) { + pset_lock(pset); + + qe_foreach_element_safe(thread, &pset->rt_runq.queue, runq_links) { + if (thread->last_made_runnable_time < scan_context->earliest_rt_make_runnable_time) { + scan_context->earliest_rt_make_runnable_time = thread->last_made_runnable_time; + } + } + + pset_unlock(pset); + + pset = pset->pset_list; + } + } while (((node = node->node_list) != NULL) && ((pset = node->psets) != NULL)); + splx(s); +} + +int64_t +sched_rtlocal_runq_count_sum(void) +{ + pset_node_t node = &pset_node0; + processor_set_t pset = node->psets; + int64_t count = 0; + + do { + while (pset != NULL) { + count += pset->rt_runq.runq_stats.count_sum; + + pset = pset->pset_list; + } + } while (((node = node->node_list) != NULL) && ((pset = node->psets) != NULL)); + + return count; +} + +/* + * realtime_queue_insert: + * + * Enqueue a thread for realtime execution. + */ +static boolean_t +realtime_queue_insert(processor_t processor, processor_set_t pset, thread_t thread) +{ + queue_t queue = &SCHED(rt_runq)(pset)->queue; + uint64_t deadline = thread->realtime.deadline; + boolean_t preempt = FALSE; + + pset_assert_locked(pset); + + if (queue_empty(queue)) { + enqueue_tail(queue, &thread->runq_links); + preempt = TRUE; + } else { + /* Insert into rt_runq in thread deadline order */ + queue_entry_t iter; + qe_foreach(iter, queue) { + thread_t iter_thread = qe_element(iter, struct thread, runq_links); + assert_thread_magic(iter_thread); + + if (deadline < iter_thread->realtime.deadline) { + if (iter == queue_first(queue)) { + preempt = TRUE; + } + insque(&thread->runq_links, queue_prev(iter)); + break; + } else if (iter == queue_last(queue)) { + enqueue_tail(queue, &thread->runq_links); + break; + } + } + } + + thread->runq = processor; + SCHED_STATS_RUNQ_CHANGE(&SCHED(rt_runq)(pset)->runq_stats, rt_runq_count(pset)); + rt_runq_count_incr(pset); + + return preempt; +} + +#define MAX_BACKUP_PROCESSORS 7 +#if defined(__x86_64__) +#define DEFAULT_BACKUP_PROCESSORS 1 +#else +#define DEFAULT_BACKUP_PROCESSORS 0 +#endif + +int sched_rt_n_backup_processors = DEFAULT_BACKUP_PROCESSORS; + +int +sched_get_rt_n_backup_processors(void) +{ + return sched_rt_n_backup_processors; +} + +void +sched_set_rt_n_backup_processors(int n) +{ + if (n < 0) { + n = 0; + } else if (n > MAX_BACKUP_PROCESSORS) { + n = MAX_BACKUP_PROCESSORS; + } + + sched_rt_n_backup_processors = n; +} + +/* + * realtime_setrun: + * + * Dispatch a thread for realtime execution. + * + * Thread must be locked. Associated pset must + * be locked, and is returned unlocked. + */ +static void +realtime_setrun( + processor_t chosen_processor, + thread_t thread) +{ + processor_set_t pset = chosen_processor->processor_set; + pset_assert_locked(pset); + ast_t preempt; + + int n_backup = 0; + + if (thread->realtime.constraint <= rt_constraint_threshold) { + n_backup = sched_rt_n_backup_processors; + } + assert((n_backup >= 0) && (n_backup <= MAX_BACKUP_PROCESSORS)); + + sched_ipi_type_t ipi_type[MAX_BACKUP_PROCESSORS + 1] = {}; + processor_t ipi_processor[MAX_BACKUP_PROCESSORS + 1] = {}; + + thread->chosen_processor = chosen_processor; + + /* */ + assert(thread->bound_processor == PROCESSOR_NULL); + + realtime_queue_insert(chosen_processor, pset, thread); + + processor_t processor = chosen_processor; + bool chosen_process_is_secondary = chosen_processor->processor_primary != chosen_processor; + + int count = 0; + for (int i = 0; i <= n_backup; i++) { + if (i > 0) { + processor = choose_processor_for_realtime_thread(pset, chosen_processor, chosen_process_is_secondary); + if ((processor == PROCESSOR_NULL) || (sched_avoid_cpu0 && (processor->cpu_id == 0))) { + break; + } + SCHED_DEBUG_CHOOSE_PROCESSOR_KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHOOSE_PROCESSOR) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), (uintptr_t)-3, processor->cpu_id, processor->state, 0); + } + ipi_type[i] = SCHED_IPI_NONE; + ipi_processor[i] = processor; + count++; + + if (processor->current_pri < BASEPRI_RTQUEUES) { + preempt = (AST_PREEMPT | AST_URGENT); + } else if (thread->realtime.deadline < processor->deadline) { + preempt = (AST_PREEMPT | AST_URGENT); + } else { + preempt = AST_NONE; + } + + if (preempt != AST_NONE) { + if (processor->state == PROCESSOR_IDLE) { + processor_state_update_from_thread(processor, thread); + processor->deadline = thread->realtime.deadline; + pset_update_processor_state(pset, processor, PROCESSOR_DISPATCHING); + if (processor == current_processor()) { + ast_on(preempt); + + if ((preempt & AST_URGENT) == AST_URGENT) { + bit_set(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id); + } + + if ((preempt & AST_PREEMPT) == AST_PREEMPT) { + bit_set(pset->pending_AST_PREEMPT_cpu_mask, processor->cpu_id); + } + } else { + ipi_type[i] = sched_ipi_action(processor, thread, true, SCHED_IPI_EVENT_PREEMPT); + } + } else if (processor->state == PROCESSOR_DISPATCHING) { + if ((processor->current_pri < thread->sched_pri) || (processor->deadline > thread->realtime.deadline)) { + processor_state_update_from_thread(processor, thread); + processor->deadline = thread->realtime.deadline; + } + } else { + if (processor == current_processor()) { + ast_on(preempt); + + if ((preempt & AST_URGENT) == AST_URGENT) { + bit_set(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id); + } + + if ((preempt & AST_PREEMPT) == AST_PREEMPT) { + bit_set(pset->pending_AST_PREEMPT_cpu_mask, processor->cpu_id); + } + } else { + ipi_type[i] = sched_ipi_action(processor, thread, false, SCHED_IPI_EVENT_PREEMPT); + } + } + } else { + /* Selected processor was too busy, just keep thread enqueued and let other processors drain it naturally. */ + } + } + + pset_unlock(pset); + + assert((count > 0) && (count <= (n_backup + 1))); + for (int i = 0; i < count; i++) { + assert(ipi_processor[i] != PROCESSOR_NULL); + sched_ipi_perform(ipi_processor[i], ipi_type[i]); + } +} + + +sched_ipi_type_t +sched_ipi_deferred_policy(processor_set_t pset, processor_t dst, + __unused sched_ipi_event_t event) +{ +#if defined(CONFIG_SCHED_DEFERRED_AST) + if (!bit_test(pset->pending_deferred_AST_cpu_mask, dst->cpu_id)) { + return SCHED_IPI_DEFERRED; + } +#else /* CONFIG_SCHED_DEFERRED_AST */ + panic("Request for deferred IPI on an unsupported platform; pset: %p CPU: %d", pset, dst->cpu_id); +#endif /* CONFIG_SCHED_DEFERRED_AST */ + return SCHED_IPI_NONE; +} + +sched_ipi_type_t +sched_ipi_action(processor_t dst, thread_t thread, boolean_t dst_idle, sched_ipi_event_t event) +{ + sched_ipi_type_t ipi_type = SCHED_IPI_NONE; + assert(dst != NULL); + + processor_set_t pset = dst->processor_set; + if (current_processor() == dst) { + return SCHED_IPI_NONE; + } + + if (bit_test(pset->pending_AST_URGENT_cpu_mask, dst->cpu_id)) { + return SCHED_IPI_NONE; + } + + ipi_type = SCHED(ipi_policy)(dst, thread, dst_idle, event); + switch (ipi_type) { + case SCHED_IPI_NONE: + return SCHED_IPI_NONE; +#if defined(CONFIG_SCHED_DEFERRED_AST) + case SCHED_IPI_DEFERRED: + bit_set(pset->pending_deferred_AST_cpu_mask, dst->cpu_id); + break; +#endif /* CONFIG_SCHED_DEFERRED_AST */ + default: + bit_set(pset->pending_AST_URGENT_cpu_mask, dst->cpu_id); + bit_set(pset->pending_AST_PREEMPT_cpu_mask, dst->cpu_id); + break; + } + return ipi_type; +} + +sched_ipi_type_t +sched_ipi_policy(processor_t dst, thread_t thread, boolean_t dst_idle, sched_ipi_event_t event) +{ + sched_ipi_type_t ipi_type = SCHED_IPI_NONE; + boolean_t deferred_ipi_supported = false; + processor_set_t pset = dst->processor_set; + +#if defined(CONFIG_SCHED_DEFERRED_AST) + deferred_ipi_supported = true; +#endif /* CONFIG_SCHED_DEFERRED_AST */ + + switch (event) { + case SCHED_IPI_EVENT_SPILL: + case SCHED_IPI_EVENT_SMT_REBAL: + case SCHED_IPI_EVENT_REBALANCE: + case SCHED_IPI_EVENT_BOUND_THR: + /* + * The spill, SMT rebalance, rebalance and the bound thread + * scenarios use immediate IPIs always. + */ + ipi_type = dst_idle ? SCHED_IPI_IDLE : SCHED_IPI_IMMEDIATE; + break; + case SCHED_IPI_EVENT_PREEMPT: + /* In the preemption case, use immediate IPIs for RT threads */ + if (thread && (thread->sched_pri >= BASEPRI_RTQUEUES)) { + ipi_type = dst_idle ? SCHED_IPI_IDLE : SCHED_IPI_IMMEDIATE; + break; + } + + /* + * For Non-RT threads preemption, + * If the core is active, use immediate IPIs. + * If the core is idle, use deferred IPIs if supported; otherwise immediate IPI. + */ + if (deferred_ipi_supported && dst_idle) { + return sched_ipi_deferred_policy(pset, dst, event); + } + ipi_type = dst_idle ? SCHED_IPI_IDLE : SCHED_IPI_IMMEDIATE; + break; + default: + panic("Unrecognized scheduler IPI event type %d", event); + } + assert(ipi_type != SCHED_IPI_NONE); + return ipi_type; +} + +void +sched_ipi_perform(processor_t dst, sched_ipi_type_t ipi) +{ + switch (ipi) { + case SCHED_IPI_NONE: + break; + case SCHED_IPI_IDLE: + machine_signal_idle(dst); + break; + case SCHED_IPI_IMMEDIATE: + cause_ast_check(dst); + break; + case SCHED_IPI_DEFERRED: + machine_signal_idle_deferred(dst); + break; + default: + panic("Unrecognized scheduler IPI type: %d", ipi); + } +} + +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + +boolean_t +priority_is_urgent(int priority) +{ + return bitmap_test(sched_preempt_pri, priority) ? TRUE : FALSE; +} + +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + +/* + * processor_setrun: + * + * Dispatch a thread for execution on a + * processor. + * + * Thread must be locked. Associated pset must + * be locked, and is returned unlocked. + */ +static void +processor_setrun( + processor_t processor, + thread_t thread, + integer_t options) +{ + processor_set_t pset = processor->processor_set; + pset_assert_locked(pset); + ast_t preempt; + enum { eExitIdle, eInterruptRunning, eDoNothing } ipi_action = eDoNothing; + + sched_ipi_type_t ipi_type = SCHED_IPI_NONE; + + thread->chosen_processor = processor; + + /* + * Set preemption mode. + */ +#if defined(CONFIG_SCHED_DEFERRED_AST) + /* TODO: Do we need to care about urgency (see rdar://problem/20136239)? */ +#endif + if (SCHED(priority_is_urgent)(thread->sched_pri) && thread->sched_pri > processor->current_pri) { + preempt = (AST_PREEMPT | AST_URGENT); + } else if (processor->current_is_eagerpreempt) { + preempt = (AST_PREEMPT | AST_URGENT); + } else if ((thread->sched_mode == TH_MODE_TIMESHARE) && (thread->sched_pri < thread->base_pri)) { + if (SCHED(priority_is_urgent)(thread->base_pri) && thread->sched_pri > processor->current_pri) { + preempt = (options & SCHED_PREEMPT)? AST_PREEMPT: AST_NONE; + } else { + preempt = AST_NONE; + } + } else { + preempt = (options & SCHED_PREEMPT)? AST_PREEMPT: AST_NONE; + } + + if ((options & (SCHED_PREEMPT | SCHED_REBALANCE)) == (SCHED_PREEMPT | SCHED_REBALANCE)) { + /* + * Having gone to the trouble of forcing this thread off a less preferred core, + * we should force the preferable core to reschedule immediately to give this + * thread a chance to run instead of just sitting on the run queue where + * it may just be stolen back by the idle core we just forced it off. + */ + preempt |= AST_PREEMPT; + } + + SCHED(processor_enqueue)(processor, thread, options); + sched_update_pset_load_average(pset, 0); + + if (preempt != AST_NONE) { + if (processor->state == PROCESSOR_IDLE) { + processor_state_update_from_thread(processor, thread); + processor->deadline = UINT64_MAX; + pset_update_processor_state(pset, processor, PROCESSOR_DISPATCHING); + ipi_action = eExitIdle; + } else if (processor->state == PROCESSOR_DISPATCHING) { + if (processor->current_pri < thread->sched_pri) { + processor_state_update_from_thread(processor, thread); + processor->deadline = UINT64_MAX; + } + } else if ((processor->state == PROCESSOR_RUNNING || + processor->state == PROCESSOR_SHUTDOWN) && + (thread->sched_pri >= processor->current_pri)) { + ipi_action = eInterruptRunning; + } + } else { + /* + * New thread is not important enough to preempt what is running, but + * special processor states may need special handling + */ + if (processor->state == PROCESSOR_SHUTDOWN && + thread->sched_pri >= processor->current_pri) { + ipi_action = eInterruptRunning; + } else if (processor->state == PROCESSOR_IDLE) { + processor_state_update_from_thread(processor, thread); + processor->deadline = UINT64_MAX; + pset_update_processor_state(pset, processor, PROCESSOR_DISPATCHING); + + ipi_action = eExitIdle; + } + } + + if (ipi_action != eDoNothing) { + if (processor == current_processor()) { + if ((preempt = csw_check_locked(processor->active_thread, processor, pset, AST_NONE)) != AST_NONE) { + ast_on(preempt); + } + + if ((preempt & AST_URGENT) == AST_URGENT) { + bit_set(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id); + } else { + bit_clear(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id); + } + + if ((preempt & AST_PREEMPT) == AST_PREEMPT) { + bit_set(pset->pending_AST_PREEMPT_cpu_mask, processor->cpu_id); + } else { + bit_clear(pset->pending_AST_PREEMPT_cpu_mask, processor->cpu_id); + } + } else { + sched_ipi_event_t event = (options & SCHED_REBALANCE) ? SCHED_IPI_EVENT_REBALANCE : SCHED_IPI_EVENT_PREEMPT; + ipi_type = sched_ipi_action(processor, thread, (ipi_action == eExitIdle), event); + } + } + pset_unlock(pset); + sched_ipi_perform(processor, ipi_type); +} + +/* + * choose_next_pset: + * + * Return the next sibling pset containing + * available processors. + * + * Returns the original pset if none other is + * suitable. + */ +static processor_set_t +choose_next_pset( + processor_set_t pset) +{ + processor_set_t nset = pset; + + do { + nset = next_pset(nset); + } while (nset->online_processor_count < 1 && nset != pset); + + return nset; +} + +inline static processor_set_t +change_locked_pset(processor_set_t current_pset, processor_set_t new_pset) +{ + if (current_pset != new_pset) { + pset_unlock(current_pset); + pset_lock(new_pset); + } + + return new_pset; +} + +/* + * choose_processor: + * + * Choose a processor for the thread, beginning at + * the pset. Accepts an optional processor hint in + * the pset. + * + * Returns a processor, possibly from a different pset. + * + * The thread must be locked. The pset must be locked, + * and the resulting pset is locked on return. + */ +processor_t +choose_processor( + processor_set_t starting_pset, + processor_t processor, + thread_t thread) +{ + processor_set_t pset = starting_pset; + processor_set_t nset; + + assert(thread->sched_pri <= BASEPRI_RTQUEUES); + + /* + * Prefer the hinted processor, when appropriate. + */ + + /* Fold last processor hint from secondary processor to its primary */ + if (processor != PROCESSOR_NULL) { + processor = processor->processor_primary; + } + + /* + * Only consult platform layer if pset is active, which + * it may not be in some cases when a multi-set system + * is going to sleep. + */ + if (pset->online_processor_count) { + if ((processor == PROCESSOR_NULL) || (processor->processor_set == pset && processor->state == PROCESSOR_IDLE)) { + processor_t mc_processor = machine_choose_processor(pset, processor); + if (mc_processor != PROCESSOR_NULL) { + processor = mc_processor->processor_primary; + } + } + } + + /* + * At this point, we may have a processor hint, and we may have + * an initial starting pset. If the hint is not in the pset, or + * if the hint is for a processor in an invalid state, discard + * the hint. + */ + if (processor != PROCESSOR_NULL) { + if (processor->processor_set != pset) { + processor = PROCESSOR_NULL; + } else if (!processor->is_recommended) { + processor = PROCESSOR_NULL; + } else { + switch (processor->state) { + case PROCESSOR_START: + case PROCESSOR_SHUTDOWN: + case PROCESSOR_OFF_LINE: + /* + * Hint is for a processor that cannot support running new threads. + */ + processor = PROCESSOR_NULL; + break; + case PROCESSOR_IDLE: + /* + * Hint is for an idle processor. Assume it is no worse than any other + * idle processor. The platform layer had an opportunity to provide + * the "least cost idle" processor above. + */ + if ((thread->sched_pri < BASEPRI_RTQUEUES) || processor_is_fast_track_candidate_for_realtime_thread(pset, processor)) { + return processor; + } + processor = PROCESSOR_NULL; + break; + case PROCESSOR_RUNNING: + case PROCESSOR_DISPATCHING: + /* + * Hint is for an active CPU. This fast-path allows + * realtime threads to preempt non-realtime threads + * to regain their previous executing processor. + */ + if ((thread->sched_pri >= BASEPRI_RTQUEUES) && + processor_is_fast_track_candidate_for_realtime_thread(pset, processor)) { + return processor; + } + + /* Otherwise, use hint as part of search below */ + break; + default: + processor = PROCESSOR_NULL; + break; + } + } + } + + /* + * Iterate through the processor sets to locate + * an appropriate processor. Seed results with + * a last-processor hint, if available, so that + * a search must find something strictly better + * to replace it. + * + * A primary/secondary pair of SMT processors are + * "unpaired" if the primary is busy but its + * corresponding secondary is idle (so the physical + * core has full use of its resources). + */ + + integer_t lowest_priority = MAXPRI + 1; + integer_t lowest_secondary_priority = MAXPRI + 1; + integer_t lowest_unpaired_primary_priority = MAXPRI + 1; + integer_t lowest_idle_secondary_priority = MAXPRI + 1; + integer_t lowest_count = INT_MAX; + uint64_t furthest_deadline = 1; + processor_t lp_processor = PROCESSOR_NULL; + processor_t lp_unpaired_primary_processor = PROCESSOR_NULL; + processor_t lp_idle_secondary_processor = PROCESSOR_NULL; + processor_t lp_paired_secondary_processor = PROCESSOR_NULL; + processor_t lc_processor = PROCESSOR_NULL; + processor_t fd_processor = PROCESSOR_NULL; + + if (processor != PROCESSOR_NULL) { + /* All other states should be enumerated above. */ + assert(processor->state == PROCESSOR_RUNNING || processor->state == PROCESSOR_DISPATCHING); + + lowest_priority = processor->current_pri; + lp_processor = processor; + + if (processor->current_pri >= BASEPRI_RTQUEUES) { + furthest_deadline = processor->deadline; + fd_processor = processor; + } + + lowest_count = SCHED(processor_runq_count)(processor); + lc_processor = processor; + } + + if (thread->sched_pri >= BASEPRI_RTQUEUES) { + pset_node_t node = pset->node; + int consider_secondaries = (!pset->is_SMT) || (bit_count(node->pset_map) == 1) || (node->pset_non_rt_primary_map == 0); + for (; consider_secondaries < 2; consider_secondaries++) { + pset = change_locked_pset(pset, starting_pset); + do { + processor = choose_processor_for_realtime_thread(pset, PROCESSOR_NULL, consider_secondaries); + if (processor) { + return processor; + } + + /* NRG Collect processor stats for furthest deadline etc. here */ + + nset = next_pset(pset); + + if (nset != starting_pset) { + pset = change_locked_pset(pset, nset); + } + } while (nset != starting_pset); + } + /* Or we could just let it change to starting_pset in the loop above */ + pset = change_locked_pset(pset, starting_pset); + } + + do { + /* + * Choose an idle processor, in pset traversal order + */ + + uint64_t idle_primary_map = (pset->cpu_state_map[PROCESSOR_IDLE] & + pset->primary_map & + pset->recommended_bitmask); + + /* there shouldn't be a pending AST if the processor is idle */ + assert((idle_primary_map & pset->pending_AST_URGENT_cpu_mask) == 0); + + int cpuid = lsb_first(idle_primary_map); + if (cpuid >= 0) { + processor = processor_array[cpuid]; + return processor; + } + + /* + * Otherwise, enumerate active and idle processors to find primary candidates + * with lower priority/etc. + */ + + uint64_t active_map = ((pset->cpu_state_map[PROCESSOR_RUNNING] | pset->cpu_state_map[PROCESSOR_DISPATCHING]) & + pset->recommended_bitmask & + ~pset->pending_AST_URGENT_cpu_mask); + + if (SCHED(priority_is_urgent)(thread->sched_pri) == FALSE) { + active_map &= ~pset->pending_AST_PREEMPT_cpu_mask; + } + + active_map = bit_ror64(active_map, (pset->last_chosen + 1)); + for (int rotid = lsb_first(active_map); rotid >= 0; rotid = lsb_next(active_map, rotid)) { + cpuid = ((rotid + pset->last_chosen + 1) & 63); + processor = processor_array[cpuid]; + + integer_t cpri = processor->current_pri; + processor_t primary = processor->processor_primary; + if (primary != processor) { + /* If primary is running a NO_SMT thread, don't choose its secondary */ + if (!((primary->state == PROCESSOR_RUNNING) && processor_active_thread_no_smt(primary))) { + if (cpri < lowest_secondary_priority) { + lowest_secondary_priority = cpri; + lp_paired_secondary_processor = processor; + } + } + } else { + if (cpri < lowest_priority) { + lowest_priority = cpri; + lp_processor = processor; + } + } + + if ((cpri >= BASEPRI_RTQUEUES) && (processor->deadline > furthest_deadline)) { + furthest_deadline = processor->deadline; + fd_processor = processor; + } + + integer_t ccount = SCHED(processor_runq_count)(processor); + if (ccount < lowest_count) { + lowest_count = ccount; + lc_processor = processor; + } + } + + /* + * For SMT configs, these idle secondary processors must have active primary. Otherwise + * the idle primary would have short-circuited the loop above + */ + uint64_t idle_secondary_map = (pset->cpu_state_map[PROCESSOR_IDLE] & + ~pset->primary_map & + pset->recommended_bitmask); + + /* there shouldn't be a pending AST if the processor is idle */ + assert((idle_secondary_map & pset->pending_AST_URGENT_cpu_mask) == 0); + assert((idle_secondary_map & pset->pending_AST_PREEMPT_cpu_mask) == 0); + + for (cpuid = lsb_first(idle_secondary_map); cpuid >= 0; cpuid = lsb_next(idle_secondary_map, cpuid)) { + processor = processor_array[cpuid]; + + processor_t cprimary = processor->processor_primary; + + integer_t primary_pri = cprimary->current_pri; + + /* + * TODO: This should also make the same decisions + * as secondary_can_run_realtime_thread + * + * TODO: Keep track of the pending preemption priority + * of the primary to make this more accurate. + */ + + /* If the primary is running a no-smt thread, then don't choose its secondary */ + if (cprimary->state == PROCESSOR_RUNNING && + processor_active_thread_no_smt(cprimary)) { + continue; + } + + /* + * Find the idle secondary processor with the lowest priority primary + * + * We will choose this processor as a fallback if we find no better + * primary to preempt. + */ + if (primary_pri < lowest_idle_secondary_priority) { + lp_idle_secondary_processor = processor; + lowest_idle_secondary_priority = primary_pri; + } + + /* Find the the lowest priority active primary with idle secondary */ + if (primary_pri < lowest_unpaired_primary_priority) { + /* If the primary processor is offline or starting up, it's not a candidate for this path */ + if (cprimary->state != PROCESSOR_RUNNING && + cprimary->state != PROCESSOR_DISPATCHING) { + continue; + } + + if (!cprimary->is_recommended) { + continue; + } + + /* if the primary is pending preemption, don't try to re-preempt it */ + if (bit_test(pset->pending_AST_URGENT_cpu_mask, cprimary->cpu_id)) { + continue; + } + + if (SCHED(priority_is_urgent)(thread->sched_pri) == FALSE && + bit_test(pset->pending_AST_PREEMPT_cpu_mask, cprimary->cpu_id)) { + continue; + } + + lowest_unpaired_primary_priority = primary_pri; + lp_unpaired_primary_processor = cprimary; + } + } + + /* + * We prefer preempting a primary processor over waking up its secondary. + * The secondary will then be woken up by the preempted thread. + */ + if (thread->sched_pri > lowest_unpaired_primary_priority) { + pset->last_chosen = lp_unpaired_primary_processor->cpu_id; + return lp_unpaired_primary_processor; + } + + /* + * We prefer preempting a lower priority active processor over directly + * waking up an idle secondary. + * The preempted thread will then find the idle secondary. + */ + if (thread->sched_pri > lowest_priority) { + pset->last_chosen = lp_processor->cpu_id; + return lp_processor; + } + + if (thread->sched_pri >= BASEPRI_RTQUEUES) { + /* + * For realtime threads, the most important aspect is + * scheduling latency, so we will pick an active + * secondary processor in this pset, or preempt + * another RT thread with a further deadline before + * going to the next pset. + */ + + if (sched_allow_rt_smt && (thread->sched_pri > lowest_secondary_priority)) { + pset->last_chosen = lp_paired_secondary_processor->cpu_id; + return lp_paired_secondary_processor; + } + + if (thread->realtime.deadline < furthest_deadline) { + return fd_processor; + } + } + + /* + * lc_processor is used to indicate the best processor set run queue + * on which to enqueue a thread when all available CPUs are busy with + * higher priority threads, so try to make sure it is initialized. + */ + if (lc_processor == PROCESSOR_NULL) { + cpumap_t available_map = ((pset->cpu_state_map[PROCESSOR_IDLE] | + pset->cpu_state_map[PROCESSOR_RUNNING] | + pset->cpu_state_map[PROCESSOR_DISPATCHING]) & + pset->recommended_bitmask); + cpuid = lsb_first(available_map); + if (cpuid >= 0) { + lc_processor = processor_array[cpuid]; + lowest_count = SCHED(processor_runq_count)(lc_processor); + } + } + + /* + * Move onto the next processor set. + * + * If all primary processors in this pset are running a higher + * priority thread, move on to next pset. Only when we have + * exhausted the search for primary processors do we + * fall back to secondaries. + */ + nset = next_pset(pset); + + if (nset != starting_pset) { + pset = change_locked_pset(pset, nset); + } + } while (nset != starting_pset); + + /* + * Make sure that we pick a running processor, + * and that the correct processor set is locked. + * Since we may have unlocked the candidate processor's + * pset, it may have changed state. + * + * All primary processors are running a higher priority + * thread, so the only options left are enqueuing on + * the secondary processor that would perturb the least priority + * primary, or the least busy primary. + */ + boolean_t fallback_processor = false; + do { + /* lowest_priority is evaluated in the main loops above */ + if (lp_idle_secondary_processor != PROCESSOR_NULL) { + processor = lp_idle_secondary_processor; + lp_idle_secondary_processor = PROCESSOR_NULL; + } else if (lp_paired_secondary_processor != PROCESSOR_NULL) { + processor = lp_paired_secondary_processor; + lp_paired_secondary_processor = PROCESSOR_NULL; + } else if (lc_processor != PROCESSOR_NULL) { + processor = lc_processor; + lc_processor = PROCESSOR_NULL; + } else { + /* + * All processors are executing higher priority threads, and + * the lowest_count candidate was not usable. + * + * For AMP platforms running the clutch scheduler always + * return a processor from the requested pset to allow the + * thread to be enqueued in the correct runq. For non-AMP + * platforms, simply return the master_processor. + */ + fallback_processor = true; +#if CONFIG_SCHED_EDGE + processor = processor_array[lsb_first(starting_pset->primary_map)]; +#else /* CONFIG_SCHED_EDGE */ + processor = master_processor; +#endif /* CONFIG_SCHED_EDGE */ + } + + /* + * Check that the correct processor set is + * returned locked. + */ + pset = change_locked_pset(pset, processor->processor_set); + + /* + * We must verify that the chosen processor is still available. + * The cases where we pick the master_processor or the fallback + * processor are execptions, since we may need enqueue a thread + * on its runqueue if this is the last remaining processor + * during pset shutdown. + * + * would really help here since it + * gets rid of the weird last processor SHUTDOWN case where + * the pset is still schedulable. + */ + if (processor != master_processor && (fallback_processor == false) && (processor->state == PROCESSOR_SHUTDOWN || processor->state == PROCESSOR_OFF_LINE)) { + processor = PROCESSOR_NULL; + } + } while (processor == PROCESSOR_NULL); + + pset->last_chosen = processor->cpu_id; + return processor; +} + +/* + * Default implementation of SCHED(choose_node)() + * for single node systems + */ +pset_node_t +sched_choose_node(__unused thread_t thread) +{ + return &pset_node0; +} + +/* + * choose_starting_pset: + * + * Choose a starting processor set for the thread. + * May return a processor hint within the pset. + * + * Returns a starting processor set, to be used by + * choose_processor. + * + * The thread must be locked. The resulting pset is unlocked on return, + * and is chosen without taking any pset locks. + */ +processor_set_t +choose_starting_pset(pset_node_t node, thread_t thread, processor_t *processor_hint) +{ + processor_set_t pset; + processor_t processor = PROCESSOR_NULL; + + if (thread->affinity_set != AFFINITY_SET_NULL) { + /* + * Use affinity set policy hint. + */ + pset = thread->affinity_set->aset_pset; + } else if (thread->last_processor != PROCESSOR_NULL) { + /* + * Simple (last processor) affinity case. + */ + processor = thread->last_processor; + pset = processor->processor_set; + } else { + /* + * No Affinity case: + * + * Utilitize a per task hint to spread threads + * among the available processor sets. + * NRG this seems like the wrong thing to do. + * See also task->pset_hint = pset in thread_setrun() + */ + task_t task = thread->task; + + pset = task->pset_hint; + if (pset == PROCESSOR_SET_NULL) { + pset = current_processor()->processor_set; + } + + pset = choose_next_pset(pset); + } + + if (!bit_test(node->pset_map, pset->pset_id)) { + /* pset is not from this node so choose one that is */ + int id = lsb_first(node->pset_map); + assert(id >= 0); + pset = pset_array[id]; + } + + if (bit_count(node->pset_map) == 1) { + /* Only a single pset in this node */ + goto out; + } + + bool avoid_cpu0 = false; + +#if defined(__x86_64__) + if ((thread->sched_pri >= BASEPRI_RTQUEUES) && sched_avoid_cpu0) { + /* Avoid the pset containing cpu0 */ + avoid_cpu0 = true; + /* Assert that cpu0 is in pset0. I expect this to be true on __x86_64__ */ + assert(bit_test(pset_array[0]->cpu_bitmask, 0)); + } +#endif + + if (thread->sched_pri >= BASEPRI_RTQUEUES) { + pset_map_t rt_target_map = atomic_load(&node->pset_non_rt_primary_map); + if ((avoid_cpu0 && pset->pset_id == 0) || !bit_test(rt_target_map, pset->pset_id)) { + if (avoid_cpu0) { + rt_target_map = bit_ror64(rt_target_map, 1); + } + int rotid = lsb_first(rt_target_map); + if (rotid >= 0) { + int id = avoid_cpu0 ? ((rotid + 1) & 63) : rotid; + pset = pset_array[id]; + goto out; + } + } + if (!pset->is_SMT || !sched_allow_rt_smt) { + /* All psets are full of RT threads - fall back to choose processor to find the furthest deadline RT thread */ + goto out; + } + rt_target_map = atomic_load(&node->pset_non_rt_map); + if ((avoid_cpu0 && pset->pset_id == 0) || !bit_test(rt_target_map, pset->pset_id)) { + if (avoid_cpu0) { + rt_target_map = bit_ror64(rt_target_map, 1); + } + int rotid = lsb_first(rt_target_map); + if (rotid >= 0) { + int id = avoid_cpu0 ? ((rotid + 1) & 63) : rotid; + pset = pset_array[id]; + goto out; + } + } + /* All psets are full of RT threads - fall back to choose processor to find the furthest deadline RT thread */ + } else { + pset_map_t idle_map = atomic_load(&node->pset_idle_map); + if (!bit_test(idle_map, pset->pset_id)) { + int next_idle_pset_id = lsb_first(idle_map); + if (next_idle_pset_id >= 0) { + pset = pset_array[next_idle_pset_id]; + } + } + } + +out: + if ((processor != PROCESSOR_NULL) && (processor->processor_set != pset)) { + processor = PROCESSOR_NULL; + } + if (processor != PROCESSOR_NULL) { + *processor_hint = processor; + } + + return pset; +} + +/* + * thread_setrun: + * + * Dispatch thread for execution, onto an idle + * processor or run queue, and signal a preemption + * as appropriate. + * + * Thread must be locked. + */ +void +thread_setrun( + thread_t thread, + sched_options_t options) +{ + processor_t processor; + processor_set_t pset; + + assert((thread->state & (TH_RUN | TH_WAIT | TH_UNINT | TH_TERMINATE | TH_TERMINATE2)) == TH_RUN); + assert(thread->runq == PROCESSOR_NULL); + + /* + * Update priority if needed. + */ + if (SCHED(can_update_priority)(thread)) { + SCHED(update_priority)(thread); + } + + thread->sfi_class = sfi_thread_classify(thread); + + assert(thread->runq == PROCESSOR_NULL); + + if (thread->bound_processor == PROCESSOR_NULL) { + /* + * Unbound case. + */ + processor_t processor_hint = PROCESSOR_NULL; + pset_node_t node = SCHED(choose_node)(thread); + processor_set_t starting_pset = choose_starting_pset(node, thread, &processor_hint); + + pset_lock(starting_pset); + + processor = SCHED(choose_processor)(starting_pset, processor_hint, thread); + pset = processor->processor_set; + task_t task = thread->task; + task->pset_hint = pset; /* NRG this is done without holding the task lock */ + + SCHED_DEBUG_CHOOSE_PROCESSOR_KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHOOSE_PROCESSOR) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), (uintptr_t)-1, processor->cpu_id, processor->state, 0); + } else { + /* + * Bound case: + * + * Unconditionally dispatch on the processor. + */ + processor = thread->bound_processor; + pset = processor->processor_set; + pset_lock(pset); + + SCHED_DEBUG_CHOOSE_PROCESSOR_KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHOOSE_PROCESSOR) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), (uintptr_t)-2, processor->cpu_id, processor->state, 0); + } + + /* + * Dispatch the thread on the chosen processor. + * TODO: This should be based on sched_mode, not sched_pri + */ + if (thread->sched_pri >= BASEPRI_RTQUEUES) { + realtime_setrun(processor, thread); + } else { + processor_setrun(processor, thread, options); + } + /* pset is now unlocked */ + if (thread->bound_processor == PROCESSOR_NULL) { + SCHED(check_spill)(pset, thread); + } +} + +processor_set_t +task_choose_pset( + task_t task) +{ + processor_set_t pset = task->pset_hint; + + if (pset != PROCESSOR_SET_NULL) { + pset = choose_next_pset(pset); + } + + return pset; +} + +/* + * Check for a preemption point in + * the current context. + * + * Called at splsched with thread locked. + */ +ast_t +csw_check( + thread_t thread, + processor_t processor, + ast_t check_reason) +{ + processor_set_t pset = processor->processor_set; + + assert(thread == processor->active_thread); + + pset_lock(pset); + + processor_state_update_from_thread(processor, thread); + + ast_t preempt = csw_check_locked(thread, processor, pset, check_reason); + + /* Acknowledge the IPI if we decided not to preempt */ + + if ((preempt & AST_URGENT) == 0) { + bit_clear(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id); + } + + if ((preempt & AST_PREEMPT) == 0) { + bit_clear(pset->pending_AST_PREEMPT_cpu_mask, processor->cpu_id); + } + + pset_unlock(pset); + + return preempt; +} + +/* + * Check for preemption at splsched with + * pset and thread locked + */ +ast_t +csw_check_locked( + thread_t thread, + processor_t processor, + processor_set_t pset, + ast_t check_reason) +{ + ast_t result; + + if (processor->first_timeslice) { + if (rt_runq_count(pset) > 0) { + return check_reason | AST_PREEMPT | AST_URGENT; + } + } else { + if (rt_runq_count(pset) > 0) { + if (BASEPRI_RTQUEUES > processor->current_pri) { + return check_reason | AST_PREEMPT | AST_URGENT; + } else { + return check_reason | AST_PREEMPT; + } + } + } + + /* + * If the current thread is running on a processor that is no longer recommended, + * urgently preempt it, at which point thread_select() should + * try to idle the processor and re-dispatch the thread to a recommended processor. + */ + if (!processor->is_recommended) { + return check_reason | AST_PREEMPT | AST_URGENT; + } + + result = SCHED(processor_csw_check)(processor); + if (result != AST_NONE) { + return check_reason | result | (thread_is_eager_preempt(thread) ? AST_URGENT : AST_NONE); + } + + /* + * Same for avoid-processor + * + * TODO: Should these set AST_REBALANCE? + */ + if (SCHED(avoid_processor_enabled) && SCHED(thread_avoid_processor)(processor, thread)) { + return check_reason | AST_PREEMPT; + } + + /* + * Even though we could continue executing on this processor, a + * secondary SMT core should try to shed load to another primary core. + * + * TODO: Should this do the same check that thread_select does? i.e. + * if no bound threads target this processor, and idle primaries exist, preempt + * The case of RT threads existing is already taken care of above + */ + + if (processor->current_pri < BASEPRI_RTQUEUES && + processor->processor_primary != processor) { + return check_reason | AST_PREEMPT; + } + + if (thread->state & TH_SUSP) { + return check_reason | AST_PREEMPT; + } + +#if CONFIG_SCHED_SFI + /* + * Current thread may not need to be preempted, but maybe needs + * an SFI wait? + */ + result = sfi_thread_needs_ast(thread, NULL); + if (result != AST_NONE) { + return check_reason | result; + } +#endif + + return AST_NONE; +} + +/* + * Handle preemption IPI or IPI in response to setting an AST flag + * Triggered by cause_ast_check + * Called at splsched + */ +void +ast_check(processor_t processor) +{ + if (processor->state != PROCESSOR_RUNNING && + processor->state != PROCESSOR_SHUTDOWN) { + return; + } + + thread_t thread = processor->active_thread; + + assert(thread == current_thread()); + + thread_lock(thread); + + /* + * Propagate thread ast to processor. + * (handles IPI in response to setting AST flag) + */ + ast_propagate(thread); + + /* + * Stash the old urgency and perfctl values to find out if + * csw_check updates them. + */ + thread_urgency_t old_urgency = processor->current_urgency; + perfcontrol_class_t old_perfctl_class = processor->current_perfctl_class; + + ast_t preempt; + + if ((preempt = csw_check(thread, processor, AST_NONE)) != AST_NONE) { + ast_on(preempt); + } + + if (old_urgency != processor->current_urgency) { + /* + * Urgency updates happen with the thread lock held (ugh). + * TODO: This doesn't notice QoS changes... + */ + uint64_t urgency_param1, urgency_param2; + + thread_urgency_t urgency = thread_get_urgency(thread, &urgency_param1, &urgency_param2); + thread_tell_urgency(urgency, urgency_param1, urgency_param2, 0, thread); + } + + thread_unlock(thread); + + if (old_perfctl_class != processor->current_perfctl_class) { + /* + * We updated the perfctl class of this thread from another core. + * Let CLPC know that the currently running thread has a new + * class. + */ + + machine_switch_perfcontrol_state_update(PERFCONTROL_ATTR_UPDATE, + mach_approximate_time(), 0, thread); + } +} + + +/* + * set_sched_pri: + * + * Set the scheduled priority of the specified thread. + * + * This may cause the thread to change queues. + * + * Thread must be locked. + */ +void +set_sched_pri( + thread_t thread, + int16_t new_priority, + set_sched_pri_options_t options) +{ + bool is_current_thread = (thread == current_thread()); + bool removed_from_runq = false; + bool lazy_update = ((options & SETPRI_LAZY) == SETPRI_LAZY); + + int16_t old_priority = thread->sched_pri; + + /* If we're already at this priority, no need to mess with the runqueue */ + if (new_priority == old_priority) { +#if CONFIG_SCHED_CLUTCH + /* For the first thread in the system, the priority is correct but + * th_sched_bucket is still TH_BUCKET_RUN. Since the clutch + * scheduler relies on the bucket being set for all threads, update + * its bucket here. + */ + if (thread->th_sched_bucket == TH_BUCKET_RUN) { + assert(is_current_thread); + SCHED(update_thread_bucket)(thread); + } +#endif /* CONFIG_SCHED_CLUTCH */ + + return; + } + + if (is_current_thread) { + assert(thread->state & TH_RUN); + assert(thread->runq == PROCESSOR_NULL); + } else { + removed_from_runq = thread_run_queue_remove(thread); + } + + thread->sched_pri = new_priority; + +#if CONFIG_SCHED_CLUTCH + /* + * Since for the clutch scheduler, the thread's bucket determines its runq + * in the hierarchy it is important to update the bucket when the thread + * lock is held and the thread has been removed from the runq hierarchy. + */ + SCHED(update_thread_bucket)(thread); + +#endif /* CONFIG_SCHED_CLUTCH */ + + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHANGE_PRIORITY), + (uintptr_t)thread_tid(thread), + thread->base_pri, + thread->sched_pri, + thread->sched_usage, + 0); + + if (removed_from_runq) { + thread_run_queue_reinsert(thread, SCHED_PREEMPT | SCHED_TAILQ); + } else if (is_current_thread) { + processor_t processor = thread->last_processor; + assert(processor == current_processor()); + + thread_urgency_t old_urgency = processor->current_urgency; + + /* + * When dropping in priority, check if the thread no longer belongs on core. + * If a thread raises its own priority, don't aggressively rebalance it. + * + * + * csw_check does a processor_state_update_from_thread, but + * we should do our own if we're being lazy. + */ + if (!lazy_update && new_priority < old_priority) { + ast_t preempt; + + if ((preempt = csw_check(thread, processor, AST_NONE)) != AST_NONE) { + ast_on(preempt); + } + } else { + processor_state_update_from_thread(processor, thread); + } + + /* + * set_sched_pri doesn't alter RT params. We expect direct base priority/QoS + * class alterations from user space to occur relatively infrequently, hence + * those are lazily handled. QoS classes have distinct priority bands, and QoS + * inheritance is expected to involve priority changes. + */ + if (processor->current_urgency != old_urgency) { + uint64_t urgency_param1, urgency_param2; + + thread_urgency_t new_urgency = thread_get_urgency(thread, + &urgency_param1, &urgency_param2); + + thread_tell_urgency(new_urgency, urgency_param1, + urgency_param2, 0, thread); + } + + /* TODO: only call this if current_perfctl_class changed */ + uint64_t ctime = mach_approximate_time(); + machine_thread_going_on_core(thread, processor->current_urgency, 0, 0, ctime); + } else if (thread->state & TH_RUN) { + processor_t processor = thread->last_processor; + + if (!lazy_update && + processor != PROCESSOR_NULL && + processor != current_processor() && + processor->active_thread == thread) { + cause_ast_check(processor); + } + } +} + +/* + * thread_run_queue_remove_for_handoff + * + * Pull a thread or its (recursive) push target out of the runqueue + * so that it is ready for thread_run() + * + * Called at splsched + * + * Returns the thread that was pulled or THREAD_NULL if no thread could be pulled. + * This may be different than the thread that was passed in. + */ +thread_t +thread_run_queue_remove_for_handoff(thread_t thread) +{ + thread_t pulled_thread = THREAD_NULL; + + thread_lock(thread); + + /* + * Check that the thread is not bound to a different processor, + * NO_SMT flag is not set on the thread, cluster type of + * processor matches with thread if the thread is pinned to a + * particular cluster and that realtime is not involved. + * + * Next, pull it off its run queue. If it doesn't come, it's not eligible. + */ + processor_t processor = current_processor(); + if ((thread->bound_processor == PROCESSOR_NULL || thread->bound_processor == processor) + && (!thread_no_smt(thread)) + && (processor->current_pri < BASEPRI_RTQUEUES) + && (thread->sched_pri < BASEPRI_RTQUEUES) +#if __AMP__ + && ((!(thread->sched_flags & TH_SFLAG_PCORE_ONLY)) || + processor->processor_set->pset_cluster_type == PSET_AMP_P) + && ((!(thread->sched_flags & TH_SFLAG_ECORE_ONLY)) || + processor->processor_set->pset_cluster_type == PSET_AMP_E) +#endif /* __AMP__ */ + ) { + if (thread_run_queue_remove(thread)) { + pulled_thread = thread; + } + } + + thread_unlock(thread); + + return pulled_thread; +} + +/* + * thread_prepare_for_handoff + * + * Make the thread ready for handoff. + * If the thread was runnable then pull it off the runq, if the thread could + * not be pulled, return NULL. + * + * If the thread was woken up from wait for handoff, make sure it is not bound to + * different processor. + * + * Called at splsched + * + * Returns the thread that was pulled or THREAD_NULL if no thread could be pulled. + * This may be different than the thread that was passed in. + */ +thread_t +thread_prepare_for_handoff(thread_t thread, thread_handoff_option_t option) +{ + thread_t pulled_thread = THREAD_NULL; + + if (option & THREAD_HANDOFF_SETRUN_NEEDED) { + processor_t processor = current_processor(); + thread_lock(thread); + + /* + * Check that the thread is not bound to a different processor, + * NO_SMT flag is not set on the thread and cluster type of + * processor matches with thread if the thread is pinned to a + * particular cluster. Call setrun instead if above conditions + * are not satisfied. + */ + if ((thread->bound_processor == PROCESSOR_NULL || thread->bound_processor == processor) + && (!thread_no_smt(thread)) +#if __AMP__ + && ((!(thread->sched_flags & TH_SFLAG_PCORE_ONLY)) || + processor->processor_set->pset_cluster_type == PSET_AMP_P) + && ((!(thread->sched_flags & TH_SFLAG_ECORE_ONLY)) || + processor->processor_set->pset_cluster_type == PSET_AMP_E) +#endif /* __AMP__ */ + ) { + pulled_thread = thread; + } else { + thread_setrun(thread, SCHED_PREEMPT | SCHED_TAILQ); + } + thread_unlock(thread); + } else { + pulled_thread = thread_run_queue_remove_for_handoff(thread); + } + + return pulled_thread; +} + +/* + * thread_run_queue_remove: + * + * Remove a thread from its current run queue and + * return TRUE if successful. + * + * Thread must be locked. + * + * If thread->runq is PROCESSOR_NULL, the thread will not re-enter the + * run queues because the caller locked the thread. Otherwise + * the thread is on a run queue, but could be chosen for dispatch + * and removed by another processor under a different lock, which + * will set thread->runq to PROCESSOR_NULL. + * + * Hence the thread select path must not rely on anything that could + * be changed under the thread lock after calling this function, + * most importantly thread->sched_pri. + */ +boolean_t +thread_run_queue_remove( + thread_t thread) +{ + boolean_t removed = FALSE; + processor_t processor = thread->runq; + + if ((thread->state & (TH_RUN | TH_WAIT)) == TH_WAIT) { + /* Thread isn't runnable */ + assert(thread->runq == PROCESSOR_NULL); + return FALSE; + } + + if (processor == PROCESSOR_NULL) { + /* + * The thread is either not on the runq, + * or is in the midst of being removed from the runq. + * + * runq is set to NULL under the pset lock, not the thread + * lock, so the thread may still be in the process of being dequeued + * from the runq. It will wait in invoke for the thread lock to be + * dropped. + */ + + return FALSE; + } + + if (thread->sched_pri < BASEPRI_RTQUEUES) { + return SCHED(processor_queue_remove)(processor, thread); + } + + processor_set_t pset = processor->processor_set; + + pset_lock(pset); + + if (thread->runq != PROCESSOR_NULL) { + /* + * Thread is on the RT run queue and we have a lock on + * that run queue. + */ + + remqueue(&thread->runq_links); + SCHED_STATS_RUNQ_CHANGE(&SCHED(rt_runq)(pset)->runq_stats, rt_runq_count(pset)); + rt_runq_count_decr(pset); + + thread->runq = PROCESSOR_NULL; + + removed = TRUE; + } + + pset_unlock(pset); + + return removed; +} + +/* + * Put the thread back where it goes after a thread_run_queue_remove + * + * Thread must have been removed under the same thread lock hold + * + * thread locked, at splsched + */ +void +thread_run_queue_reinsert(thread_t thread, sched_options_t options) +{ + assert(thread->runq == PROCESSOR_NULL); + assert(thread->state & (TH_RUN)); + + thread_setrun(thread, options); +} + +void +sys_override_cpu_throttle(boolean_t enable_override) +{ + if (enable_override) { + cpu_throttle_enabled = 0; + } else { + cpu_throttle_enabled = 1; + } +} + +thread_urgency_t +thread_get_urgency(thread_t thread, uint64_t *arg1, uint64_t *arg2) +{ + uint64_t urgency_param1 = 0, urgency_param2 = 0; + + thread_urgency_t urgency; + + if (thread == NULL || (thread->state & TH_IDLE)) { + urgency_param1 = 0; + urgency_param2 = 0; + + urgency = THREAD_URGENCY_NONE; + } else if (thread->sched_mode == TH_MODE_REALTIME) { + urgency_param1 = thread->realtime.period; + urgency_param2 = thread->realtime.deadline; + + urgency = THREAD_URGENCY_REAL_TIME; + } else if (cpu_throttle_enabled && + (thread->sched_pri <= MAXPRI_THROTTLE) && + (thread->base_pri <= MAXPRI_THROTTLE)) { + /* + * Threads that are running at low priority but are not + * tagged with a specific QoS are separated out from + * the "background" urgency. Performance management + * subsystem can decide to either treat these threads + * as normal threads or look at other signals like thermal + * levels for optimal power/perf tradeoffs for a platform. + */ + boolean_t thread_lacks_qos = (proc_get_effective_thread_policy(thread, TASK_POLICY_QOS) == THREAD_QOS_UNSPECIFIED); //thread_has_qos_policy(thread); + boolean_t task_is_suppressed = (proc_get_effective_task_policy(thread->task, TASK_POLICY_SUP_ACTIVE) == 0x1); + + /* + * Background urgency applied when thread priority is + * MAXPRI_THROTTLE or lower and thread is not promoted + * and thread has a QoS specified + */ + urgency_param1 = thread->sched_pri; + urgency_param2 = thread->base_pri; + + if (thread_lacks_qos && !task_is_suppressed) { + urgency = THREAD_URGENCY_LOWPRI; + } else { + urgency = THREAD_URGENCY_BACKGROUND; + } + } else { + /* For otherwise unclassified threads, report throughput QoS parameters */ + urgency_param1 = proc_get_effective_thread_policy(thread, TASK_POLICY_THROUGH_QOS); + urgency_param2 = proc_get_effective_task_policy(thread->task, TASK_POLICY_THROUGH_QOS); + urgency = THREAD_URGENCY_NORMAL; + } + + if (arg1 != NULL) { + *arg1 = urgency_param1; + } + if (arg2 != NULL) { + *arg2 = urgency_param2; + } + + return urgency; +} + +perfcontrol_class_t +thread_get_perfcontrol_class(thread_t thread) +{ + /* Special case handling */ + if (thread->state & TH_IDLE) { + return PERFCONTROL_CLASS_IDLE; + } + if (thread->task == kernel_task) { + return PERFCONTROL_CLASS_KERNEL; + } + if (thread->sched_mode == TH_MODE_REALTIME) { + return PERFCONTROL_CLASS_REALTIME; + } + + /* perfcontrol_class based on base_pri */ + if (thread->base_pri <= MAXPRI_THROTTLE) { + return PERFCONTROL_CLASS_BACKGROUND; + } else if (thread->base_pri <= BASEPRI_UTILITY) { + return PERFCONTROL_CLASS_UTILITY; + } else if (thread->base_pri <= BASEPRI_DEFAULT) { + return PERFCONTROL_CLASS_NONUI; + } else if (thread->base_pri <= BASEPRI_FOREGROUND) { + return PERFCONTROL_CLASS_UI; + } else { + return PERFCONTROL_CLASS_ABOVEUI; + } +} + +/* + * This is the processor idle loop, which just looks for other threads + * to execute. Processor idle threads invoke this without supplying a + * current thread to idle without an asserted wait state. + * + * Returns a the next thread to execute if dispatched directly. + */ + +#if 0 +#define IDLE_KERNEL_DEBUG_CONSTANT(...) KERNEL_DEBUG_CONSTANT(__VA_ARGS__) +#else +#define IDLE_KERNEL_DEBUG_CONSTANT(...) do { } while(0) +#endif + +thread_t +processor_idle( + thread_t thread, + processor_t processor) { - spl_t s; + processor_set_t pset = processor->processor_set; - s = splsched(); - wake_lock(thread); + (void)splsched(); - while (thread->state & (TH_RUN/*|TH_UNINT*/)) { - if (thread->last_processor != PROCESSOR_NULL) - cause_ast_check(thread->last_processor); + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_IDLE) | DBG_FUNC_START, + (uintptr_t)thread_tid(thread), 0, 0, 0, 0); - thread->wake_active = TRUE; - assert_wait((event_t)&thread->wake_active, THREAD_ABORTSAFE); - wake_unlock(thread); - splx(s); + SCHED_STATS_INC(idle_transitions); + assert(processor->running_timers_active == false); - thread_block((void (*)(void))0); - if (current_thread()->wait_result != THREAD_AWAKENED) - return (FALSE); + uint64_t ctime = mach_absolute_time(); - s = splsched(); - wake_lock(thread); + timer_switch(&processor->system_state, ctime, &processor->idle_state); + processor->current_state = &processor->idle_state; + + cpu_quiescent_counter_leave(ctime); + + while (1) { + /* + * Ensure that updates to my processor and pset state, + * made by the IPI source processor before sending the IPI, + * are visible on this processor now (even though we don't + * take the pset lock yet). + */ + atomic_thread_fence(memory_order_acquire); + + if (processor->state != PROCESSOR_IDLE) { + break; + } + if (bit_test(pset->pending_AST_URGENT_cpu_mask, processor->cpu_id)) { + break; + } +#if defined(CONFIG_SCHED_DEFERRED_AST) + if (bit_test(pset->pending_deferred_AST_cpu_mask, processor->cpu_id)) { + break; + } +#endif + if (processor->is_recommended && (processor->processor_primary == processor)) { + if (rt_runq_count(pset)) { + break; + } + } else { + if (SCHED(processor_bound_count)(processor)) { + break; + } + } + + IDLE_KERNEL_DEBUG_CONSTANT( + MACHDBG_CODE(DBG_MACH_SCHED, MACH_IDLE) | DBG_FUNC_NONE, (uintptr_t)thread_tid(thread), rt_runq_count(pset), SCHED(processor_runq_count)(processor), -1, 0); + + machine_track_platform_idle(TRUE); + + machine_idle(); + /* returns with interrupts enabled */ + + machine_track_platform_idle(FALSE); + + (void)splsched(); + + /* + * Check if we should call sched_timeshare_consider_maintenance() here. + * The CPU was woken out of idle due to an interrupt and we should do the + * call only if the processor is still idle. If the processor is non-idle, + * the threads running on the processor would do the call as part of + * context swithing. + */ + if (processor->state == PROCESSOR_IDLE) { + sched_timeshare_consider_maintenance(mach_absolute_time()); + } + + IDLE_KERNEL_DEBUG_CONSTANT( + MACHDBG_CODE(DBG_MACH_SCHED, MACH_IDLE) | DBG_FUNC_NONE, (uintptr_t)thread_tid(thread), rt_runq_count(pset), SCHED(processor_runq_count)(processor), -2, 0); + + if (!SCHED(processor_queue_empty)(processor)) { + /* Secondary SMT processors respond to directed wakeups + * exclusively. Some platforms induce 'spurious' SMT wakeups. + */ + if (processor->processor_primary == processor) { + break; + } + } } - wake_unlock(thread); - splx(s); + ctime = mach_absolute_time(); + + timer_switch(&processor->idle_state, ctime, &processor->system_state); + processor->current_state = &processor->system_state; + + cpu_quiescent_counter_join(ctime); + + ast_t reason = AST_NONE; + + /* We're handling all scheduling AST's */ + ast_off(AST_SCHEDULING); + + /* + * thread_select will move the processor from dispatching to running, + * or put it in idle if there's nothing to do. + */ + thread_t current_thread = current_thread(); + + thread_lock(current_thread); + thread_t new_thread = thread_select(current_thread, processor, &reason); + thread_unlock(current_thread); + + assert(processor->running_timers_active == false); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_IDLE) | DBG_FUNC_END, + (uintptr_t)thread_tid(thread), processor->state, (uintptr_t)thread_tid(new_thread), reason, 0); + + return new_thread; +} + +/* + * Each processor has a dedicated thread which + * executes the idle loop when there is no suitable + * previous context. + * + * This continuation is entered with interrupts disabled. + */ +void +idle_thread(__assert_only void* parameter, + __unused wait_result_t result) +{ + assert(ml_get_interrupts_enabled() == FALSE); + assert(parameter == NULL); - return (TRUE); + processor_t processor = current_processor(); + + /* + * Ensure that anything running in idle context triggers + * preemption-disabled checks. + */ + disable_preemption(); + + /* + * Enable interrupts temporarily to handle any pending interrupts + * or IPIs before deciding to sleep + */ + spllo(); + + thread_t new_thread = processor_idle(THREAD_NULL, processor); + /* returns with interrupts disabled */ + + enable_preemption(); + + if (new_thread != THREAD_NULL) { + thread_run(processor->idle_thread, + idle_thread, NULL, new_thread); + /*NOTREACHED*/ + } + + thread_block(idle_thread); + /*NOTREACHED*/ } +kern_return_t +idle_thread_create( + processor_t processor) +{ + kern_return_t result; + thread_t thread; + spl_t s; + char name[MAXTHREADNAMESIZE]; + + result = kernel_thread_create(idle_thread, NULL, MAXPRI_KERNEL, &thread); + if (result != KERN_SUCCESS) { + return result; + } + + snprintf(name, sizeof(name), "idle #%d", processor->cpu_id); + thread_set_thread_name(thread, name); + + s = splsched(); + thread_lock(thread); + thread->bound_processor = processor; + processor->idle_thread = thread; + thread->sched_pri = thread->base_pri = IDLEPRI; + thread->state = (TH_RUN | TH_IDLE); + thread->options |= TH_OPT_IDLE_THREAD; + thread_unlock(thread); + splx(s); + + thread_deallocate(thread); + + return KERN_SUCCESS; +} /* - * thread_stop_wait(thread) - * Stop the thread then wait for it to block interruptibly + * sched_startup: + * + * Kicks off scheduler services. + * + * Called at splsched. */ -boolean_t -thread_stop_wait( - thread_t thread) +void +sched_startup(void) { - if (thread_stop(thread)) { - if (thread_wait(thread)) - return (TRUE); + kern_return_t result; + thread_t thread; - thread_unstop(thread); + simple_lock_init(&sched_vm_group_list_lock, 0); + +#if __arm__ || __arm64__ + simple_lock_init(&sched_recommended_cores_lock, 0); +#endif /* __arm__ || __arm64__ */ + + result = kernel_thread_start_priority((thread_continue_t)sched_init_thread, + NULL, MAXPRI_KERNEL, &thread); + if (result != KERN_SUCCESS) { + panic("sched_startup"); } - return (FALSE); + thread_deallocate(thread); + + assert_thread_magic(thread); + + /* + * Yield to the sched_init_thread once, to + * initialize our own thread after being switched + * back to. + * + * The current thread is the only other thread + * active at this point. + */ + thread_block(THREAD_CONTINUE_NULL); } +#if __arm64__ +static _Atomic uint64_t sched_perfcontrol_callback_deadline; +#endif /* __arm64__ */ + + +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + +static volatile uint64_t sched_maintenance_deadline; +static uint64_t sched_tick_last_abstime; +static uint64_t sched_tick_delta; +uint64_t sched_tick_max_delta; + /* - * Routine: clear_wait_internal + * sched_init_thread: * - * Clear the wait condition for the specified thread. - * Start the thread executing if that is appropriate. - * Arguments: - * thread thread to awaken - * result Wakeup result the thread should see - * Conditions: - * At splsched - * the thread is locked. + * Perform periodic bookkeeping functions about ten + * times per second. */ void -clear_wait_internal( - thread_t thread, - int result) +sched_timeshare_maintenance_continue(void) +{ + uint64_t sched_tick_ctime, late_time; + + struct sched_update_scan_context scan_context = { + .earliest_bg_make_runnable_time = UINT64_MAX, + .earliest_normal_make_runnable_time = UINT64_MAX, + .earliest_rt_make_runnable_time = UINT64_MAX + }; + + sched_tick_ctime = mach_absolute_time(); + + if (__improbable(sched_tick_last_abstime == 0)) { + sched_tick_last_abstime = sched_tick_ctime; + late_time = 0; + sched_tick_delta = 1; + } else { + late_time = sched_tick_ctime - sched_tick_last_abstime; + sched_tick_delta = late_time / sched_tick_interval; + /* Ensure a delta of 1, since the interval could be slightly + * smaller than the sched_tick_interval due to dispatch + * latencies. + */ + sched_tick_delta = MAX(sched_tick_delta, 1); + + /* In the event interrupt latencies or platform + * idle events that advanced the timebase resulted + * in periods where no threads were dispatched, + * cap the maximum "tick delta" at SCHED_TICK_MAX_DELTA + * iterations. + */ + sched_tick_delta = MIN(sched_tick_delta, SCHED_TICK_MAX_DELTA); + + sched_tick_last_abstime = sched_tick_ctime; + sched_tick_max_delta = MAX(sched_tick_delta, sched_tick_max_delta); + } + + scan_context.sched_tick_last_abstime = sched_tick_last_abstime; + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_MAINTENANCE) | DBG_FUNC_START, + sched_tick_delta, late_time, 0, 0, 0); + + /* Add a number of pseudo-ticks corresponding to the elapsed interval + * This could be greater than 1 if substantial intervals where + * all processors are idle occur, which rarely occurs in practice. + */ + + sched_tick += sched_tick_delta; + + update_vm_info(); + + /* + * Compute various averages. + */ + compute_averages(sched_tick_delta); + + /* + * Scan the run queues for threads which + * may need to be updated, and find the earliest runnable thread on the runqueue + * to report its latency. + */ + SCHED(thread_update_scan)(&scan_context); + + SCHED(rt_runq_scan)(&scan_context); + + uint64_t ctime = mach_absolute_time(); + + uint64_t bg_max_latency = (ctime > scan_context.earliest_bg_make_runnable_time) ? + ctime - scan_context.earliest_bg_make_runnable_time : 0; + + uint64_t default_max_latency = (ctime > scan_context.earliest_normal_make_runnable_time) ? + ctime - scan_context.earliest_normal_make_runnable_time : 0; + + uint64_t realtime_max_latency = (ctime > scan_context.earliest_rt_make_runnable_time) ? + ctime - scan_context.earliest_rt_make_runnable_time : 0; + + machine_max_runnable_latency(bg_max_latency, default_max_latency, realtime_max_latency); + + /* + * Check to see if the special sched VM group needs attention. + */ + sched_vm_group_maintenance(); + +#if __arm__ || __arm64__ + /* Check to see if the recommended cores failsafe is active */ + sched_recommended_cores_maintenance(); +#endif /* __arm__ || __arm64__ */ + + +#if DEBUG || DEVELOPMENT +#if __x86_64__ +#include + /* Check for long-duration interrupts */ + mp_interrupt_watchdog(); +#endif /* __x86_64__ */ +#endif /* DEBUG || DEVELOPMENT */ + + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_MAINTENANCE) | DBG_FUNC_END, + sched_pri_shifts[TH_BUCKET_SHARE_FG], sched_pri_shifts[TH_BUCKET_SHARE_BG], + sched_pri_shifts[TH_BUCKET_SHARE_UT], sched_pri_shifts[TH_BUCKET_SHARE_DF], 0); + + assert_wait((event_t)sched_timeshare_maintenance_continue, THREAD_UNINT); + thread_block((thread_continue_t)sched_timeshare_maintenance_continue); + /*NOTREACHED*/ +} + +static uint64_t sched_maintenance_wakeups; + +/* + * Determine if the set of routines formerly driven by a maintenance timer + * must be invoked, based on a deadline comparison. Signals the scheduler + * maintenance thread on deadline expiration. Must be invoked at an interval + * lower than the "sched_tick_interval", currently accomplished by + * invocation via the quantum expiration timer and at context switch time. + * Performance matters: this routine reuses a timestamp approximating the + * current absolute time received from the caller, and should perform + * no more than a comparison against the deadline in the common case. + */ +void +sched_timeshare_consider_maintenance(uint64_t ctime) { + cpu_quiescent_counter_checkin(ctime); + + uint64_t deadline = sched_maintenance_deadline; + + if (__improbable(ctime >= deadline)) { + if (__improbable(current_thread() == sched_maintenance_thread)) { + return; + } + OSMemoryBarrier(); + + uint64_t ndeadline = ctime + sched_tick_interval; + + if (__probable(os_atomic_cmpxchg(&sched_maintenance_deadline, deadline, ndeadline, seq_cst))) { + thread_wakeup((event_t)sched_timeshare_maintenance_continue); + sched_maintenance_wakeups++; + } + } + +#if !CONFIG_SCHED_CLUTCH /* - * If the thread isn't in a wait queue, just set it running. Otherwise, - * try to remove it from the queue and, if successful, then set it - * running. NEVER interrupt an uninterruptible thread. + * Only non-clutch schedulers use the global load calculation EWMA algorithm. For clutch + * scheduler, the load is maintained at the thread group and bucket level. */ - if (!((result == THREAD_INTERRUPTED) && (thread->state & TH_UNINT))) { - if (wait_queue_assert_possible(thread) || - (wait_queue_remove(thread) == KERN_SUCCESS)) { - thread_go_locked(thread, result); + uint64_t load_compute_deadline = os_atomic_load_wide(&sched_load_compute_deadline, relaxed); + + if (__improbable(load_compute_deadline && ctime >= load_compute_deadline)) { + uint64_t new_deadline = 0; + if (os_atomic_cmpxchg(&sched_load_compute_deadline, load_compute_deadline, new_deadline, relaxed)) { + compute_sched_load(); + new_deadline = ctime + sched_load_compute_interval_abs; + os_atomic_store_wide(&sched_load_compute_deadline, new_deadline, relaxed); } } +#endif /* CONFIG_SCHED_CLUTCH */ + +#if __arm64__ + uint64_t perf_deadline = os_atomic_load(&sched_perfcontrol_callback_deadline, relaxed); + + if (__improbable(perf_deadline && ctime >= perf_deadline)) { + /* CAS in 0, if success, make callback. Otherwise let the next context switch check again. */ + if (os_atomic_cmpxchg(&sched_perfcontrol_callback_deadline, perf_deadline, 0, relaxed)) { + machine_perfcontrol_deadline_passed(perf_deadline); + } + } +#endif /* __arm64__ */ +} + +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + +void +sched_init_thread(void) +{ + thread_block(THREAD_CONTINUE_NULL); + + thread_t thread = current_thread(); + + thread_set_thread_name(thread, "sched_maintenance_thread"); + + sched_maintenance_thread = thread; + + SCHED(maintenance_continuation)(); + + /*NOTREACHED*/ } +#if defined(CONFIG_SCHED_TIMESHARE_CORE) /* - * clear_wait: + * thread_update_scan / runq_scan: * - * Clear the wait condition for the specified thread. Start the thread - * executing if that is appropriate. + * Scan the run queues to account for timesharing threads + * which need to be updated. * - * parameters: - * thread thread to awaken - * result Wakeup result the thread should see + * Scanner runs in two passes. Pass one squirrels likely + * threads away in an array, pass two does the update. + * + * This is necessary because the run queue is locked for + * the candidate scan, but the thread is locked for the update. + * + * Array should be sized to make forward progress, without + * disabling preemption for long periods. */ + +#define THREAD_UPDATE_SIZE 128 + +static thread_t thread_update_array[THREAD_UPDATE_SIZE]; +static uint32_t thread_update_count = 0; + +/* Returns TRUE if thread was added, FALSE if thread_update_array is full */ +boolean_t +thread_update_add_thread(thread_t thread) +{ + if (thread_update_count == THREAD_UPDATE_SIZE) { + return FALSE; + } + + thread_update_array[thread_update_count++] = thread; + thread_reference_internal(thread); + return TRUE; +} + void -clear_wait( - thread_t thread, - int result) +thread_update_process_threads(void) { - spl_t s; + assert(thread_update_count <= THREAD_UPDATE_SIZE); - s = splsched(); - thread_lock(thread); - clear_wait_internal(thread, result); - thread_unlock(thread); - splx(s); + for (uint32_t i = 0; i < thread_update_count; i++) { + thread_t thread = thread_update_array[i]; + assert_thread_magic(thread); + thread_update_array[i] = THREAD_NULL; + + spl_t s = splsched(); + thread_lock(thread); + if (!(thread->state & (TH_WAIT)) && thread->sched_stamp != sched_tick) { + SCHED(update_priority)(thread); + } + thread_unlock(thread); + splx(s); + + thread_deallocate(thread); + } + + thread_update_count = 0; +} + +static boolean_t +runq_scan_thread( + thread_t thread, + sched_update_scan_context_t scan_context) +{ + assert_thread_magic(thread); + + if (thread->sched_stamp != sched_tick && + thread->sched_mode == TH_MODE_TIMESHARE) { + if (thread_update_add_thread(thread) == FALSE) { + return TRUE; + } + } + + if (cpu_throttle_enabled && ((thread->sched_pri <= MAXPRI_THROTTLE) && (thread->base_pri <= MAXPRI_THROTTLE))) { + if (thread->last_made_runnable_time < scan_context->earliest_bg_make_runnable_time) { + scan_context->earliest_bg_make_runnable_time = thread->last_made_runnable_time; + } + } else { + if (thread->last_made_runnable_time < scan_context->earliest_normal_make_runnable_time) { + scan_context->earliest_normal_make_runnable_time = thread->last_made_runnable_time; + } + } + + return FALSE; +} + +/* + * Scan a runq for candidate threads. + * + * Returns TRUE if retry is needed. + */ +boolean_t +runq_scan( + run_queue_t runq, + sched_update_scan_context_t scan_context) +{ + int count = runq->count; + int queue_index; + + assert(count >= 0); + + if (count == 0) { + return FALSE; + } + + for (queue_index = bitmap_first(runq->bitmap, NRQS); + queue_index >= 0; + queue_index = bitmap_next(runq->bitmap, queue_index)) { + thread_t thread; + circle_queue_t queue = &runq->queues[queue_index]; + + cqe_foreach_element(thread, queue, runq_links) { + assert(count > 0); + if (runq_scan_thread(thread, scan_context) == TRUE) { + return TRUE; + } + count--; + } + } + + return FALSE; +} + +#if CONFIG_SCHED_CLUTCH + +boolean_t +sched_clutch_timeshare_scan( + queue_t thread_queue, + uint16_t thread_count, + sched_update_scan_context_t scan_context) +{ + if (thread_count == 0) { + return FALSE; + } + + thread_t thread; + qe_foreach_element_safe(thread, thread_queue, th_clutch_timeshare_link) { + if (runq_scan_thread(thread, scan_context) == TRUE) { + return TRUE; + } + thread_count--; + } + + assert(thread_count == 0); + return FALSE; } -/* - * thread_wakeup_prim: - * - * Common routine for thread_wakeup, thread_wakeup_with_result, - * and thread_wakeup_one. - * - */ -void -thread_wakeup_prim( - event_t event, - boolean_t one_thread, - int result) -{ - register wait_queue_t wq; - register int index; +#endif /* CONFIG_SCHED_CLUTCH */ + +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ - index = wait_hash(event); - wq = &wait_queues[index]; - if (one_thread) - wait_queue_wakeup_one(wq, event, result); - else - wait_queue_wakeup_all(wq, event, result); +bool +thread_is_eager_preempt(thread_t thread) +{ + return thread->sched_flags & TH_SFLAG_EAGERPREEMPT; } -/* - * thread_bind: - * - * Force a thread to execute on the specified processor. - * If the thread is currently executing, it may wait until its - * time slice is up before switching onto the specified processor. - * - * A processor of PROCESSOR_NULL causes the thread to be unbound. - * xxx - DO NOT export this to users. - */ void -thread_bind( - register thread_t thread, - processor_t processor) +thread_set_eager_preempt(thread_t thread) { - spl_t s; - - s = splsched(); + spl_t s = splsched(); thread_lock(thread); - thread_bind_locked(thread, processor); - thread_unlock(thread); + + assert(!thread_is_eager_preempt(thread)); + + thread->sched_flags |= TH_SFLAG_EAGERPREEMPT; + + if (thread == current_thread()) { + /* csw_check updates current_is_eagerpreempt on the processor */ + ast_t ast = csw_check(thread, current_processor(), AST_NONE); + + thread_unlock(thread); + + if (ast != AST_NONE) { + thread_block_reason(THREAD_CONTINUE_NULL, NULL, ast); + } + } else { + processor_t last_processor = thread->last_processor; + + if (last_processor != PROCESSOR_NULL && + last_processor->state == PROCESSOR_RUNNING && + last_processor->active_thread == thread) { + cause_ast_check(last_processor); + } + + thread_unlock(thread); + } + splx(s); } -/* - * Select a thread for this processor (the current processor) to run. - * May select the current thread, which must already be locked. - */ -thread_t -thread_select( - register processor_t myprocessor) +void +thread_clear_eager_preempt(thread_t thread) { - register thread_t thread; - processor_set_t pset; - register run_queue_t runq = &myprocessor->runq; - boolean_t other_runnable; - sched_policy_t *policy; + spl_t s = splsched(); + thread_lock(thread); - /* - * Check for other non-idle runnable threads. - */ - myprocessor->first_quantum = TRUE; - pset = myprocessor->processor_set; - thread = current_thread(); + assert(thread_is_eager_preempt(thread)); -#if 0 /* CHECKME! */ - thread->unconsumed_quantum = myprocessor->quantum; -#endif + thread->sched_flags &= ~TH_SFLAG_EAGERPREEMPT; - simple_lock(&runq->lock); - simple_lock(&pset->runq.lock); + if (thread == current_thread()) { + current_processor()->current_is_eagerpreempt = false; + } - other_runnable = runq->count > 0 || pset->runq.count > 0; + thread_unlock(thread); + splx(s); +} - if ( thread->state == TH_RUN && - (!other_runnable || - (runq->highq < thread->sched_pri && - pset->runq.highq < thread->sched_pri)) && - thread->processor_set == pset && - (thread->bound_processor == PROCESSOR_NULL || - thread->bound_processor == myprocessor) ) { +/* + * Scheduling statistics + */ +void +sched_stats_handle_csw(processor_t processor, int reasons, int selfpri, int otherpri) +{ + struct sched_statistics *stats; + boolean_t to_realtime = FALSE; - /* I am the highest priority runnable (non-idle) thread */ - simple_unlock(&pset->runq.lock); - simple_unlock(&runq->lock); + stats = PERCPU_GET_RELATIVE(sched_stats, processor, processor); + stats->csw_count++; - /* Update the thread's meta-priority */ - policy = policy_id_to_sched_policy(thread->policy); - assert(policy != SCHED_POLICY_NULL); - (void)policy->sp_ops.sp_thread_update_mpri(policy, thread); + if (otherpri >= BASEPRI_REALTIME) { + stats->rt_sched_count++; + to_realtime = TRUE; } - else - if (other_runnable) { - simple_unlock(&pset->runq.lock); - simple_unlock(&runq->lock); - thread = choose_thread(myprocessor); - } - else { - simple_unlock(&pset->runq.lock); - simple_unlock(&runq->lock); - /* - * Nothing is runnable, so set this processor idle if it - * was running. If it was in an assignment or shutdown, - * leave it alone. Return its idle thread. - */ - simple_lock(&pset->idle_lock); - if (myprocessor->state == PROCESSOR_RUNNING) { - myprocessor->state = PROCESSOR_IDLE; - /* - * XXX Until it goes away, put master on end of queue, others - * XXX on front so master gets used last. - */ - if (myprocessor == master_processor) - queue_enter(&(pset->idle_queue), myprocessor, - processor_t, processor_queue); - else - queue_enter_first(&(pset->idle_queue), myprocessor, - processor_t, processor_queue); + if ((reasons & AST_PREEMPT) != 0) { + stats->preempt_count++; - pset->idle_count++; + if (selfpri >= BASEPRI_REALTIME) { + stats->preempted_rt_count++; } - simple_unlock(&pset->idle_lock); - thread = myprocessor->idle_thread; + if (to_realtime) { + stats->preempted_by_rt_count++; + } } - - return (thread); } +void +sched_stats_handle_runq_change(struct runq_stats *stats, int old_count) +{ + uint64_t timestamp = mach_absolute_time(); + + stats->count_sum += (timestamp - stats->last_change_timestamp) * old_count; + stats->last_change_timestamp = timestamp; +} /* - * Stop running the current thread and start running the new thread. - * If continuation is non-zero, and the current thread is blocked, - * then it will resume by executing continuation on a new stack. - * Returns TRUE if the hand-off succeeds. - * The reason parameter == AST_QUANTUM if the thread blocked - * because its quantum expired. - * Assumes splsched. + * For calls from assembly code */ +#undef thread_wakeup +void +thread_wakeup( + event_t x); - -static thread_t -__current_thread(void) +void +thread_wakeup( + event_t x) { - return (current_thread()); + thread_wakeup_with_result(x, THREAD_AWAKENED); } boolean_t -thread_invoke( - register thread_t old_thread, - register thread_t new_thread, - int reason, - void (*continuation)(void)) +preemption_enabled(void) { - sched_policy_t *policy; - sf_return_t sfr; - void (*lcont)(void); + return get_preemption_level() == 0 && ml_get_interrupts_enabled(); +} - /* - * Mark thread interruptible. - */ - thread_lock(new_thread); - new_thread->state &= ~TH_UNINT; +static void +sched_timer_deadline_tracking_init(void) +{ + nanoseconds_to_absolutetime(TIMER_DEADLINE_TRACKING_BIN_1_DEFAULT, &timer_deadline_tracking_bin_1); + nanoseconds_to_absolutetime(TIMER_DEADLINE_TRACKING_BIN_2_DEFAULT, &timer_deadline_tracking_bin_2); +} - if (cpu_data[cpu_number()].preemption_level != 1) - panic("thread_invoke: preemption_level %d\n", - cpu_data[cpu_number()].preemption_level); +#if __arm__ || __arm64__ +uint32_t perfcontrol_requested_recommended_cores = ALL_CORES_RECOMMENDED; +uint32_t perfcontrol_requested_recommended_core_count = MAX_CPUS; +bool perfcontrol_failsafe_active = false; +bool perfcontrol_sleep_override = false; - assert(thread_runnable(new_thread)); +uint64_t perfcontrol_failsafe_maintenance_runnable_time; +uint64_t perfcontrol_failsafe_activation_time; +uint64_t perfcontrol_failsafe_deactivation_time; - assert(old_thread->continuation == (void (*)(void))0); +/* data covering who likely caused it and how long they ran */ +#define FAILSAFE_NAME_LEN 33 /* (2*MAXCOMLEN)+1 from size of p_name */ +char perfcontrol_failsafe_name[FAILSAFE_NAME_LEN]; +int perfcontrol_failsafe_pid; +uint64_t perfcontrol_failsafe_tid; +uint64_t perfcontrol_failsafe_thread_timer_at_start; +uint64_t perfcontrol_failsafe_thread_timer_last_seen; +uint32_t perfcontrol_failsafe_recommended_at_trigger; - if ((old_thread->sched_mode & TH_MODE_REALTIME) && (!old_thread->stack_privilege)) { - old_thread->stack_privilege = old_thread->kernel_stack; - } +/* + * Perf controller calls here to update the recommended core bitmask. + * If the failsafe is active, we don't immediately apply the new value. + * Instead, we store the new request and use it after the failsafe deactivates. + * + * If the failsafe is not active, immediately apply the update. + * + * No scheduler locks are held, no other locks are held that scheduler might depend on, + * interrupts are enabled + * + * currently prototype is in osfmk/arm/machine_routines.h + */ +void +sched_perfcontrol_update_recommended_cores(uint32_t recommended_cores) +{ + assert(preemption_enabled()); - if (continuation != (void (*)()) 0) { - switch (new_thread->state & TH_STACK_STATE) { - case TH_STACK_HANDOFF: + spl_t s = splsched(); + simple_lock(&sched_recommended_cores_lock, LCK_GRP_NULL); - /* - * If the old thread has stack privilege, we can't give - * his stack away. So go and get him one and treat this - * as a traditional context switch. - */ - if (old_thread->stack_privilege == current_stack()) - goto get_new_stack; + perfcontrol_requested_recommended_cores = recommended_cores; + perfcontrol_requested_recommended_core_count = __builtin_popcountll(recommended_cores); - /* - * Make the whole handoff/dispatch atomic to match the - * non-handoff case. - */ - disable_preemption(); + if ((perfcontrol_failsafe_active == false) && (perfcontrol_sleep_override == false)) { + sched_update_recommended_cores(perfcontrol_requested_recommended_cores & usercontrol_requested_recommended_cores); + } else { + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_REC_CORES_FAILSAFE) | DBG_FUNC_NONE, + perfcontrol_requested_recommended_cores, + sched_maintenance_thread->last_made_runnable_time, 0, 0, 0); + } - /* - * Set up ast context of new thread and switch to its timer. - */ - new_thread->state &= ~(TH_STACK_HANDOFF|TH_UNINT); - new_thread->last_processor = current_processor(); - ast_context(new_thread->top_act, cpu_number()); - timer_switch(&new_thread->system_timer); - thread_unlock(new_thread); + simple_unlock(&sched_recommended_cores_lock); + splx(s); +} - old_thread->continuation = continuation; - stack_handoff(old_thread, new_thread); +void +sched_override_recommended_cores_for_sleep(void) +{ + spl_t s = splsched(); + simple_lock(&sched_recommended_cores_lock, LCK_GRP_NULL); - wake_lock(old_thread); - thread_lock(old_thread); - act_machine_sv_free(old_thread->top_act); + if (perfcontrol_sleep_override == false) { + perfcontrol_sleep_override = true; + sched_update_recommended_cores(ALL_CORES_RECOMMENDED); + } - /* - * inline thread_dispatch but don't free stack - */ + simple_unlock(&sched_recommended_cores_lock); + splx(s); +} - switch (old_thread->state & (TH_RUN|TH_WAIT|TH_UNINT|TH_IDLE)) { - sched_policy_t *policy; - sf_return_t sfr; - - case TH_RUN | TH_UNINT: - case TH_RUN: - /* - * No reason to stop. Put back on a run queue. - */ - old_thread->state |= TH_STACK_HANDOFF; - - /* Get pointer to scheduling policy "object" */ - policy = &sched_policy[old_thread->policy]; - - /* Leave enqueueing thread up to scheduling policy */ - sfr = policy->sp_ops.sp_thread_dispatch(policy, old_thread); - assert(sfr == SF_SUCCESS); - break; - - case TH_RUN | TH_WAIT | TH_UNINT: - case TH_RUN | TH_WAIT: - old_thread->sleep_stamp = sched_tick; - /* fallthrough */ - - case TH_WAIT: /* this happens! */ - /* - * Waiting - */ - old_thread->state |= TH_STACK_HANDOFF; - old_thread->state &= ~TH_RUN; - if (old_thread->state & TH_TERMINATE) - thread_reaper_enqueue(old_thread); - - if (old_thread->wake_active) { - old_thread->wake_active = FALSE; - thread_unlock(old_thread); - wake_unlock(old_thread); - thread_wakeup((event_t)&old_thread->wake_active); - wake_lock(old_thread); - thread_lock(old_thread); - } - break; - - case TH_RUN | TH_IDLE: - /* - * Drop idle thread -- it is already in - * idle_thread_array. - */ - old_thread->state |= TH_STACK_HANDOFF; - break; - - default: - panic("State 0x%x \n",old_thread->state); - } - - /* Get pointer to scheduling policy "object" */ - policy = &sched_policy[old_thread->policy]; - - /* Indicate to sched policy that old thread has stopped execution */ - /*** ??? maybe use a macro -- rkc, 1/4/96 ***/ - sfr = policy->sp_ops.sp_thread_done(policy, old_thread); - assert(sfr == SF_SUCCESS); - thread_unlock(old_thread); - wake_unlock(old_thread); - thread_lock(new_thread); - - assert(thread_runnable(new_thread)); - - /* Get pointer to scheduling policy "object" */ - policy = &sched_policy[new_thread->policy]; - - /* Indicate to sched policy that new thread has started execution */ - /*** ??? maybe use a macro ***/ - sfr = policy->sp_ops.sp_thread_begin(policy, new_thread); - assert(sfr == SF_SUCCESS); - - lcont = new_thread->continuation; - new_thread->continuation = (void(*)(void))0; - - thread_unlock(new_thread); - enable_preemption(); - - counter_always(c_thread_invoke_hits++); - - if (new_thread->funnel_state & TH_FN_REFUNNEL) { - kern_return_t save_wait_result; - new_thread->funnel_state = 0; - save_wait_result = new_thread->wait_result; - KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, new_thread->funnel_lock, 2, 0, 0, 0); - //mutex_lock(new_thread->funnel_lock); - funnel_lock(new_thread->funnel_lock); - KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, new_thread->funnel_lock, 2, 0, 0, 0); - new_thread->funnel_state = TH_FN_OWNED; - new_thread->wait_result = save_wait_result; - } - (void) spllo(); - - assert(lcont); - call_continuation(lcont); - /*NOTREACHED*/ - return TRUE; +void +sched_restore_recommended_cores_after_sleep(void) +{ + spl_t s = splsched(); + simple_lock(&sched_recommended_cores_lock, LCK_GRP_NULL); - case TH_STACK_COMING_IN: - /* - * waiting for a stack - */ - thread_swapin(new_thread); - thread_unlock(new_thread); - counter_always(c_thread_invoke_misses++); - return FALSE; + if (perfcontrol_sleep_override == true) { + perfcontrol_sleep_override = false; + sched_update_recommended_cores(perfcontrol_requested_recommended_cores & usercontrol_requested_recommended_cores); + } - case 0: - /* - * already has a stack - can't handoff - */ - if (new_thread == old_thread) { - - /* same thread but with continuation */ - counter(++c_thread_invoke_same); - thread_unlock(new_thread); - - if (old_thread->funnel_state & TH_FN_REFUNNEL) { - kern_return_t save_wait_result; - - old_thread->funnel_state = 0; - save_wait_result = old_thread->wait_result; - KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, old_thread->funnel_lock, 3, 0, 0, 0); - funnel_lock(old_thread->funnel_lock); - KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, old_thread->funnel_lock, 3, 0, 0, 0); - old_thread->funnel_state = TH_FN_OWNED; - old_thread->wait_result = save_wait_result; - } - (void) spllo(); - call_continuation(continuation); - /*NOTREACHED*/ - } - break; - } - } else { - /* - * check that the new thread has a stack - */ - if (new_thread->state & TH_STACK_STATE) { - get_new_stack: - /* has no stack. if not already waiting for one try to get one */ - if ((new_thread->state & TH_STACK_COMING_IN) || - /* not already waiting. nonblocking try to get one */ - !stack_alloc_try(new_thread, thread_continue)) - { - /* couldn't get one. schedule new thread to get a stack and - return failure so we can try another thread. */ - thread_swapin(new_thread); - thread_unlock(new_thread); - counter_always(c_thread_invoke_misses++); - return FALSE; - } - } else if (old_thread == new_thread) { - counter(++c_thread_invoke_same); - thread_unlock(new_thread); - return TRUE; - } - - /* new thread now has a stack. it has been setup to resume in - thread_continue so it can dispatch the old thread, deal with - funnelling and then go to it's true continuation point */ - } - - new_thread->state &= ~(TH_STACK_HANDOFF | TH_UNINT); + simple_unlock(&sched_recommended_cores_lock); + splx(s); +} +/* + * Consider whether we need to activate the recommended cores failsafe + * + * Called from quantum timer interrupt context of a realtime thread + * No scheduler locks are held, interrupts are disabled + */ +void +sched_consider_recommended_cores(uint64_t ctime, thread_t cur_thread) +{ /* - * Set up ast context of new thread and switch to its timer. - */ - new_thread->last_processor = current_processor(); - ast_context(new_thread->top_act, cpu_number()); - timer_switch(&new_thread->system_timer); - assert(thread_runnable(new_thread)); - - /* - * N.B. On return from the call to switch_context, 'old_thread' - * points at the thread that yielded to us. Unfortunately, at - * this point, there are no simple_locks held, so if we are preempted - * before the call to thread_dispatch blocks preemption, it is - * possible for 'old_thread' to terminate, leaving us with a - * stale thread pointer. + * Check if a realtime thread is starving the system + * and bringing up non-recommended cores would help + * + * TODO: Is this the correct check for recommended == possible cores? + * TODO: Validate the checks without the relevant lock are OK. */ - disable_preemption(); - thread_unlock(new_thread); + if (__improbable(perfcontrol_failsafe_active == TRUE)) { + /* keep track of how long the responsible thread runs */ - counter_always(c_thread_invoke_csw++); - current_task()->csw++; + simple_lock(&sched_recommended_cores_lock, LCK_GRP_NULL); - - thread_lock(old_thread); - old_thread->reason = reason; - assert(old_thread->runq == RUN_QUEUE_NULL); - - if (continuation != (void (*)(void))0) - old_thread->continuation = continuation; - - /* Indicate to sched policy that old thread has stopped execution */ - policy = &sched_policy[old_thread->policy]; - /*** ??? maybe use a macro -- ***/ - sfr = policy->sp_ops.sp_thread_done(policy, old_thread); - assert(sfr == SF_SUCCESS); - thread_unlock(old_thread); + if (perfcontrol_failsafe_active == TRUE && + cur_thread->thread_id == perfcontrol_failsafe_tid) { + perfcontrol_failsafe_thread_timer_last_seen = timer_grab(&cur_thread->user_timer) + + timer_grab(&cur_thread->system_timer); + } - /* - * switch_context is machine-dependent. It does the - * machine-dependent components of a context-switch, like - * changing address spaces. It updates active_threads. - */ - old_thread = switch_context(old_thread, continuation, new_thread); - - /* Now on new thread's stack. Set a local variable to refer to it. */ - new_thread = __current_thread(); - assert(old_thread != new_thread); - - assert(thread_runnable(new_thread)); - - thread_lock(new_thread); - assert(thread_runnable(new_thread)); - /* Indicate to sched policy that new thread has started execution */ - policy = &sched_policy[new_thread->policy]; - /*** ??? maybe use a macro -- rkc, 1/4/96 ***/ - sfr = policy->sp_ops.sp_thread_begin(policy, new_thread); - assert(sfr == SF_SUCCESS); - thread_unlock(new_thread); + simple_unlock(&sched_recommended_cores_lock); - /* - * We're back. Now old_thread is the thread that resumed - * us, and we have to dispatch it. - */ - /* CHECKME! */ -// Code from OSF in Grenoble deleted the following fields. They were -// used in HPPA and 386 code, but not in the PPC for other than -// just setting and resetting. They didn't delete these lines from -// the MACH_RT builds, though, causing compile errors. I'm going -// to make a wild guess and assume we can just delete these. -#if 0 - if (old_thread->preempt == TH_NOT_PREEMPTABLE) { - /* - * Mark that we have been really preempted - */ - old_thread->preempt = TH_PREEMPTED; + /* we're already trying to solve the problem, so bail */ + return; } -#endif - thread_dispatch(old_thread); - enable_preemption(); - /* if we get here and 'continuation' is set that means the - * switch_context() path returned and did not call out - * to the continuation. we will do it manually here */ - if (continuation) { - call_continuation(continuation); - /* NOTREACHED */ + /* The failsafe won't help if there are no more processors to enable */ + if (__probable(perfcontrol_requested_recommended_core_count >= processor_count)) { + return; } - return TRUE; -} + uint64_t too_long_ago = ctime - perfcontrol_failsafe_starvation_threshold; -/* - * thread_continue: - * - * Called when the launching a new thread, at splsched(); - */ -void -thread_continue( - register thread_t old_thread) -{ - register thread_t self; - register void (*continuation)(); - sched_policy_t *policy; - sf_return_t sfr; + /* Use the maintenance thread as our canary in the coal mine */ + thread_t m_thread = sched_maintenance_thread; - self = current_thread(); - - /* - * We must dispatch the old thread and then - * call the current thread's continuation. - * There might not be an old thread, if we are - * the first thread to run on this processor. - */ - if (old_thread != THREAD_NULL) { - thread_dispatch(old_thread); - - thread_lock(self); + /* If it doesn't look bad, nothing to see here */ + if (__probable(m_thread->last_made_runnable_time >= too_long_ago)) { + return; + } - /* Get pointer to scheduling policy "object" */ - policy = &sched_policy[self->policy]; + /* It looks bad, take the lock to be sure */ + thread_lock(m_thread); - /* Indicate to sched policy that new thread has started execution */ - /*** ??? maybe use a macro -- rkc, 1/4/96 ***/ - sfr = policy->sp_ops.sp_thread_begin(policy,self); - assert(sfr == SF_SUCCESS); - } else { - thread_lock(self); + if (m_thread->runq == PROCESSOR_NULL || + (m_thread->state & (TH_RUN | TH_WAIT)) != TH_RUN || + m_thread->last_made_runnable_time >= too_long_ago) { + /* + * Maintenance thread is either on cpu or blocked, and + * therefore wouldn't benefit from more cores + */ + thread_unlock(m_thread); + return; } - - continuation = self->continuation; - self->continuation = (void (*)(void))0; - thread_unlock(self); + + uint64_t maintenance_runnable_time = m_thread->last_made_runnable_time; + + thread_unlock(m_thread); /* - * N.B. - the following is necessary, since thread_invoke() - * inhibits preemption on entry and reenables before it - * returns. Unfortunately, the first time a newly-created - * thread executes, it magically appears here, and never - * executes the enable_preemption() call in thread_invoke(). + * There are cores disabled at perfcontrol's recommendation, but the + * system is so overloaded that the maintenance thread can't run. + * That likely means that perfcontrol can't run either, so it can't fix + * the recommendation. We have to kick in a failsafe to keep from starving. + * + * When the maintenance thread has been starved for too long, + * ignore the recommendation from perfcontrol and light up all the cores. + * + * TODO: Consider weird states like boot, sleep, or debugger */ - enable_preemption(); - if (self->funnel_state & TH_FN_REFUNNEL) { - kern_return_t save_wait_result; - self->funnel_state = 0; - save_wait_result = self->wait_result; - KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, self->funnel_lock, 4, 0, 0, 0); - funnel_lock(self->funnel_lock); - KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, self->funnel_lock, 4, 0, 0, 0); - self->wait_result = save_wait_result; - self->funnel_state = TH_FN_OWNED; + simple_lock(&sched_recommended_cores_lock, LCK_GRP_NULL); + + if (perfcontrol_failsafe_active == TRUE) { + simple_unlock(&sched_recommended_cores_lock); + return; } - spllo(); - assert(continuation); - (*continuation)(); - /*NOTREACHED*/ -} + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_REC_CORES_FAILSAFE) | DBG_FUNC_START, + perfcontrol_requested_recommended_cores, maintenance_runnable_time, 0, 0, 0); -#if MACH_LDEBUG || MACH_KDB + perfcontrol_failsafe_active = TRUE; + perfcontrol_failsafe_activation_time = mach_absolute_time(); + perfcontrol_failsafe_maintenance_runnable_time = maintenance_runnable_time; + perfcontrol_failsafe_recommended_at_trigger = perfcontrol_requested_recommended_cores; -#define THREAD_LOG_SIZE 300 + /* Capture some data about who screwed up (assuming that the thread on core is at fault) */ + task_t task = cur_thread->task; + perfcontrol_failsafe_pid = task_pid(task); + strlcpy(perfcontrol_failsafe_name, proc_name_address(task->bsd_info), sizeof(perfcontrol_failsafe_name)); -struct t64 { - unsigned long h; - unsigned long l; -}; + perfcontrol_failsafe_tid = cur_thread->thread_id; -struct { - struct t64 stamp; - thread_t thread; - long info1; - long info2; - long info3; - char * action; -} thread_log[THREAD_LOG_SIZE]; + /* Blame the thread for time it has run recently */ + uint64_t recent_computation = (ctime - cur_thread->computation_epoch) + cur_thread->computation_metered; -int thread_log_index; + uint64_t last_seen = timer_grab(&cur_thread->user_timer) + timer_grab(&cur_thread->system_timer); -void check_thread_time(long n); + /* Compute the start time of the bad behavior in terms of the thread's on core time */ + perfcontrol_failsafe_thread_timer_at_start = last_seen - recent_computation; + perfcontrol_failsafe_thread_timer_last_seen = last_seen; + /* Ignore the previously recommended core configuration */ + sched_update_recommended_cores(ALL_CORES_RECOMMENDED); -int check_thread_time_crash; + simple_unlock(&sched_recommended_cores_lock); +} -#if 0 -void -check_thread_time(long us) +/* + * Now that our bacon has been saved by the failsafe, consider whether to turn it off + * + * Runs in the context of the maintenance thread, no locks held + */ +static void +sched_recommended_cores_maintenance(void) { - struct t64 temp; - - if (!check_thread_time_crash) + /* Common case - no failsafe, nothing to be done here */ + if (__probable(perfcontrol_failsafe_active == FALSE)) { return; + } - temp = thread_log[0].stamp; - cyctm05_diff (&thread_log[1].stamp, &thread_log[0].stamp, &temp); + uint64_t ctime = mach_absolute_time(); - if (temp.l >= us && thread_log[1].info != 0x49) /* HACK!!! */ - panic ("check_thread_time"); -} -#endif + boolean_t print_diagnostic = FALSE; + char p_name[FAILSAFE_NAME_LEN] = ""; -void -log_thread_action(char * action, long info1, long info2, long info3) -{ - int i; - spl_t x; - static unsigned int tstamp; + spl_t s = splsched(); + simple_lock(&sched_recommended_cores_lock, LCK_GRP_NULL); - x = splhigh(); + /* Check again, under the lock, to avoid races */ + if (perfcontrol_failsafe_active == FALSE) { + goto out; + } - for (i = THREAD_LOG_SIZE-1; i > 0; i--) { - thread_log[i] = thread_log[i-1]; + /* + * Ensure that the other cores get another few ticks to run some threads + * If we don't have this hysteresis, the maintenance thread is the first + * to run, and then it immediately kills the other cores + */ + if ((ctime - perfcontrol_failsafe_activation_time) < perfcontrol_failsafe_starvation_threshold) { + goto out; } - thread_log[0].stamp.h = 0; - thread_log[0].stamp.l = tstamp++; - thread_log[0].thread = current_thread(); - thread_log[0].info1 = info1; - thread_log[0].info2 = info2; - thread_log[0].info3 = info3; - thread_log[0].action = action; -/* strcpy (&thread_log[0].action[0], action);*/ + /* Capture some diagnostic state under the lock so we can print it out later */ - splx(x); -} -#endif /* MACH_LDEBUG || MACH_KDB */ + int pid = perfcontrol_failsafe_pid; + uint64_t tid = perfcontrol_failsafe_tid; -#if MACH_KDB -#include -void db_show_thread_log(void); + uint64_t thread_usage = perfcontrol_failsafe_thread_timer_last_seen - + perfcontrol_failsafe_thread_timer_at_start; + uint32_t rec_cores_before = perfcontrol_failsafe_recommended_at_trigger; + uint32_t rec_cores_after = perfcontrol_requested_recommended_cores; + uint64_t failsafe_duration = ctime - perfcontrol_failsafe_activation_time; + strlcpy(p_name, perfcontrol_failsafe_name, sizeof(p_name)); -void -db_show_thread_log(void) -{ - int i; + print_diagnostic = TRUE; - db_printf ("%s %s %s %s %s %s\n", " Thread ", " Info1 ", " Info2 ", - " Info3 ", " Timestamp ", "Action"); + /* Deactivate the failsafe and reinstate the requested recommendation settings */ - for (i = 0; i < THREAD_LOG_SIZE; i++) { - db_printf ("%08x %08x %08x %08x %08x/%08x %s\n", - thread_log[i].thread, - thread_log[i].info1, - thread_log[i].info2, - thread_log[i].info3, - thread_log[i].stamp.h, - thread_log[i].stamp.l, - thread_log[i].action); - } -} -#endif /* MACH_KDB */ + perfcontrol_failsafe_deactivation_time = ctime; + perfcontrol_failsafe_active = FALSE; -/* - * thread_block_reason: - * - * Block the current thread. If the thread is runnable - * then someone must have woken it up between its request - * to sleep and now. In this case, it goes back on a - * run queue. - * - * If a continuation is specified, then thread_block will - * attempt to discard the thread's kernel stack. When the - * thread resumes, it will execute the continuation function - * on a new kernel stack. - */ -counter(mach_counter_t c_thread_block_calls = 0;) - -int -thread_block_reason( - void (*continuation)(void), - int reason) -{ - register thread_t thread = current_thread(); - register processor_t myprocessor; - register thread_t new_thread; - spl_t s; + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_REC_CORES_FAILSAFE) | DBG_FUNC_END, + perfcontrol_requested_recommended_cores, failsafe_duration, 0, 0, 0); + + sched_update_recommended_cores(perfcontrol_requested_recommended_cores & usercontrol_requested_recommended_cores); - counter(++c_thread_block_calls); +out: + simple_unlock(&sched_recommended_cores_lock); + splx(s); - check_simple_locks(); + if (print_diagnostic) { + uint64_t failsafe_duration_ms = 0, thread_usage_ms = 0; - machine_clock_assist(); + absolutetime_to_nanoseconds(failsafe_duration, &failsafe_duration_ms); + failsafe_duration_ms = failsafe_duration_ms / NSEC_PER_MSEC; - s = splsched(); + absolutetime_to_nanoseconds(thread_usage, &thread_usage_ms); + thread_usage_ms = thread_usage_ms / NSEC_PER_MSEC; - if ((thread->funnel_state & TH_FN_OWNED) && !(reason & AST_PREEMPT)) { - thread->funnel_state = TH_FN_REFUNNEL; - KERNEL_DEBUG(0x603242c | DBG_FUNC_NONE, thread->funnel_lock, 2, 0, 0, 0); - funnel_unlock(thread->funnel_lock); + printf("recommended core failsafe kicked in for %lld ms " + "likely due to %s[%d] thread 0x%llx spending " + "%lld ms on cpu at realtime priority - " + "new recommendation: 0x%x -> 0x%x\n", + failsafe_duration_ms, p_name, pid, tid, thread_usage_ms, + rec_cores_before, rec_cores_after); } +} - myprocessor = current_processor(); +#endif /* __arm__ || __arm64__ */ - thread_lock(thread); - if (thread->state & TH_ABORT) - clear_wait_internal(thread, THREAD_INTERRUPTED); +kern_return_t +sched_processor_enable(processor_t processor, boolean_t enable) +{ + assert(preemption_enabled()); - /* Unconditionally remove either | both */ - ast_off(AST_QUANTUM|AST_BLOCK|AST_URGENT); + spl_t s = splsched(); + simple_lock(&sched_recommended_cores_lock, LCK_GRP_NULL); - new_thread = thread_select(myprocessor); - assert(new_thread); - assert(thread_runnable(new_thread)); - thread_unlock(thread); - while (!thread_invoke(thread, new_thread, reason, continuation)) { - thread_lock(thread); - new_thread = thread_select(myprocessor); - assert(new_thread); - assert(thread_runnable(new_thread)); - thread_unlock(thread); + if (enable) { + bit_set(usercontrol_requested_recommended_cores, processor->cpu_id); + } else { + bit_clear(usercontrol_requested_recommended_cores, processor->cpu_id); } - if (thread->funnel_state & TH_FN_REFUNNEL) { - kern_return_t save_wait_result; - - save_wait_result = thread->wait_result; - thread->funnel_state = 0; - KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, thread->funnel_lock, 5, 0, 0, 0); - funnel_lock(thread->funnel_lock); - KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, thread->funnel_lock, 5, 0, 0, 0); - thread->funnel_state = TH_FN_OWNED; - thread->wait_result = save_wait_result; +#if __arm__ || __arm64__ + if ((perfcontrol_failsafe_active == false) && (perfcontrol_sleep_override == false)) { + sched_update_recommended_cores(perfcontrol_requested_recommended_cores & usercontrol_requested_recommended_cores); + } else { + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_REC_CORES_FAILSAFE) | DBG_FUNC_NONE, + perfcontrol_requested_recommended_cores, + sched_maintenance_thread->last_made_runnable_time, 0, 0, 0); } +#else /* __arm__ || __arm64__ */ + sched_update_recommended_cores(usercontrol_requested_recommended_cores); +#endif /* !__arm__ || __arm64__ */ + simple_unlock(&sched_recommended_cores_lock); splx(s); - return thread->wait_result; + return KERN_SUCCESS; } -/* - * thread_block: - * - * Now calls thread_block_reason() which forwards the - * the reason parameter to thread_invoke() so it can - * do the right thing if the thread's quantum expired. - */ -int -thread_block( - void (*continuation)(void)) -{ - return thread_block_reason(continuation, 0); -} /* - * thread_run: + * Apply a new recommended cores mask to the processors it affects + * Runs after considering failsafes and such * - * Switch directly from the current thread to a specified - * thread. Both the current and new threads must be - * runnable. + * Iterate over processors and update their ->is_recommended field. + * If a processor is running, we let it drain out at its next + * quantum expiration or blocking point. If a processor is idle, there + * may be more work for it to do, so IPI it. * - * Assumption: - * at splsched. + * interrupts disabled, sched_recommended_cores_lock is held */ -int -thread_run( - thread_t old_thread, - void (*continuation)(void), - thread_t new_thread) +static void +sched_update_recommended_cores(uint64_t recommended_cores) { - while (!thread_invoke(old_thread, new_thread, 0, continuation)) { - register processor_t myprocessor = current_processor(); - thread_lock(old_thread); - new_thread = thread_select(myprocessor); - thread_unlock(old_thread); + processor_set_t pset, nset; + processor_t processor; + uint64_t needs_exit_idle_mask = 0x0; + uint32_t avail_count; + + processor = processor_list; + pset = processor->processor_set; + + KDBG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_UPDATE_REC_CORES) | DBG_FUNC_START, + recommended_cores, +#if __arm__ || __arm64__ + perfcontrol_failsafe_active, 0, 0); +#else /* __arm__ || __arm64__ */ + 0, 0, 0); +#endif /* ! __arm__ || __arm64__ */ + + if (__builtin_popcountll(recommended_cores) == 0) { + bit_set(recommended_cores, master_processor->cpu_id); /* add boot processor or we hang */ } - return old_thread->wait_result; -} -/* - * Dispatches a running thread that is not on a runq. - * Called at splsched. - */ -void -thread_dispatch( - register thread_t thread) -{ - sched_policy_t *policy; - sf_return_t sfr; + /* First set recommended cores */ + pset_lock(pset); + avail_count = 0; + do { + nset = processor->processor_set; + if (nset != pset) { + pset_unlock(pset); + pset = nset; + pset_lock(pset); + } - /* - * If we are discarding the thread's stack, we must do it - * before the thread has a chance to run. - */ - wake_lock(thread); - thread_lock(thread); + if (bit_test(recommended_cores, processor->cpu_id)) { + processor->is_recommended = TRUE; + bit_set(pset->recommended_bitmask, processor->cpu_id); -#ifndef i386 - /* no continuations on i386 for now */ - if (thread->continuation != (void (*)())0) { - assert((thread->state & TH_STACK_STATE) == 0); - thread->state |= TH_STACK_HANDOFF; - stack_free(thread); - if (thread->top_act) { - act_machine_sv_free(thread->top_act); - } - } -#endif + if (processor->state == PROCESSOR_IDLE) { + if (processor != current_processor()) { + bit_set(needs_exit_idle_mask, processor->cpu_id); + } + } + if (processor->state != PROCESSOR_OFF_LINE) { + avail_count++; + SCHED(pset_made_schedulable)(processor, pset, false); + } + } + } while ((processor = processor->processor_list) != NULL); + pset_unlock(pset); - switch (thread->state & (TH_RUN|TH_WAIT|TH_UNINT|TH_IDLE)) { + /* Now shutdown not recommended cores */ + processor = processor_list; + pset = processor->processor_set; - case TH_RUN | TH_UNINT: - case TH_RUN: - /* - * No reason to stop. Put back on a run queue. - */ - /* Leave enqueueing thread up to scheduling policy */ - policy = &sched_policy[thread->policy]; - /*** ??? maybe use a macro ***/ - sfr = policy->sp_ops.sp_thread_dispatch(policy, thread); - assert(sfr == SF_SUCCESS); - break; + pset_lock(pset); + do { + nset = processor->processor_set; + if (nset != pset) { + pset_unlock(pset); + pset = nset; + pset_lock(pset); + } - case TH_RUN | TH_WAIT | TH_UNINT: - case TH_RUN | TH_WAIT: - thread->sleep_stamp = sched_tick; - /* fallthrough */ - case TH_WAIT: /* this happens! */ - - /* - * Waiting - */ - thread->state &= ~TH_RUN; - if (thread->state & TH_TERMINATE) - thread_reaper_enqueue(thread); + if (!bit_test(recommended_cores, processor->cpu_id)) { + sched_ipi_type_t ipi_type = SCHED_IPI_NONE; - if (thread->wake_active) { - thread->wake_active = FALSE; - thread_unlock(thread); - wake_unlock(thread); - thread_wakeup((event_t)&thread->wake_active); - return; + processor->is_recommended = FALSE; + bit_clear(pset->recommended_bitmask, processor->cpu_id); + + if ((processor->state == PROCESSOR_RUNNING) || (processor->state == PROCESSOR_DISPATCHING)) { + ipi_type = SCHED_IPI_IMMEDIATE; + } + SCHED(processor_queue_shutdown)(processor); + /* pset unlocked */ + + SCHED(rt_queue_shutdown)(processor); + + if (ipi_type != SCHED_IPI_NONE) { + if (processor == current_processor()) { + ast_on(AST_PREEMPT); + } else { + sched_ipi_perform(processor, ipi_type); + } + } + + pset_lock(pset); } - break; + } while ((processor = processor->processor_list) != NULL); - case TH_RUN | TH_IDLE: - /* - * Drop idle thread -- it is already in - * idle_thread_array. - */ - break; + processor_avail_count_user = avail_count; +#if defined(__x86_64__) + commpage_update_active_cpus(); +#endif + + pset_unlock(pset); - default: - panic("State 0x%x \n",thread->state); + /* Issue all pending IPIs now that the pset lock has been dropped */ + for (int cpuid = lsb_first(needs_exit_idle_mask); cpuid >= 0; cpuid = lsb_next(needs_exit_idle_mask, cpuid)) { + processor = processor_array[cpuid]; + machine_signal_idle(processor); } - thread_unlock(thread); - wake_unlock(thread); + + KDBG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_UPDATE_REC_CORES) | DBG_FUNC_END, + needs_exit_idle_mask, 0, 0, 0); } -/* - * Enqueue thread on run queue. Thread must be locked, - * and not already be on a run queue. - */ -int -run_queue_enqueue( - register run_queue_t rq, - register thread_t thread, - boolean_t tail) +void +thread_set_options(uint32_t thopt) { - register int whichq; - int oldrqcount; - - whichq = thread->sched_pri; - assert(whichq >= MINPRI && whichq <= MAXPRI); - - simple_lock(&rq->lock); /* lock the run queue */ - assert(thread->runq == RUN_QUEUE_NULL); - if (tail) - enqueue_tail(&rq->queues[whichq], (queue_entry_t)thread); - else - enqueue_head(&rq->queues[whichq], (queue_entry_t)thread); + spl_t x; + thread_t t = current_thread(); - setbit(MAXPRI - whichq, rq->bitmap); - if (whichq > rq->highq) - rq->highq = whichq; + x = splsched(); + thread_lock(t); - oldrqcount = rq->count++; - thread->runq = rq; - thread->whichq = whichq; -#if DEBUG - thread_check(thread, rq); -#endif /* DEBUG */ - simple_unlock(&rq->lock); + t->options |= thopt; - return (oldrqcount); + thread_unlock(t); + splx(x); } -/* - * thread_setrun: - * - * Make thread runnable; dispatch directly onto an idle processor - * if possible. Else put on appropriate run queue (processor - * if bound, else processor set. Caller must have lock on thread. - * This is always called at splsched. - * The tail parameter, if TRUE || TAIL_Q, indicates that the - * thread should be placed at the tail of the runq. If - * FALSE || HEAD_Q the thread will be placed at the head of the - * appropriate runq. - */ void -thread_setrun( - register thread_t new_thread, - boolean_t may_preempt, - boolean_t tail) +thread_set_pending_block_hint(thread_t thread, block_hint_t block_hint) { - register processor_t processor; - register run_queue_t runq; - register processor_set_t pset; - thread_t thread; - ast_t ast_flags = AST_BLOCK; - - mp_disable_preemption(); + thread->pending_block_hint = block_hint; +} - assert(!(new_thread->state & TH_SWAPPED_OUT)); - assert(thread_runnable(new_thread)); - - /* - * Update priority if needed. - */ - if (new_thread->sched_stamp != sched_tick) - update_priority(new_thread); +uint32_t +qos_max_parallelism(int qos, uint64_t options) +{ + return SCHED(qos_max_parallelism)(qos, options); +} - if (new_thread->policy & (POLICY_FIFO|POLICY_RR)) { - if ( new_thread->sched_pri >= (MAXPRI_KERNBAND - 2) && - kernel_preemption_mode == KERNEL_PREEMPT ) - ast_flags |= AST_URGENT; +uint32_t +sched_qos_max_parallelism(__unused int qos, uint64_t options) +{ + host_basic_info_data_t hinfo; + mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT; + /* Query the machine layer for core information */ + __assert_only kern_return_t kret = host_info(host_self(), HOST_BASIC_INFO, + (host_info_t)&hinfo, &count); + assert(kret == KERN_SUCCESS); + + if (options & QOS_PARALLELISM_COUNT_LOGICAL) { + return hinfo.logical_cpu; + } else { + return hinfo.physical_cpu; } - - assert(new_thread->runq == RUN_QUEUE_NULL); - - /* - * Try to dispatch the thread directly onto an idle processor. - */ - if ((processor = new_thread->bound_processor) == PROCESSOR_NULL) { - /* - * Not bound, any processor in the processor set is ok. - */ - pset = new_thread->processor_set; - if (pset->idle_count > 0) { - simple_lock(&pset->idle_lock); - if (pset->idle_count > 0) { - processor = (processor_t) queue_first(&pset->idle_queue); - queue_remove(&(pset->idle_queue), processor, processor_t, - processor_queue); - pset->idle_count--; - processor->next_thread = new_thread; - processor->state = PROCESSOR_DISPATCHING; - simple_unlock(&pset->idle_lock); - if(processor->slot_num != cpu_number()) - machine_signal_idle(processor); - mp_enable_preemption(); - return; - } - simple_unlock(&pset->idle_lock); - } - - - /* - * Preempt check - */ - runq = &pset->runq; - thread = current_thread(); - processor = current_processor(); - if ( may_preempt && - pset == processor->processor_set && - thread->sched_pri < new_thread->sched_pri ) { - /* - * XXX if we have a non-empty local runq or are - * XXX running a bound thread, ought to check for - * XXX another cpu running lower-pri thread to preempt. - */ - /* - * Turn off first_quantum to allow csw. - */ - processor->first_quantum = FALSE; - - ast_on(ast_flags); - } +} - /* - * Put us on the end of the runq, if we are not preempting - * or the guy we are preempting. - */ - run_queue_enqueue(runq, new_thread, tail); - } - else { - /* - * Bound, can only run on bound processor. Have to lock - * processor here because it may not be the current one. - */ - if (processor->state == PROCESSOR_IDLE) { - simple_lock(&processor->lock); - pset = processor->processor_set; - simple_lock(&pset->idle_lock); - if (processor->state == PROCESSOR_IDLE) { - queue_remove(&pset->idle_queue, processor, - processor_t, processor_queue); - pset->idle_count--; - processor->next_thread = new_thread; - processor->state = PROCESSOR_DISPATCHING; - simple_unlock(&pset->idle_lock); - simple_unlock(&processor->lock); - if(processor->slot_num != cpu_number()) - machine_signal_idle(processor); - mp_enable_preemption(); - return; - } - simple_unlock(&pset->idle_lock); - simple_unlock(&processor->lock); - } - - /* - * Cause ast on processor if processor is on line, and the - * currently executing thread is not bound to that processor - * (bound threads have implicit priority over non-bound threads). - * We also avoid sending the AST to the idle thread (if it got - * scheduled in the window between the 'if' above and here), - * since the idle_thread is bound. - */ - runq = &processor->runq; - thread = current_thread(); - if (processor == current_processor()) { - if ( thread->bound_processor == PROCESSOR_NULL || - thread->sched_pri < new_thread->sched_pri ) { - processor->first_quantum = FALSE; - ast_on(ast_flags); - } - - run_queue_enqueue(runq, new_thread, tail); - } - else { - thread = cpu_data[processor->slot_num].active_thread; - if ( run_queue_enqueue(runq, new_thread, tail) == 0 && - processor->state != PROCESSOR_OFF_LINE && - thread && thread->bound_processor != processor ) - cause_ast_check(processor); - } - } - - mp_enable_preemption(); -} - -/* - * set_pri: - * - * Set the priority of the specified thread to the specified - * priority. This may cause the thread to change queues. - * - * The thread *must* be locked by the caller. - */ -void -set_pri( - thread_t thread, - int pri, - boolean_t resched) +int sched_allow_NO_SMT_threads = 1; +bool +thread_no_smt(thread_t thread) { - register struct run_queue *rq; + return sched_allow_NO_SMT_threads && (thread->bound_processor == PROCESSOR_NULL) && ((thread->sched_flags & TH_SFLAG_NO_SMT) || (thread->task->t_flags & TF_NO_SMT)); +} - rq = rem_runq(thread); - assert(thread->runq == RUN_QUEUE_NULL); - thread->sched_pri = pri; - if (rq != RUN_QUEUE_NULL) { - if (resched) - thread_setrun(thread, TRUE, TAIL_Q); - else - run_queue_enqueue(rq, thread, TAIL_Q); - } +bool +processor_active_thread_no_smt(processor_t processor) +{ + return sched_allow_NO_SMT_threads && !processor->current_is_bound && processor->current_is_NO_SMT; } +#if __arm64__ + /* - * rem_runq: + * Set up or replace old timer with new timer * - * Remove a thread from its run queue. - * The run queue that the process was on is returned - * (or RUN_QUEUE_NULL if not on a run queue). Thread *must* be locked - * before calling this routine. Unusual locking protocol on runq - * field in thread structure makes this code interesting; see thread.h. + * Returns true if canceled old timer, false if it did not */ -run_queue_t -rem_runq( - thread_t thread) +boolean_t +sched_perfcontrol_update_callback_deadline(uint64_t new_deadline) { - register struct run_queue *rq; - - rq = thread->runq; /* - * If rq is RUN_QUEUE_NULL, the thread will stay out of the - * run_queues because the caller locked the thread. Otherwise - * the thread is on a runq, but could leave. + * Exchange deadline for new deadline, if old deadline was nonzero, + * then I cancelled the callback, otherwise I didn't */ - if (rq != RUN_QUEUE_NULL) { - simple_lock(&rq->lock); - if (rq == thread->runq) { - /* - * Thread is in a runq and we have a lock on - * that runq. - */ -#if DEBUG - thread_check(thread, rq); -#endif /* DEBUG */ - remqueue(&rq->queues[0], (queue_entry_t)thread); - rq->count--; - - if (queue_empty(rq->queues + thread->sched_pri)) { - /* update run queue status */ - if (thread->sched_pri != IDLEPRI) - clrbit(MAXPRI - thread->sched_pri, rq->bitmap); - rq->highq = MAXPRI - ffsbit(rq->bitmap); - } - thread->runq = RUN_QUEUE_NULL; - simple_unlock(&rq->lock); - } - else { - /* - * The thread left the runq before we could - * lock the runq. It is not on a runq now, and - * can't move again because this routine's - * caller locked the thread. - */ - assert(thread->runq == RUN_QUEUE_NULL); - simple_unlock(&rq->lock); - rq = RUN_QUEUE_NULL; - } - } - return (rq); + return os_atomic_xchg(&sched_perfcontrol_callback_deadline, new_deadline, + relaxed) != 0; } +#endif /* __arm64__ */ -/* - * choose_thread: - * - * Choose a thread to execute. The thread chosen is removed - * from its run queue. Note that this requires only that the runq - * lock be held. - * - * Strategy: - * Check processor runq first; if anything found, run it. - * Else check pset runq; if nothing found, return idle thread. - * - * Second line of strategy is implemented by choose_pset_thread. - * This is only called on processor startup and when thread_block - * thinks there's something in the processor runq. - */ -thread_t -choose_thread( - processor_t myprocessor) -{ - thread_t thread; - register queue_t q; - register run_queue_t runq; - processor_set_t pset; - - runq = &myprocessor->runq; - pset = myprocessor->processor_set; - - simple_lock(&runq->lock); - if (runq->count > 0 && runq->highq >= pset->runq.highq) { - q = runq->queues + runq->highq; -#if MACH_ASSERT - if (!queue_empty(q)) { -#endif /*MACH_ASSERT*/ - thread = (thread_t)q->next; - ((queue_entry_t)thread)->next->prev = q; - q->next = ((queue_entry_t)thread)->next; - thread->runq = RUN_QUEUE_NULL; - runq->count--; - if (queue_empty(q)) { - if (runq->highq != IDLEPRI) - clrbit(MAXPRI - runq->highq, runq->bitmap); - runq->highq = MAXPRI - ffsbit(runq->bitmap); - } - simple_unlock(&runq->lock); - return (thread); -#if MACH_ASSERT - } - panic("choose_thread"); -#endif /*MACH_ASSERT*/ - /*NOTREACHED*/ - } - - simple_unlock(&runq->lock); - simple_lock(&pset->runq.lock); - return (choose_pset_thread(myprocessor, pset)); -} +#if CONFIG_SCHED_EDGE +#define SCHED_PSET_LOAD_EWMA_TC_NSECS 10000000u /* - * choose_pset_thread: choose a thread from processor_set runq or - * set processor idle and choose its idle thread. + * sched_edge_pset_running_higher_bucket() * - * Caller must be at splsched and have a lock on the runq. This - * lock is released by this routine. myprocessor is always the current - * processor, and pset must be its processor set. - * This routine chooses and removes a thread from the runq if there - * is one (and returns it), else it sets the processor idle and - * returns its idle thread. + * Routine to calculate cumulative running counts for each scheduling + * bucket. This effectively lets the load calculation calculate if a + * cluster is running any threads at a QoS lower than the thread being + * migrated etc. */ -thread_t -choose_pset_thread( - register processor_t myprocessor, - processor_set_t pset) -{ - register run_queue_t runq; - register thread_t thread; - register queue_t q; - - runq = &pset->runq; - if (runq->count > 0) { - q = runq->queues + runq->highq; -#if MACH_ASSERT - if (!queue_empty(q)) { -#endif /*MACH_ASSERT*/ - thread = (thread_t)q->next; - ((queue_entry_t)thread)->next->prev = q; - q->next = ((queue_entry_t)thread)->next; - thread->runq = RUN_QUEUE_NULL; - runq->count--; - if (queue_empty(q)) { - if (runq->highq != IDLEPRI) - clrbit(MAXPRI - runq->highq, runq->bitmap); - runq->highq = MAXPRI - ffsbit(runq->bitmap); - } - simple_unlock(&runq->lock); - return (thread); -#if MACH_ASSERT - } - panic("choose_pset_thread"); -#endif /*MACH_ASSERT*/ - /*NOTREACHED*/ - } - simple_unlock(&runq->lock); - /* - * Nothing is runnable, so set this processor idle if it - * was running. If it was in an assignment or shutdown, - * leave it alone. Return its idle thread. - */ - simple_lock(&pset->idle_lock); - if (myprocessor->state == PROCESSOR_RUNNING) { - myprocessor->state = PROCESSOR_IDLE; - /* - * XXX Until it goes away, put master on end of queue, others - * XXX on front so master gets used last. - */ - if (myprocessor == master_processor) - queue_enter(&(pset->idle_queue), myprocessor, - processor_t, processor_queue); - else - queue_enter_first(&(pset->idle_queue), myprocessor, - processor_t, processor_queue); +static void +sched_edge_pset_running_higher_bucket(processor_set_t pset, uint32_t *running_higher) +{ + bitmap_t *active_map = &pset->cpu_state_map[PROCESSOR_RUNNING]; - pset->idle_count++; + /* Edge Scheduler Optimization */ + for (int cpu = bitmap_first(active_map, MAX_CPUS); cpu >= 0; cpu = bitmap_next(active_map, cpu)) { + sched_bucket_t cpu_bucket = os_atomic_load(&pset->cpu_running_buckets[cpu], relaxed); + for (sched_bucket_t bucket = cpu_bucket; bucket < TH_BUCKET_SCHED_MAX; bucket++) { + running_higher[bucket]++; + } } - simple_unlock(&pset->idle_lock); - - return (myprocessor->idle_thread); } /* - * no_dispatch_count counts number of times processors go non-idle - * without being dispatched. This should be very rare. - */ -int no_dispatch_count = 0; - -/* - * This is the idle thread, which just looks for other threads - * to execute. + * sched_update_pset_load_average() + * + * Updates the load average for each sched bucket for a cluster. + * This routine must be called with the pset lock held. */ void -idle_thread_continue(void) +sched_update_pset_load_average(processor_set_t pset, uint64_t curtime) { - register processor_t myprocessor; - register volatile thread_t *threadp; - register volatile int *gcount; - register volatile int *lcount; - register thread_t new_thread; - register int state; - register processor_set_t pset; - int mycpu; - - mycpu = cpu_number(); - myprocessor = current_processor(); - threadp = (volatile thread_t *) &myprocessor->next_thread; - lcount = (volatile int *) &myprocessor->runq.count; - - for (;;) { -#ifdef MARK_CPU_IDLE - MARK_CPU_IDLE(mycpu); -#endif /* MARK_CPU_IDLE */ + if (pset->online_processor_count == 0) { + /* Looks like the pset is not runnable any more; nothing to do here */ + return; + } - gcount = (volatile int *)&myprocessor->processor_set->runq.count; + /* + * Edge Scheduler Optimization + * + * See if more callers of this routine can pass in timestamps to avoid the + * mach_absolute_time() call here. + */ - (void)splsched(); - while ( (*threadp == (volatile thread_t)THREAD_NULL) && - (*gcount == 0) && (*lcount == 0) ) { + if (!curtime) { + curtime = mach_absolute_time(); + } + uint64_t last_update = os_atomic_load(&pset->pset_load_last_update, relaxed); + int64_t delta_ticks = curtime - last_update; + if (delta_ticks < 0) { + return; + } - /* check for ASTs while we wait */ + uint64_t delta_nsecs = 0; + absolutetime_to_nanoseconds(delta_ticks, &delta_nsecs); - if (need_ast[mycpu] &~ (AST_SCHEDULING|AST_URGENT|AST_BSD|AST_BSD_INIT)) { - /* don't allow scheduling ASTs */ - need_ast[mycpu] &= ~(AST_SCHEDULING|AST_URGENT|AST_BSD|AST_BSD_INIT); - ast_taken(FALSE, AST_ALL, TRUE); /* back at spllo */ - } - else -#ifdef __ppc__ - machine_idle(); -#else - (void)spllo(); -#endif - machine_clock_assist(); + if (__improbable(delta_nsecs > UINT32_MAX)) { + delta_nsecs = UINT32_MAX; + } - (void)splsched(); - } + uint32_t running_higher[TH_BUCKET_SCHED_MAX] = {0}; + sched_edge_pset_running_higher_bucket(pset, running_higher); -#ifdef MARK_CPU_ACTIVE - (void)spllo(); - MARK_CPU_ACTIVE(mycpu); - (void)splsched(); -#endif /* MARK_CPU_ACTIVE */ + for (sched_bucket_t sched_bucket = TH_BUCKET_FIXPRI; sched_bucket < TH_BUCKET_SCHED_MAX; sched_bucket++) { + uint64_t old_load_average = os_atomic_load(&pset->pset_load_average[sched_bucket], relaxed); + uint64_t old_load_average_factor = old_load_average * SCHED_PSET_LOAD_EWMA_TC_NSECS; + uint32_t current_runq_depth = (sched_edge_cluster_cumulative_count(&pset->pset_clutch_root, sched_bucket) + rt_runq_count(pset) + running_higher[sched_bucket]) / pset->online_processor_count; /* - * This is not a switch statement to avoid the - * bounds checking code in the common case. + * For the new load average multiply current_runq_depth by delta_nsecs (which resuts in a 32.0 value). + * Since we want to maintain the load average as a 24.8 fixed arithmetic value for precision, the + * new load averga needs to be shifted before it can be added to the old load average. */ - pset = myprocessor->processor_set; - simple_lock(&pset->idle_lock); -retry: - state = myprocessor->state; - if (state == PROCESSOR_DISPATCHING) { - /* - * Commmon case -- cpu dispatched. - */ - new_thread = *threadp; - *threadp = (volatile thread_t) THREAD_NULL; - myprocessor->state = PROCESSOR_RUNNING; - simple_unlock(&pset->idle_lock); - - thread_lock(new_thread); - simple_lock(&myprocessor->runq.lock); - simple_lock(&pset->runq.lock); - if ( myprocessor->runq.highq > new_thread->sched_pri || - pset->runq.highq > new_thread->sched_pri ) { - simple_unlock(&pset->runq.lock); - simple_unlock(&myprocessor->runq.lock); - - if (new_thread->bound_processor != PROCESSOR_NULL) - run_queue_enqueue(&myprocessor->runq, new_thread, HEAD_Q); - else - run_queue_enqueue(&pset->runq, new_thread, HEAD_Q); - thread_unlock(new_thread); - - counter(c_idle_thread_block++); - thread_block(idle_thread_continue); - } - else { - simple_unlock(&pset->runq.lock); - simple_unlock(&myprocessor->runq.lock); - - /* - * set up quantum for new thread. - */ - if (new_thread->policy & (POLICY_RR|POLICY_FIFO)) - myprocessor->quantum = new_thread->unconsumed_quantum; - else - myprocessor->quantum = pset->set_quantum; - thread_unlock(new_thread); - - myprocessor->first_quantum = TRUE; - counter(c_idle_thread_handoff++); - thread_run(myprocessor->idle_thread, - idle_thread_continue, new_thread); - } - } - else - if (state == PROCESSOR_IDLE) { - if (myprocessor->state != PROCESSOR_IDLE) { - /* - * Something happened, try again. - */ - goto retry; - } - /* - * Processor was not dispatched (Rare). - * Set it running again. - */ - no_dispatch_count++; - pset->idle_count--; - queue_remove(&pset->idle_queue, myprocessor, - processor_t, processor_queue); - myprocessor->state = PROCESSOR_RUNNING; - simple_unlock(&pset->idle_lock); - - counter(c_idle_thread_block++); - thread_block(idle_thread_continue); - } - else - if ( state == PROCESSOR_ASSIGN || - state == PROCESSOR_SHUTDOWN ) { - /* - * Changing processor sets, or going off-line. - * Release next_thread if there is one. Actual - * thread to run is on a runq. - */ - if ((new_thread = (thread_t)*threadp) != THREAD_NULL) { - *threadp = (volatile thread_t) THREAD_NULL; - simple_unlock(&pset->idle_lock); - thread_lock(new_thread); - thread_setrun(new_thread, FALSE, TAIL_Q); - thread_unlock(new_thread); - } else - simple_unlock(&pset->idle_lock); - - counter(c_idle_thread_block++); - thread_block(idle_thread_continue); - } - else { - simple_unlock(&pset->idle_lock); - printf("Bad processor state %d (Cpu %d)\n", - cpu_state(mycpu), mycpu); - panic("idle_thread"); + uint64_t new_load_average_factor = (current_runq_depth * delta_nsecs) << SCHED_PSET_LOAD_EWMA_FRACTION_BITS; + /* + * For extremely parallel workloads, it is important that the load average on a cluster moves zero to non-zero + * instantly to allow threads to be migrated to other (potentially idle) clusters quickly. Hence use the EWMA + * when the system is already loaded; otherwise for an idle system use the latest load average immediately. + */ + int old_load_shifted = (int)((old_load_average + SCHED_PSET_LOAD_EWMA_ROUND_BIT) >> SCHED_PSET_LOAD_EWMA_FRACTION_BITS); + boolean_t load_uptick = (old_load_shifted == 0) && (current_runq_depth != 0); + boolean_t load_downtick = (old_load_shifted != 0) && (current_runq_depth == 0); + uint64_t load_average; + if (load_uptick || load_downtick) { + load_average = (current_runq_depth << SCHED_PSET_LOAD_EWMA_FRACTION_BITS); + } else { + /* Indicates a loaded system; use EWMA for load average calculation */ + load_average = (old_load_average_factor + new_load_average_factor) / (delta_nsecs + SCHED_PSET_LOAD_EWMA_TC_NSECS); } - - (void)spllo(); + os_atomic_store(&pset->pset_load_average[sched_bucket], load_average, relaxed); + KDBG(MACHDBG_CODE(DBG_MACH_SCHED_CLUTCH, MACH_SCHED_EDGE_LOAD_AVG) | DBG_FUNC_NONE, pset->pset_cluster_id, (load_average >> SCHED_PSET_LOAD_EWMA_FRACTION_BITS), load_average & SCHED_PSET_LOAD_EWMA_FRACTION_MASK, sched_bucket); } + os_atomic_store(&pset->pset_load_last_update, curtime, relaxed); } void -idle_thread(void) +sched_update_pset_avg_execution_time(processor_set_t pset, uint64_t execution_time, uint64_t curtime, sched_bucket_t sched_bucket) { - thread_t self = current_thread(); - spl_t s; - - stack_privilege(self); - thread_swappable(current_act(), FALSE); - - s = splsched(); - thread_lock(self); + pset_execution_time_t old_execution_time_packed, new_execution_time_packed; + uint64_t avg_thread_execution_time = 0; + + os_atomic_rmw_loop(&pset->pset_execution_time[sched_bucket].pset_execution_time_packed, + old_execution_time_packed.pset_execution_time_packed, + new_execution_time_packed.pset_execution_time_packed, relaxed, { + uint64_t last_update = old_execution_time_packed.pset_execution_time_last_update; + int64_t delta_ticks = curtime - last_update; + if (delta_ticks < 0) { + /* + * Its possible that another CPU came in and updated the pset_execution_time + * before this CPU could do it. Since the average execution time is meant to + * be an approximate measure per cluster, ignore the older update. + */ + os_atomic_rmw_loop_give_up(return ); + } + uint64_t delta_nsecs = 0; + absolutetime_to_nanoseconds(delta_ticks, &delta_nsecs); - self->priority = IDLEPRI; - self->sched_pri = self->priority; + uint64_t nanotime = 0; + absolutetime_to_nanoseconds(execution_time, &nanotime); + uint64_t execution_time_us = nanotime / NSEC_PER_USEC; - thread_unlock(self); - splx(s); + uint64_t old_execution_time = (old_execution_time_packed.pset_avg_thread_execution_time * SCHED_PSET_LOAD_EWMA_TC_NSECS); + uint64_t new_execution_time = (execution_time_us * delta_nsecs); - counter(c_idle_thread_block++); - thread_block((void(*)(void))0); - idle_thread_continue(); - /*NOTREACHED*/ + avg_thread_execution_time = (old_execution_time + new_execution_time) / (delta_nsecs + SCHED_PSET_LOAD_EWMA_TC_NSECS); + new_execution_time_packed.pset_avg_thread_execution_time = avg_thread_execution_time; + new_execution_time_packed.pset_execution_time_last_update = curtime; + }); + KDBG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_PSET_AVG_EXEC_TIME) | DBG_FUNC_NONE, pset->pset_cluster_id, avg_thread_execution_time, sched_bucket); } -static AbsoluteTime sched_tick_interval, sched_tick_deadline; +#else /* CONFIG_SCHED_EDGE */ -/* - * sched_tick_thread - * - * Update the priorities of all threads periodically. - */ void -sched_tick_thread_continue(void) +sched_update_pset_load_average(processor_set_t pset, __unused uint64_t curtime) { - AbsoluteTime abstime; -#if SIMPLE_CLOCK - int new_usec; -#endif /* SIMPLE_CLOCK */ - - clock_get_uptime(&abstime); - - sched_tick++; /* age usage one more time */ -#if SIMPLE_CLOCK - /* - * Compensate for clock drift. sched_usec is an - * exponential average of the number of microseconds in - * a second. It decays in the same fashion as cpu_usage. - */ - new_usec = sched_usec_elapsed(); - sched_usec = (5*sched_usec + 3*new_usec)/8; -#endif /* SIMPLE_CLOCK */ + int non_rt_load = pset->pset_runq.count; + int load = ((bit_count(pset->cpu_state_map[PROCESSOR_RUNNING]) + non_rt_load + rt_runq_count(pset)) << PSET_LOAD_NUMERATOR_SHIFT); + int new_load_average = ((int)pset->load_average + load) >> 1; + + pset->load_average = new_load_average; +#if (DEVELOPMENT || DEBUG) +#if __AMP__ + if (pset->pset_cluster_type == PSET_AMP_P) { + KDBG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_PSET_LOAD_AVERAGE) | DBG_FUNC_NONE, sched_get_pset_load_average(pset, 0), (bit_count(pset->cpu_state_map[PROCESSOR_RUNNING]) + pset->pset_runq.count + rt_runq_count(pset))); + } +#endif +#endif +} - /* - * Compute the scheduler load factors. - */ - compute_mach_factor(); +void +sched_update_pset_avg_execution_time(__unused processor_set_t pset, __unused uint64_t execution_time, __unused uint64_t curtime, __unused sched_bucket_t sched_bucket) +{ +} +#endif /* CONFIG_SCHED_EDGE */ - /* - * Scan the run queues for runnable threads that need to - * have their priorities recalculated. - */ - do_thread_scan(); +/* pset is locked */ +static bool +processor_is_fast_track_candidate_for_realtime_thread(processor_set_t pset, processor_t processor) +{ + int cpuid = processor->cpu_id; +#if defined(__x86_64__) + if (sched_avoid_cpu0 && (cpuid == 0)) { + return false; + } +#endif - clock_deadline_for_periodic_event(sched_tick_interval, abstime, - &sched_tick_deadline); + cpumap_t fasttrack_map = pset_available_cpumap(pset) & ~pset->pending_AST_URGENT_cpu_mask & ~pset->realtime_map; - assert_wait((event_t)sched_tick_thread_continue, THREAD_INTERRUPTIBLE); - thread_set_timer_deadline(sched_tick_deadline); - thread_block(sched_tick_thread_continue); - /*NOTREACHED*/ + return bit_test(fasttrack_map, cpuid); } -void -sched_tick_thread(void) +/* pset is locked */ +static processor_t +choose_processor_for_realtime_thread(processor_set_t pset, processor_t skip_processor, bool consider_secondaries) { - thread_t self = current_thread(); - natural_t rate; - spl_t s; +#if defined(__x86_64__) + bool avoid_cpu0 = sched_avoid_cpu0 && bit_test(pset->cpu_bitmask, 0); +#else + const bool avoid_cpu0 = false; +#endif - stack_privilege(self); - thread_swappable(self->top_act, FALSE); + cpumap_t cpu_map = pset_available_cpumap(pset) & ~pset->pending_AST_URGENT_cpu_mask & ~pset->realtime_map; + if (skip_processor) { + bit_clear(cpu_map, skip_processor->cpu_id); + } - s = splsched(); - thread_lock(self); + cpumap_t primary_map = cpu_map & pset->primary_map; + if (avoid_cpu0) { + primary_map = bit_ror64(primary_map, 1); + } - self->priority = MAXPRI_STANDARD; - self->sched_pri = self->priority; + int rotid = lsb_first(primary_map); + if (rotid >= 0) { + int cpuid = avoid_cpu0 ? ((rotid + 1) & 63) : rotid; - thread_unlock(self); - splx(s); + processor_t processor = processor_array[cpuid]; - rate = (1000 >> SCHED_TICK_SHIFT); - clock_interval_to_absolutetime_interval(rate, USEC_PER_SEC, - &sched_tick_interval); - clock_get_uptime(&sched_tick_deadline); + return processor; + } - thread_block(sched_tick_thread_continue); - /*NOTREACHED*/ -} + if (!pset->is_SMT || !sched_allow_rt_smt || !consider_secondaries) { + goto out; + } -#define MAX_STUCK_THREADS 128 + /* Consider secondary processors */ + cpumap_t secondary_map = cpu_map & ~pset->primary_map; + if (avoid_cpu0) { + /* Also avoid cpu1 */ + secondary_map = bit_ror64(secondary_map, 2); + } + rotid = lsb_first(secondary_map); + if (rotid >= 0) { + int cpuid = avoid_cpu0 ? ((rotid + 2) & 63) : rotid; -/* - * do_thread_scan: scan for stuck threads. A thread is stuck if - * it is runnable but its priority is so low that it has not - * run for several seconds. Its priority should be higher, but - * won't be until it runs and calls update_priority. The scanner - * finds these threads and does the updates. - * - * Scanner runs in two passes. Pass one squirrels likely - * thread ids away in an array (takes out references for them). - * Pass two does the priority updates. This is necessary because - * the run queue lock is required for the candidate scan, but - * cannot be held during updates [set_pri will deadlock]. - * - * Array length should be enough so that restart isn't necessary, - * but restart logic is included. Does not scan processor runqs. - * - */ -thread_t stuck_threads[MAX_STUCK_THREADS]; -int stuck_count = 0; + processor_t processor = processor_array[cpuid]; -/* - * do_runq_scan is the guts of pass 1. It scans a runq for - * stuck threads. A boolean is returned indicating whether - * a retry is needed. - */ -boolean_t -do_runq_scan( - run_queue_t runq) -{ - register queue_t q; - register thread_t thread; - register int count; - spl_t s; - boolean_t result = FALSE; + return processor; + } - s = splsched(); - simple_lock(&runq->lock); - if ((count = runq->count) > 0) { - q = runq->queues + runq->highq; - while (count > 0) { - queue_iterate(q, thread, thread_t, links) { - if ( !(thread->state & (TH_WAIT|TH_SUSP)) && - thread->policy == POLICY_TIMESHARE ) { - if (thread->sched_stamp != sched_tick) { - /* - * Stuck, save its id for later. - */ - if (stuck_count == MAX_STUCK_THREADS) { - /* - * !@#$% No more room. - */ - simple_unlock(&runq->lock); - splx(s); - - return (TRUE); - } +out: + if (skip_processor) { + return PROCESSOR_NULL; + } - /* - * Inline version of thread_reference - * XXX - lock ordering problem here: - * thread locks should be taken before runq - * locks: just try and get the thread's locks - * and ignore this thread if we fail, we might - * have better luck next time. - */ - if (simple_lock_try(&thread->lock)) { - thread->ref_count++; - thread_unlock(thread); - stuck_threads[stuck_count++] = thread; - } - else - result = TRUE; - } - } + /* + * If we didn't find an obvious processor to choose, but there are still more CPUs + * not already running realtime threads than realtime threads in the realtime run queue, + * this thread belongs in this pset, so choose some other processor in this pset + * to ensure the thread is enqueued here. + */ + cpumap_t non_realtime_map = pset_available_cpumap(pset) & pset->primary_map & ~pset->realtime_map; + if (bit_count(non_realtime_map) > rt_runq_count(pset)) { + cpu_map = non_realtime_map; + assert(cpu_map != 0); + int cpuid = bit_first(cpu_map); + assert(cpuid >= 0); + return processor_array[cpuid]; + } - count--; - } + if (!pset->is_SMT || !sched_allow_rt_smt || !consider_secondaries) { + goto skip_secondaries; + } - q--; - } + non_realtime_map = pset_available_cpumap(pset) & ~pset->realtime_map; + if (bit_count(non_realtime_map) > rt_runq_count(pset)) { + cpu_map = non_realtime_map; + assert(cpu_map != 0); + int cpuid = bit_first(cpu_map); + assert(cpuid >= 0); + return processor_array[cpuid]; } - simple_unlock(&runq->lock); - splx(s); - return (result); +skip_secondaries: + return PROCESSOR_NULL; } -boolean_t thread_scan_enabled = TRUE; - -void -do_thread_scan(void) +/* pset is locked */ +static bool +all_available_primaries_are_running_realtime_threads(processor_set_t pset) { - register boolean_t restart_needed = FALSE; - register thread_t thread; - register processor_set_t pset = &default_pset; - register processor_t processor; - spl_t s; + cpumap_t cpu_map = pset_available_cpumap(pset) & pset->primary_map & ~pset->realtime_map; + return rt_runq_count(pset) > bit_count(cpu_map); +} - if (!thread_scan_enabled) - return; +#if defined(__x86_64__) +/* pset is locked */ +static bool +these_processors_are_running_realtime_threads(processor_set_t pset, uint64_t these_map) +{ + cpumap_t cpu_map = pset_available_cpumap(pset) & these_map & ~pset->realtime_map; + return rt_runq_count(pset) > bit_count(cpu_map); +} +#endif - do { - restart_needed = do_runq_scan(&pset->runq); - if (!restart_needed) { - simple_lock(&pset->processors_lock); - processor = (processor_t)queue_first(&pset->processors); - while (!queue_end(&pset->processors, (queue_entry_t)processor)) { - if (restart_needed = do_runq_scan(&processor->runq)) - break; - - processor = (processor_t)queue_next(&processor->processors); - } - simple_unlock(&pset->processors_lock); - } - - /* - * Ok, we now have a collection of candidates -- fix them. - */ - while (stuck_count > 0) { - thread = stuck_threads[--stuck_count]; - stuck_threads[stuck_count] = THREAD_NULL; - s = splsched(); - thread_lock(thread); - if (thread->policy == POLICY_TIMESHARE) { - if ( !(thread->state & (TH_WAIT|TH_SUSP)) && - thread->sched_stamp != sched_tick ) - update_priority(thread); - } - thread_unlock(thread); - splx(s); - thread_deallocate(thread); - } - - } while (restart_needed); +static bool +sched_ok_to_run_realtime_thread(processor_set_t pset, processor_t processor) +{ + bool ok_to_run_realtime_thread = true; +#if defined(__x86_64__) + if (sched_avoid_cpu0 && processor->cpu_id == 0) { + ok_to_run_realtime_thread = these_processors_are_running_realtime_threads(pset, pset->primary_map & ~0x1); + } else if (sched_avoid_cpu0 && (processor->cpu_id == 1) && processor->is_SMT) { + ok_to_run_realtime_thread = sched_allow_rt_smt && these_processors_are_running_realtime_threads(pset, ~0x2); + } else if (processor->processor_primary != processor) { + ok_to_run_realtime_thread = (sched_allow_rt_smt && all_available_primaries_are_running_realtime_threads(pset)); + } +#else + (void)pset; + (void)processor; +#endif + return ok_to_run_realtime_thread; } - -/* - * Just in case someone doesn't use the macro - */ -#undef thread_wakeup -void -thread_wakeup( - event_t x); void -thread_wakeup( - event_t x) +sched_pset_made_schedulable(__unused processor_t processor, processor_set_t pset, boolean_t drop_lock) { - thread_wakeup_with_result(x, THREAD_AWAKENED); + if (drop_lock) { + pset_unlock(pset); + } } -boolean_t -thread_runnable( - thread_t thread) +void +thread_set_no_smt(bool set) { - sched_policy_t *policy; + if (!system_is_SMT) { + /* Not a machine that supports SMT */ + return; + } - /* Ask sched policy if thread is runnable */ - policy = policy_id_to_sched_policy(thread->policy); + thread_t thread = current_thread(); - return ((policy != SCHED_POLICY_NULL)? - policy->sp_ops.sp_thread_runnable(policy, thread) : FALSE); + spl_t s = splsched(); + thread_lock(thread); + if (set) { + thread->sched_flags |= TH_SFLAG_NO_SMT; + } + thread_unlock(thread); + splx(s); } -#if DEBUG - -void -dump_processor_set( - processor_set_t ps) -{ - printf("processor_set: %08x\n",ps); - printf("idle_queue: %08x %08x, idle_count: 0x%x\n", - ps->idle_queue.next,ps->idle_queue.prev,ps->idle_count); - printf("processors: %08x %08x, processor_count: 0x%x\n", - ps->processors.next,ps->processors.prev,ps->processor_count); - printf("tasks: %08x %08x, task_count: 0x%x\n", - ps->tasks.next,ps->tasks.prev,ps->task_count); - printf("threads: %08x %08x, thread_count: 0x%x\n", - ps->threads.next,ps->threads.prev,ps->thread_count); - printf("ref_count: 0x%x, active: %x\n", - ps->ref_count,ps->active); - printf("pset_self: %08x, pset_name_self: %08x\n",ps->pset_self, ps->pset_name_self); - printf("max_priority: 0x%x, policies: 0x%x, set_quantum: 0x%x\n", - ps->max_priority, ps->policies, ps->set_quantum); -} - -#define processor_state(s) (((s)>PROCESSOR_SHUTDOWN)?"*unknown*":states[s]) +bool +thread_get_no_smt(void) +{ + return current_thread()->sched_flags & TH_SFLAG_NO_SMT; +} +extern void task_set_no_smt(task_t); void -dump_processor( - processor_t p) +task_set_no_smt(task_t task) { - char *states[]={"OFF_LINE","RUNNING","IDLE","DISPATCHING", - "ASSIGN","SHUTDOWN"}; + if (!system_is_SMT) { + /* Not a machine that supports SMT */ + return; + } + + if (task == TASK_NULL) { + task = current_task(); + } - printf("processor: %08x\n",p); - printf("processor_queue: %08x %08x\n", - p->processor_queue.next,p->processor_queue.prev); - printf("state: %8s, next_thread: %08x, idle_thread: %08x\n", - processor_state(p->state), p->next_thread, p->idle_thread); - printf("quantum: %u, first_quantum: %x, last_quantum: %u\n", - p->quantum, p->first_quantum, p->last_quantum); - printf("processor_set: %08x, processor_set_next: %08x\n", - p->processor_set, p->processor_set_next); - printf("processors: %08x %08x\n", p->processors.next,p->processors.prev); - printf("processor_self: %08x, slot_num: 0x%x\n", p->processor_self, p->slot_num); + task_lock(task); + task->t_flags |= TF_NO_SMT; + task_unlock(task); } +#if DEBUG || DEVELOPMENT +extern void sysctl_task_set_no_smt(char no_smt); void -dump_run_queue_struct( - run_queue_t rq) +sysctl_task_set_no_smt(char no_smt) { - char dump_buf[80]; - int i; + if (!system_is_SMT) { + /* Not a machine that supports SMT */ + return; + } - for( i=0; i < NRQS; ) { - int j; + task_t task = current_task(); - printf("%6s",(i==0)?"runq:":""); - for( j=0; (j<8) && (i < NRQS); j++,i++ ) { - if( rq->queues[i].next == &rq->queues[i] ) - printf( " --------"); - else - printf(" %08x",rq->queues[i].next); + task_lock(task); + if (no_smt == '1') { + task->t_flags |= TF_NO_SMT; } - printf("\n"); - } - for( i=0; i < NRQBM; ) { - register unsigned int mask; - char *d=dump_buf; - - mask = ~0; - mask ^= (mask>>1); + task_unlock(task); +} - do { - *d++ = ((rq->bitmap[i]&mask)?'r':'e'); - mask >>=1; - } while( mask ); - *d = '\0'; - printf("%8s%s\n",((i==0)?"bitmap:":""),dump_buf); - i++; - } - printf("highq: 0x%x, count: %u\n", rq->highq, rq->count); -} - -void -dump_run_queues( - run_queue_t runq) +extern char sysctl_task_get_no_smt(void); +char +sysctl_task_get_no_smt(void) { - register queue_t q1; - register int i; - register queue_entry_t e; - - q1 = runq->queues; - for (i = 0; i < NRQS; i++) { - if (q1->next != q1) { - int t_cnt; + task_t task = current_task(); - printf("[%u]",i); - for (t_cnt=0, e = q1->next; e != q1; e = e->next) { - printf("\t0x%08x",e); - if( (t_cnt = ++t_cnt%4) == 0 ) - printf("\n"); - } - if( t_cnt ) - printf("\n"); - } - /* else - printf("[%u]\t\n",i); - */ - q1++; + if (task->t_flags & TF_NO_SMT) { + return '1'; } + return '0'; } +#endif /* DEVELOPMENT || DEBUG */ -void -checkrq( - run_queue_t rq, - char *msg) -{ - register queue_t q1; - register int i, j; - register queue_entry_t e; - register int highq; - - highq = NRQS; - j = 0; - q1 = rq->queues; - for (i = MAXPRI; i >= 0; i--) { - if (q1->next == q1) { - if (q1->prev != q1) { - panic("checkrq: empty at %s", msg); - } - } - else { - if (highq == -1) - highq = i; - - for (e = q1->next; e != q1; e = e->next) { - j++; - if (e->next->prev != e) - panic("checkrq-2 at %s", msg); - if (e->prev->next != e) - panic("checkrq-3 at %s", msg); - } - } - q1++; - } - if (j != rq->count) - panic("checkrq: count wrong at %s", msg); - if (rq->count != 0 && highq > rq->highq) - panic("checkrq: highq wrong at %s", msg); + +__private_extern__ void +thread_bind_cluster_type(thread_t thread, char cluster_type, bool soft_bound) +{ +#if __AMP__ + spl_t s = splsched(); + thread_lock(thread); + thread->sched_flags &= ~(TH_SFLAG_ECORE_ONLY | TH_SFLAG_PCORE_ONLY | TH_SFLAG_BOUND_SOFT); + if (soft_bound) { + thread->sched_flags |= TH_SFLAG_BOUND_SOFT; + } + switch (cluster_type) { + case 'e': + case 'E': + thread->sched_flags |= TH_SFLAG_ECORE_ONLY; + break; + case 'p': + case 'P': + thread->sched_flags |= TH_SFLAG_PCORE_ONLY; + break; + default: + break; + } + thread_unlock(thread); + splx(s); + + if (thread == current_thread()) { + thread_block(THREAD_CONTINUE_NULL); + } +#else /* __AMP__ */ + (void)thread; + (void)cluster_type; + (void)soft_bound; +#endif /* __AMP__ */ } -void -thread_check( - register thread_t thread, - register run_queue_t rq) +#if DEVELOPMENT || DEBUG +extern int32_t sysctl_get_bound_cpuid(void); +int32_t +sysctl_get_bound_cpuid(void) { - register int whichq = thread->sched_pri; - register queue_entry_t queue, entry; + int32_t cpuid = -1; + thread_t self = current_thread(); - if (whichq < MINPRI || whichq > MAXPRI) - panic("thread_check: bad pri"); + processor_t processor = self->bound_processor; + if (processor == NULL) { + cpuid = -1; + } else { + cpuid = processor->cpu_id; + } - if (whichq != thread->whichq) - panic("thread_check: whichq"); + return cpuid; +} - queue = &rq->queues[whichq]; - entry = queue_first(queue); - while (!queue_end(queue, entry)) { - if (entry == (queue_entry_t)thread) - return; +extern kern_return_t sysctl_thread_bind_cpuid(int32_t cpuid); +kern_return_t +sysctl_thread_bind_cpuid(int32_t cpuid) +{ + processor_t processor = PROCESSOR_NULL; - entry = queue_next(entry); + if (cpuid == -1) { + goto unbind; } - panic("thread_check: not found"); -} + if (cpuid < 0 || cpuid >= MAX_SCHED_CPUS) { + return KERN_INVALID_VALUE; + } + + processor = processor_array[cpuid]; + if (processor == PROCESSOR_NULL) { + return KERN_INVALID_VALUE; + } -#endif /* DEBUG */ +#if __AMP__ -#if MACH_KDB -#include -#define printf kdbprintf -extern int db_indent; -void db_sched(void); + thread_t thread = current_thread(); -void -db_sched(void) -{ - iprintf("Scheduling Statistics:\n"); - db_indent += 2; - iprintf("Thread invocations: csw %d same %d\n", - c_thread_invoke_csw, c_thread_invoke_same); -#if MACH_COUNTERS - iprintf("Thread block: calls %d\n", - c_thread_block_calls); - iprintf("Idle thread:\n\thandoff %d block %d no_dispatch %d\n", - c_idle_thread_handoff, - c_idle_thread_block, no_dispatch_count); - iprintf("Sched thread blocks: %d\n", c_sched_thread_block); -#endif /* MACH_COUNTERS */ - db_indent -= 2; -} -#endif /* MACH_KDB */ + if (thread->sched_flags & (TH_SFLAG_ECORE_ONLY | TH_SFLAG_PCORE_ONLY)) { + if ((thread->sched_flags & TH_SFLAG_BOUND_SOFT) == 0) { + /* Cannot hard-bind an already hard-cluster-bound thread */ + return KERN_NOT_SUPPORTED; + } + } + +#endif /* __AMP__ */ + +unbind: + thread_bind(processor); + + thread_block(THREAD_CONTINUE_NULL); + return KERN_SUCCESS; +} +#endif /* DEVELOPMENT || DEBUG */