X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/6d2010ae8f7a6078e10b361c6962983bab233e0f..fe8ab488e9161c46dd9885d58fc52996dc0249ff:/osfmk/kern/sched_prim.c diff --git a/osfmk/kern/sched_prim.c b/osfmk/kern/sched_prim.c index c73ef0f3d..3a88e11fb 100644 --- a/osfmk/kern/sched_prim.c +++ b/osfmk/kern/sched_prim.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000-2009 Apple Inc. All rights reserved. + * Copyright (c) 2000-2012 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * @@ -65,9 +65,6 @@ */ #include -#include - -#include #include #include @@ -80,13 +77,16 @@ #include #include +#ifdef CONFIG_MACH_APPROXIMATE_TIME +#include +#endif + #include #include #include #include #include #include -#include #include #include #include @@ -94,10 +94,13 @@ #include #include #include +#include #include #include #include #include +#include +#include #include #include @@ -109,19 +112,26 @@ #include +#if defined(CONFIG_TELEMETRY) && defined(CONFIG_SCHED_TIMESHARE_CORE) +#include +#endif + struct rt_queue rt_runq; #define RT_RUNQ ((processor_t)-1) decl_simple_lock_data(static,rt_lock); -#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY) +#if defined(CONFIG_SCHED_FAIRSHARE_CORE) static struct fairshare_queue fs_runq; #define FS_RUNQ ((processor_t)-2) decl_simple_lock_data(static,fs_lock); -#endif +#endif /* CONFIG_SCHED_FAIRSHARE_CORE */ #define DEFAULT_PREEMPTION_RATE 100 /* (1/s) */ int default_preemption_rate = DEFAULT_PREEMPTION_RATE; +#define DEFAULT_BG_PREEMPTION_RATE 400 /* (1/s) */ +int default_bg_preemption_rate = DEFAULT_BG_PREEMPTION_RATE; + #define MAX_UNSAFE_QUANTA 800 int max_unsafe_quanta = MAX_UNSAFE_QUANTA; @@ -136,14 +146,16 @@ uint64_t max_poll_computation; uint64_t max_unsafe_computation; uint64_t sched_safe_duration; -#if defined(CONFIG_SCHED_TRADITIONAL) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) uint32_t std_quantum; uint32_t min_std_quantum; +uint32_t bg_quantum; uint32_t std_quantum_us; +uint32_t bg_quantum_us; -#endif /* CONFIG_SCHED_TRADITIONAL */ +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ uint32_t thread_depress_time; uint32_t default_timeshare_computation; @@ -152,15 +164,40 @@ uint32_t default_timeshare_constraint; uint32_t max_rt_quantum; uint32_t min_rt_quantum; -uint32_t sched_cswtime; - -#if defined(CONFIG_SCHED_TRADITIONAL) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) unsigned sched_tick; uint32_t sched_tick_interval; +#if defined(CONFIG_TELEMETRY) +uint32_t sched_telemetry_interval; +#endif /* CONFIG_TELEMETRY */ uint32_t sched_pri_shift = INT8_MAX; +uint32_t sched_background_pri_shift = INT8_MAX; +uint32_t sched_combined_fgbg_pri_shift = INT8_MAX; uint32_t sched_fixed_shift; +uint32_t sched_use_combined_fgbg_decay = 0; + +uint32_t sched_decay_usage_age_factor = 1; /* accelerate 5/8^n usage aging */ + +/* 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; + +/* 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 */ + +uint64_t timer_deadline_tracking_bin_1; +uint64_t timer_deadline_tracking_bin_2; + +thread_t sched_maintenance_thread; + +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + +#if defined(CONFIG_SCHED_TRADITIONAL) static boolean_t sched_traditional_use_pset_runqueue = FALSE; @@ -205,21 +242,22 @@ static inline void runq_consider_decr_bound_count(processor_t processor, thread_ uint64_t sched_one_second_interval; -uint32_t sched_run_count, sched_share_count; +uint32_t sched_run_count, sched_share_count, sched_background_count; uint32_t sched_load_average, sched_mach_factor; /* Forwards */ -#if defined(CONFIG_SCHED_TRADITIONAL) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) -static void load_shift_init(void) __attribute__((section("__TEXT, initcode"))); -static void preempt_pri_init(void) __attribute__((section("__TEXT, initcode"))); +static void load_shift_init(void); +static void preempt_pri_init(void); -#endif /* CONFIG_SCHED_TRADITIONAL */ +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ static thread_t thread_select( thread_t thread, - processor_t processor); + processor_t processor, + ast_t reason); #if CONFIG_SCHED_IDLE_IN_PLACE static thread_t thread_select_idle( @@ -231,6 +269,11 @@ thread_t processor_idle( thread_t thread, processor_t processor); +ast_t +csw_check_locked( processor_t processor, + processor_set_t pset, + ast_t check_reason); + #if defined(CONFIG_SCHED_TRADITIONAL) static thread_t steal_thread( @@ -263,8 +306,6 @@ processor_queue_remove( static boolean_t processor_queue_empty(processor_t processor); -static boolean_t priority_is_urgent(int priority); - static ast_t processor_csw_check(processor_t processor); static boolean_t processor_queue_has_priority(processor_t processor, @@ -280,16 +321,13 @@ static boolean_t sched_traditional_with_pset_runqueue_processor_queue_empty(proc static uint64_t sched_traditional_processor_runq_stats_count_sum(processor_t processor); static uint64_t sched_traditional_with_pset_runqueue_processor_runq_stats_count_sum(processor_t processor); -#endif - -#if defined(CONFIG_SCHED_TRADITIONAL) +static int sched_traditional_processor_bound_count(processor_t processor); -static void -sched_traditional_init(void); +#endif -static void -sched_traditional_timebase_init(void); + +#if defined(CONFIG_SCHED_TRADITIONAL) static void sched_traditional_processor_init(processor_t processor); @@ -303,28 +341,24 @@ sched_traditional_with_pset_runqueue_init(void); #endif static void -sched_realtime_init(void) __attribute__((section("__TEXT, initcode"))); +sched_realtime_init(void); static void sched_realtime_timebase_init(void); -#if defined(CONFIG_SCHED_TRADITIONAL) static void -sched_traditional_tick_continue(void); +sched_timer_deadline_tracking_init(void); -static uint32_t -sched_traditional_initial_quantum_size(thread_t thread); +#if defined(CONFIG_SCHED_TRADITIONAL) static sched_mode_t sched_traditional_initial_thread_sched_mode(task_t parent_task); -static boolean_t -sched_traditional_supports_timeshare_mode(void); - static thread_t sched_traditional_choose_thread( - processor_t processor, - int priority); + processor_t processor, + int priority, + __unused ast_t reason); #endif @@ -335,13 +369,10 @@ extern int debug_task; #define TLOG(a, fmt, args...) do {} while (0) #endif -#if DEBUG -static +__assert_only static boolean_t thread_runnable( thread_t thread); -#endif /*DEBUG*/ - /* * State machine * @@ -368,84 +399,86 @@ boolean_t thread_runnable( * */ -#if defined(CONFIG_SCHED_TRADITIONAL) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) int8_t sched_load_shifts[NRQS]; int sched_preempt_pri[NRQBM]; -#endif +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ #if defined(CONFIG_SCHED_TRADITIONAL) const struct sched_dispatch_table sched_traditional_dispatch = { - sched_traditional_init, - sched_traditional_timebase_init, - sched_traditional_processor_init, - sched_traditional_pset_init, - sched_traditional_tick_continue, - sched_traditional_choose_thread, - steal_thread, - compute_priority, - choose_processor, - processor_enqueue, - processor_queue_shutdown, - processor_queue_remove, - processor_queue_empty, - priority_is_urgent, - processor_csw_check, - processor_queue_has_priority, - sched_traditional_initial_quantum_size, - sched_traditional_initial_thread_sched_mode, - sched_traditional_supports_timeshare_mode, - can_update_priority, - update_priority, - lightweight_update_priority, - sched_traditional_quantum_expire, - should_current_thread_rechoose_processor, - sched_traditional_processor_runq_count, - sched_traditional_processor_runq_stats_count_sum, - sched_traditional_fairshare_init, - sched_traditional_fairshare_runq_count, - sched_traditional_fairshare_runq_stats_count_sum, - sched_traditional_fairshare_enqueue, - sched_traditional_fairshare_dequeue, - sched_traditional_fairshare_queue_remove, - TRUE /* direct_dispatch_to_idle_processors */ + .init = sched_traditional_init, + .timebase_init = sched_traditional_timebase_init, + .processor_init = sched_traditional_processor_init, + .pset_init = sched_traditional_pset_init, + .maintenance_continuation = sched_traditional_maintenance_continue, + .choose_thread = sched_traditional_choose_thread, + .steal_thread = steal_thread, + .compute_priority = compute_priority, + .choose_processor = choose_processor, + .processor_enqueue = processor_enqueue, + .processor_queue_shutdown = processor_queue_shutdown, + .processor_queue_remove = processor_queue_remove, + .processor_queue_empty = processor_queue_empty, + .priority_is_urgent = priority_is_urgent, + .processor_csw_check = processor_csw_check, + .processor_queue_has_priority = processor_queue_has_priority, + .initial_quantum_size = sched_traditional_initial_quantum_size, + .initial_thread_sched_mode = sched_traditional_initial_thread_sched_mode, + .can_update_priority = can_update_priority, + .update_priority = update_priority, + .lightweight_update_priority = lightweight_update_priority, + .quantum_expire = sched_traditional_quantum_expire, + .should_current_thread_rechoose_processor = should_current_thread_rechoose_processor, + .processor_runq_count = sched_traditional_processor_runq_count, + .processor_runq_stats_count_sum = sched_traditional_processor_runq_stats_count_sum, + .fairshare_init = sched_traditional_fairshare_init, + .fairshare_runq_count = sched_traditional_fairshare_runq_count, + .fairshare_runq_stats_count_sum = sched_traditional_fairshare_runq_stats_count_sum, + .fairshare_enqueue = sched_traditional_fairshare_enqueue, + .fairshare_dequeue = sched_traditional_fairshare_dequeue, + .fairshare_queue_remove = sched_traditional_fairshare_queue_remove, + .processor_bound_count = sched_traditional_processor_bound_count, + .thread_update_scan = thread_update_scan, + .direct_dispatch_to_idle_processors = TRUE, }; const struct sched_dispatch_table sched_traditional_with_pset_runqueue_dispatch = { - sched_traditional_with_pset_runqueue_init, - sched_traditional_timebase_init, - sched_traditional_processor_init, - sched_traditional_pset_init, - sched_traditional_tick_continue, - sched_traditional_choose_thread, - steal_thread, - compute_priority, - choose_processor, - processor_enqueue, - processor_queue_shutdown, - processor_queue_remove, - sched_traditional_with_pset_runqueue_processor_queue_empty, - priority_is_urgent, - processor_csw_check, - processor_queue_has_priority, - sched_traditional_initial_quantum_size, - sched_traditional_initial_thread_sched_mode, - sched_traditional_supports_timeshare_mode, - can_update_priority, - update_priority, - lightweight_update_priority, - sched_traditional_quantum_expire, - should_current_thread_rechoose_processor, - sched_traditional_processor_runq_count, - sched_traditional_with_pset_runqueue_processor_runq_stats_count_sum, - sched_traditional_fairshare_init, - sched_traditional_fairshare_runq_count, - sched_traditional_fairshare_runq_stats_count_sum, - sched_traditional_fairshare_enqueue, - sched_traditional_fairshare_dequeue, - sched_traditional_fairshare_queue_remove, - FALSE /* direct_dispatch_to_idle_processors */ + .init = sched_traditional_with_pset_runqueue_init, + .timebase_init = sched_traditional_timebase_init, + .processor_init = sched_traditional_processor_init, + .pset_init = sched_traditional_pset_init, + .maintenance_continuation = sched_traditional_maintenance_continue, + .choose_thread = sched_traditional_choose_thread, + .steal_thread = steal_thread, + .compute_priority = compute_priority, + .choose_processor = choose_processor, + .processor_enqueue = processor_enqueue, + .processor_queue_shutdown = processor_queue_shutdown, + .processor_queue_remove = processor_queue_remove, + .processor_queue_empty = sched_traditional_with_pset_runqueue_processor_queue_empty, + .priority_is_urgent = priority_is_urgent, + .processor_csw_check = processor_csw_check, + .processor_queue_has_priority = processor_queue_has_priority, + .initial_quantum_size = sched_traditional_initial_quantum_size, + .initial_thread_sched_mode = sched_traditional_initial_thread_sched_mode, + .can_update_priority = can_update_priority, + .update_priority = update_priority, + .lightweight_update_priority = lightweight_update_priority, + .quantum_expire = sched_traditional_quantum_expire, + .should_current_thread_rechoose_processor = should_current_thread_rechoose_processor, + .processor_runq_count = sched_traditional_processor_runq_count, + .processor_runq_stats_count_sum = sched_traditional_with_pset_runqueue_processor_runq_stats_count_sum, + .fairshare_init = sched_traditional_fairshare_init, + .fairshare_runq_count = sched_traditional_fairshare_runq_count, + .fairshare_runq_stats_count_sum = sched_traditional_fairshare_runq_stats_count_sum, + .fairshare_enqueue = sched_traditional_fairshare_enqueue, + .fairshare_dequeue = sched_traditional_fairshare_dequeue, + .fairshare_queue_remove = sched_traditional_fairshare_queue_remove, + .processor_bound_count = sched_traditional_processor_bound_count, + .thread_update_scan = thread_update_scan, + .direct_dispatch_to_idle_processors = FALSE, }; #endif @@ -472,7 +505,10 @@ const struct sched_dispatch_table *sched_current_dispatch = NULL; #define SCHED_STRING_MAX_LENGTH (48) char sched_string[SCHED_STRING_MAX_LENGTH]; -static enum sched_enum _sched_enum = sched_enum_unknown; +static enum sched_enum _sched_enum __attribute__((used)) = sched_enum_unknown; + +/* Global flag which indicates whether Background Stepper Context is enabled */ +static int cpu_throttle_enabled = 1; void sched_init(void) @@ -488,6 +524,19 @@ sched_init(void) } } + + 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; + } + } + + kprintf("Setting scheduler priority decay band limit %d\n", sched_pri_decay_band_limit); + if (strlen(sched_arg) > 0) { if (0) { /* Allow pattern below */ @@ -496,73 +545,75 @@ sched_init(void) sched_current_dispatch = &sched_traditional_dispatch; _sched_enum = sched_enum_traditional; strlcpy(sched_string, kSchedTraditionalString, sizeof(sched_string)); - kprintf("Scheduler: Runtime selection of %s\n", kSchedTraditionalString); } else if (0 == strcmp(sched_arg, kSchedTraditionalWithPsetRunqueueString)) { sched_current_dispatch = &sched_traditional_with_pset_runqueue_dispatch; _sched_enum = sched_enum_traditional_with_pset_runqueue; strlcpy(sched_string, kSchedTraditionalWithPsetRunqueueString, sizeof(sched_string)); - kprintf("Scheduler: Runtime selection of %s\n", kSchedTraditionalWithPsetRunqueueString); #endif #if defined(CONFIG_SCHED_PROTO) } else if (0 == strcmp(sched_arg, kSchedProtoString)) { sched_current_dispatch = &sched_proto_dispatch; _sched_enum = sched_enum_proto; strlcpy(sched_string, kSchedProtoString, sizeof(sched_string)); - kprintf("Scheduler: Runtime selection of %s\n", kSchedProtoString); #endif #if defined(CONFIG_SCHED_GRRR) } else if (0 == strcmp(sched_arg, kSchedGRRRString)) { sched_current_dispatch = &sched_grrr_dispatch; _sched_enum = sched_enum_grrr; strlcpy(sched_string, kSchedGRRRString, sizeof(sched_string)); - kprintf("Scheduler: Runtime selection of %s\n", kSchedGRRRString); #endif -#if defined(CONFIG_SCHED_FIXEDPRIORITY) - } else if (0 == strcmp(sched_arg, kSchedFixedPriorityString)) { - sched_current_dispatch = &sched_fixedpriority_dispatch; - _sched_enum = sched_enum_fixedpriority; - strlcpy(sched_string, kSchedFixedPriorityString, sizeof(sched_string)); - kprintf("Scheduler: Runtime selection of %s\n", kSchedFixedPriorityString); - } else if (0 == strcmp(sched_arg, kSchedFixedPriorityWithPsetRunqueueString)) { - sched_current_dispatch = &sched_fixedpriority_with_pset_runqueue_dispatch; - _sched_enum = sched_enum_fixedpriority_with_pset_runqueue; - strlcpy(sched_string, kSchedFixedPriorityWithPsetRunqueueString, sizeof(sched_string)); - kprintf("Scheduler: Runtime selection of %s\n", kSchedFixedPriorityWithPsetRunqueueString); +#if defined(CONFIG_SCHED_MULTIQ) + } else if (0 == strcmp(sched_arg, kSchedMultiQString)) { + sched_current_dispatch = &sched_multiq_dispatch; + _sched_enum = sched_enum_multiq; + strlcpy(sched_string, kSchedMultiQString, sizeof(sched_string)); + } else if (0 == strcmp(sched_arg, kSchedDualQString)) { + sched_current_dispatch = &sched_dualq_dispatch; + _sched_enum = sched_enum_dualq; + strlcpy(sched_string, kSchedDualQString, sizeof(sched_string)); #endif } else { +#if defined(CONFIG_SCHED_TRADITIONAL) + printf("Unrecognized scheduler algorithm: %s\n", sched_arg); + printf("Scheduler: Using instead: %s\n", kSchedTraditionalWithPsetRunqueueString); + + sched_current_dispatch = &sched_traditional_with_pset_runqueue_dispatch; + _sched_enum = sched_enum_traditional_with_pset_runqueue; + strlcpy(sched_string, kSchedTraditionalWithPsetRunqueueString, sizeof(sched_string)); +#else panic("Unrecognized scheduler algorithm: %s", sched_arg); +#endif } + kprintf("Scheduler: Runtime selection of %s\n", sched_string); } else { -#if defined(CONFIG_SCHED_TRADITIONAL) - sched_current_dispatch = &sched_traditional_dispatch; - _sched_enum = sched_enum_traditional; - strlcpy(sched_string, kSchedTraditionalString, sizeof(sched_string)); - kprintf("Scheduler: Default of %s\n", kSchedTraditionalString); +#if defined(CONFIG_SCHED_MULTIQ) + sched_current_dispatch = &sched_multiq_dispatch; + _sched_enum = sched_enum_multiq; + strlcpy(sched_string, kSchedMultiQString, sizeof(sched_string)); +#elif defined(CONFIG_SCHED_TRADITIONAL) + sched_current_dispatch = &sched_traditional_with_pset_runqueue_dispatch; + _sched_enum = sched_enum_traditional_with_pset_runqueue; + strlcpy(sched_string, kSchedTraditionalWithPsetRunqueueString, sizeof(sched_string)); #elif defined(CONFIG_SCHED_PROTO) sched_current_dispatch = &sched_proto_dispatch; _sched_enum = sched_enum_proto; strlcpy(sched_string, kSchedProtoString, sizeof(sched_string)); - kprintf("Scheduler: Default of %s\n", kSchedProtoString); #elif defined(CONFIG_SCHED_GRRR) sched_current_dispatch = &sched_grrr_dispatch; _sched_enum = sched_enum_grrr; strlcpy(sched_string, kSchedGRRRString, sizeof(sched_string)); - kprintf("Scheduler: Default of %s\n", kSchedGRRRString); -#elif defined(CONFIG_SCHED_FIXEDPRIORITY) - sched_current_dispatch = &sched_fixedpriority_dispatch; - _sched_enum = sched_enum_fixedpriority; - strlcpy(sched_string, kSchedFixedPriorityString, sizeof(sched_string)); - kprintf("Scheduler: Default of %s\n", kSchedFixedPriorityString); #else #error No default scheduler implementation #endif + kprintf("Scheduler: Default of %s\n", sched_string); } SCHED(init)(); SCHED(fairshare_init)(); sched_realtime_init(); ast_init(); - + sched_timer_deadline_tracking_init(); + SCHED(pset_init)(&pset0); SCHED(processor_init)(master_processor); } @@ -579,9 +630,9 @@ sched_timebase_init(void) sched_realtime_timebase_init(); } -#if defined(CONFIG_SCHED_TRADITIONAL) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) -static void +void sched_traditional_init(void) { /* @@ -594,12 +645,18 @@ sched_traditional_init(void) printf("standard timeslicing quantum is %d us\n", std_quantum_us); + if (default_bg_preemption_rate < 1) + default_bg_preemption_rate = DEFAULT_BG_PREEMPTION_RATE; + bg_quantum_us = (1000 * 1000) / default_bg_preemption_rate; + + printf("standard background quantum is %d us\n", bg_quantum_us); + load_shift_init(); preempt_pri_init(); sched_tick = 0; } -static void +void sched_traditional_timebase_init(void) { uint64_t abstime; @@ -616,6 +673,12 @@ sched_traditional_timebase_init(void) 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); @@ -631,16 +694,27 @@ sched_traditional_timebase_init(void) abstime >>= 1; sched_fixed_shift = shift; - max_unsafe_computation = max_unsafe_quanta * std_quantum; - sched_safe_duration = 2 * max_unsafe_quanta * std_quantum; + max_unsafe_computation = ((uint64_t)max_unsafe_quanta) * std_quantum; + sched_safe_duration = 2 * ((uint64_t)max_unsafe_quanta) * std_quantum; - max_poll_computation = max_poll_quanta * std_quantum; + 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; +#if defined(CONFIG_TELEMETRY) + /* interval for high frequency telemetry */ + clock_interval_to_absolutetime_interval(10, NSEC_PER_MSEC, &abstime); + assert((abstime >> 32) == 0 && (uint32_t)abstime != 0); + sched_telemetry_interval = (uint32_t)abstime; +#endif } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + + +#if defined(CONFIG_SCHED_TRADITIONAL) + static void sched_traditional_processor_init(processor_t processor) { @@ -668,7 +742,7 @@ sched_traditional_with_pset_runqueue_init(void) #endif /* CONFIG_SCHED_TRADITIONAL */ -#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY) +#if defined(CONFIG_SCHED_FAIRSHARE_CORE) void sched_traditional_fairshare_init(void) { @@ -677,7 +751,7 @@ sched_traditional_fairshare_init(void) fs_runq.count = 0; queue_init(&fs_runq.queue); } -#endif +#endif /* CONFIG_SCHED_FAIRSHARE_CORE */ static void sched_realtime_init(void) @@ -706,7 +780,7 @@ sched_realtime_timebase_init(void) } -#if defined(CONFIG_SCHED_TRADITIONAL) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) /* * Set up values for timeshare @@ -718,10 +792,45 @@ load_shift_init(void) int8_t k, *p = sched_load_shifts; uint32_t i, j; + uint32_t sched_decay_penalty = 1; + + 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); + } + + 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); + } + + if (PE_parse_boot_argn("sched_use_combined_fgbg_decay", &sched_use_combined_fgbg_decay, sizeof (sched_use_combined_fgbg_decay))) { + kprintf("Overriding schedule fg/bg decay calculation: %u\n", sched_use_combined_fgbg_decay); + } + + 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; + } + + return; + } + *p++ = INT8_MIN; *p++ = 0; - for (i = j = 2, k = 1; i < NRQS; ++k) { - for (j <<= 1; i < j; ++i) + /* + * 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; } } @@ -731,14 +840,14 @@ preempt_pri_init(void) { int i, *p = sched_preempt_pri; - for (i = BASEPRI_FOREGROUND + 1; i < MINPRI_KERNEL; ++i) + for (i = BASEPRI_FOREGROUND; i < MINPRI_KERNEL; ++i) setbit(i, p); for (i = BASEPRI_PREEMPT; i <= MAXPRI; ++i) setbit(i, p); } -#endif /* CONFIG_SCHED_TRADITIONAL */ +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ /* * Thread wait timer expiration. @@ -763,73 +872,6 @@ thread_timer_expire( splx(s); } -#ifndef __LP64__ - -/* - * thread_set_timer: - * - * Set a timer for the current thread, if the thread - * is ready to wait. Must be called between assert_wait() - * and thread_block(). - */ -void -thread_set_timer( - uint32_t interval, - uint32_t scale_factor) -{ - thread_t thread = current_thread(); - uint64_t deadline; - spl_t s; - - s = splsched(); - thread_lock(thread); - if ((thread->state & TH_WAIT) != 0) { - clock_interval_to_deadline(interval, scale_factor, &deadline); - if (!timer_call_enter(&thread->wait_timer, deadline, thread->sched_pri >= BASEPRI_RTQUEUES ? TIMER_CALL_CRITICAL : 0)) - thread->wait_timer_active++; - thread->wait_timer_is_set = TRUE; - } - thread_unlock(thread); - splx(s); -} - -void -thread_set_timer_deadline( - uint64_t deadline) -{ - thread_t thread = current_thread(); - spl_t s; - - s = splsched(); - thread_lock(thread); - if ((thread->state & TH_WAIT) != 0) { - if (!timer_call_enter(&thread->wait_timer, deadline, thread->sched_pri >= BASEPRI_RTQUEUES ? TIMER_CALL_CRITICAL : 0)) - thread->wait_timer_active++; - thread->wait_timer_is_set = TRUE; - } - thread_unlock(thread); - splx(s); -} - -void -thread_cancel_timer(void) -{ - thread_t thread = current_thread(); - spl_t s; - - s = splsched(); - thread_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; - } - thread_unlock(thread); - splx(s); -} - -#endif /* __LP64__ */ - /* * thread_unblock: * @@ -845,6 +887,8 @@ thread_unblock( wait_result_t wresult) { boolean_t result = FALSE; + thread_t cthread = current_thread(); + uint32_t new_run_count; /* * Set wait_result. @@ -874,9 +918,13 @@ thread_unblock( /* * Update run counts. */ - sched_run_incr(); - if (thread->sched_mode == TH_MODE_TIMESHARE) - sched_share_incr(); + new_run_count = sched_run_incr(thread); + if (thread->sched_mode == TH_MODE_TIMESHARE) { + sched_share_incr(thread); + + if (thread->sched_flags & TH_SFLAG_THROTTLED) + sched_background_incr(thread); + } } else { /* @@ -893,6 +941,7 @@ thread_unblock( assert((thread->state & TH_IDLE) == 0); #endif + new_run_count = sched_run_count; /* updated in thread_select_idle() */ result = TRUE; } @@ -900,20 +949,68 @@ thread_unblock( * Calculate deadline for real-time threads. */ if (thread->sched_mode == TH_MODE_REALTIME) { - thread->realtime.deadline = mach_absolute_time(); - thread->realtime.deadline += thread->realtime.constraint; + uint64_t ctime; + + ctime = mach_absolute_time(); + thread->realtime.deadline = thread->realtime.constraint + ctime; } /* * Clear old quantum, fail-safe computation, etc. */ - thread->current_quantum = 0; + thread->quantum_remaining = 0; thread->computation_metered = 0; thread->reason = AST_NONE; - KERNEL_DEBUG_CONSTANT( + /* 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. + */ + boolean_t aticontext, pidle; + ml_get_power_state(&aticontext, &pidle); + + if (__improbable(aticontext && !(thread_get_tag_internal(thread) & THREAD_TAG_CALLOUT))) { + ledger_credit(thread->t_ledger, task_ledgers.interrupt_wakeups, 1); + DTRACE_SCHED2(iwakeup, struct thread *, thread, struct proc *, thread->task->bsd_info); + + uint64_t ttd = PROCESSOR_DATA(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++; + } + + if (pidle) { + ledger_credit(thread->t_ledger, task_ledgers.platform_idle_wakeups, 1); + } + + } else if (thread_get_tag_internal(cthread) & THREAD_TAG_CALLOUT) { + if (cthread->callout_woken_from_icontext) { + ledger_credit(thread->t_ledger, task_ledgers.interrupt_wakeups, 1); + thread->thread_callout_interrupt_wakeups++; + if (cthread->callout_woken_from_platform_idle) { + ledger_credit(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; + } + + 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, 0, 0, 0); + (uintptr_t)thread_tid(thread), thread->sched_pri, thread->wait_result, new_run_count, 0); DTRACE_SCHED2(wakeup, struct thread *, thread, struct proc *, thread->task->bsd_info); @@ -985,7 +1082,8 @@ thread_mark_wait_locked( (!at_safe_point && (thread->sched_flags & TH_SFLAG_ABORTSAFELY))) { - DTRACE_SCHED(sleep); + if ( !(thread->state & TH_TERMINATE)) + DTRACE_SCHED(sleep); thread->state |= (interruptible) ? TH_WAIT : (TH_WAIT | TH_UNINT); thread->at_safe_point = at_safe_point; @@ -1060,7 +1158,12 @@ assert_wait( register wait_queue_t wq; register int index; - assert(event != NO_EVENT); + if(event == NO_EVENT) + panic("assert_wait() called with NO_EVENT"); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT)|DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE(event), 0, 0, 0, 0); index = wait_hash(event); wq = &wait_queues[index]; @@ -1080,7 +1183,9 @@ assert_wait_timeout( uint64_t deadline; spl_t s; - assert(event != NO_EVENT); + if(event == NO_EVENT) + panic("assert_wait_timeout() called with NO_EVENT"); + wqueue = &wait_queues[wait_hash(event)]; s = splsched(); @@ -1088,8 +1193,65 @@ assert_wait_timeout( thread_lock(thread); 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(event), interruptible, deadline, 0, 0); + + wresult = wait_queue_assert_wait64_locked(wqueue, CAST_DOWN(event64_t, event), + interruptible, + TIMEOUT_URGENCY_SYS_NORMAL, + deadline, 0, + thread); + + thread_unlock(thread); + wait_queue_unlock(wqueue); + 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; + wait_queue_t wqueue; + uint64_t deadline; + uint64_t abstime; + uint64_t slop; + uint64_t now; + spl_t s; + + 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); + + if(event == NO_EVENT) + panic("assert_wait_timeout_with_leeway() called with NO_EVENT"); + + wqueue = &wait_queues[wait_hash(event)]; + + s = splsched(); + wait_queue_lock(wqueue); + thread_lock(thread); + + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT)|DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE(event), interruptible, deadline, 0, 0); + wresult = wait_queue_assert_wait64_locked(wqueue, CAST_DOWN(event64_t, event), - interruptible, deadline, thread); + interruptible, + urgency, deadline, slop, + thread); thread_unlock(thread); wait_queue_unlock(wqueue); @@ -1116,8 +1278,14 @@ assert_wait_deadline( wait_queue_lock(wqueue); thread_lock(thread); + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT)|DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE(event), interruptible, deadline, 0, 0); + wresult = wait_queue_assert_wait64_locked(wqueue, CAST_DOWN(event64_t,event), - interruptible, deadline, thread); + interruptible, + TIMEOUT_URGENCY_SYS_NORMAL, deadline, 0, + thread); thread_unlock(thread); wait_queue_unlock(wqueue); @@ -1126,90 +1294,85 @@ assert_wait_deadline( return (wresult); } -/* - * thread_sleep_fast_usimple_lock: - * - * Cause the current thread to wait until the specified event - * occurs. The specified simple_lock is unlocked before releasing - * the cpu and re-acquired as part of waking up. - * - * This is the simple lock sleep interface for components that use a - * faster version of simple_lock() than is provided by usimple_lock(). - */ -__private_extern__ wait_result_t -thread_sleep_fast_usimple_lock( - event_t event, - simple_lock_t lock, - wait_interrupt_t interruptible) +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) { - wait_result_t res; + thread_t thread = current_thread(); + wait_result_t wresult; + wait_queue_t wqueue; + spl_t s; - res = assert_wait(event, interruptible); - if (res == THREAD_WAITING) { - simple_unlock(lock); - res = thread_block(THREAD_CONTINUE_NULL); - simple_lock(lock); - } - return res; -} + if(event == NO_EVENT) + panic("assert_wait_deadline_with_leeway() called with NO_EVENT"); + wqueue = &wait_queues[wait_hash(event)]; -/* - * thread_sleep_usimple_lock: - * - * Cause the current thread to wait until the specified event - * occurs. The specified usimple_lock is unlocked before releasing - * the cpu and re-acquired as part of waking up. - * - * This is the simple lock sleep interface for components where - * simple_lock() is defined in terms of usimple_lock(). - */ -wait_result_t -thread_sleep_usimple_lock( - event_t event, - usimple_lock_t lock, - wait_interrupt_t interruptible) -{ - wait_result_t res; + s = splsched(); + wait_queue_lock(wqueue); + thread_lock(thread); - res = assert_wait(event, interruptible); - if (res == THREAD_WAITING) { - usimple_unlock(lock); - res = thread_block(THREAD_CONTINUE_NULL); - usimple_lock(lock); - } - return res; + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_WAIT)|DBG_FUNC_NONE, + VM_KERNEL_UNSLIDE(event), interruptible, deadline, 0, 0); + + wresult = wait_queue_assert_wait64_locked(wqueue, CAST_DOWN(event64_t,event), + interruptible, + urgency, deadline, leeway, + thread); + + thread_unlock(thread); + wait_queue_unlock(wqueue); + splx(s); + + return (wresult); } /* - * thread_sleep_lock_write: + * thread_isoncpu: * - * Cause the current thread to wait until the specified event - * occurs. The specified (write) lock is unlocked before releasing - * the cpu. The (write) lock will be re-acquired before returning. + * 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. */ -wait_result_t -thread_sleep_lock_write( - event_t event, - lock_t *lock, - wait_interrupt_t interruptible) +static inline boolean_t +thread_isoncpu(thread_t thread) { - wait_result_t res; + /* Not running or runnable */ + if (!(thread->state & TH_RUN)) + return (FALSE); - res = assert_wait(event, interruptible); - if (res == THREAD_WAITING) { - lock_write_done(lock); - res = thread_block(THREAD_CONTINUE_NULL); - lock_write(lock); - } - return res; + /* 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 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. Arbitrates access among + * 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 @@ -1219,10 +1382,12 @@ thread_sleep_lock_write( */ boolean_t thread_stop( - thread_t thread) + 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); @@ -1248,11 +1413,15 @@ thread_stop( thread->state |= TH_SUSP; - while (thread->state & TH_RUN) { - processor_t processor = thread->last_processor; - - if (processor != PROCESSOR_NULL && processor->active_thread == thread) + 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); @@ -1277,6 +1446,13 @@ thread_stop( 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); } @@ -1333,19 +1509,32 @@ thread_unstop( */ void thread_wait( - thread_t thread) + thread_t thread, + boolean_t until_not_runnable) { wait_result_t wresult; - spl_t s = splsched(); + boolean_t oncpu; + processor_t processor; + spl_t s = splsched(); wake_lock(thread); thread_lock(thread); - while (thread->state & TH_RUN) { - processor_t processor = thread->last_processor; + /* + * 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 (processor != PROCESSOR_NULL && processor->active_thread == thread) + if (oncpu) { + assert(thread->state & TH_RUN); + processor = thread->chosen_processor; cause_ast_check(processor); + } thread->wake_active = TRUE; thread_unlock(thread); @@ -1476,18 +1665,22 @@ thread_wakeup_prim_internal( register wait_queue_t wq; register int index; + if(event == NO_EVENT) + panic("thread_wakeup_prim() called with NO_EVENT"); + index = wait_hash(event); wq = &wait_queues[index]; if (one_thread) return (wait_queue_wakeup_one(wq, event, result, priority)); else - return (wait_queue_wakeup_all(wq, event, result)); + return (wait_queue_wakeup_all(wq, event, result)); } /* * 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. @@ -1505,6 +1698,9 @@ thread_bind( s = splsched(); thread_lock(self); + /* */ + assert(self->sched_pri < BASEPRI_RTQUEUES); + prev = self->bound_processor; self->bound_processor = processor; @@ -1514,7 +1710,67 @@ thread_bind( return (prev); } -/* +/* 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. + */ + +/* Invoked with pset locked, returns with pset unlocked */ +#if (DEVELOPMENT || DEBUG) +int sched_smt_balance = 1; +#endif + +static 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; + + sprocessor = (processor_t)queue_first(&cpset->active_queue); + + while (!queue_end(&cpset->active_queue, (queue_entry_t)sprocessor)) { + if ((sprocessor->state == PROCESSOR_RUNNING) && + (sprocessor->processor_primary != sprocessor) && + (sprocessor->processor_primary->state == PROCESSOR_RUNNING) && + (sprocessor->current_pri < BASEPRI_RTQUEUES) && + ((cpset->pending_AST_cpu_mask & (1U << sprocessor->cpu_id)) == 0)) { + assert(sprocessor != cprocessor); + ast_processor = sprocessor; + break; + } + sprocessor = (processor_t)queue_next((queue_entry_t)sprocessor); + } + +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); + cause_ast_check(ast_processor); + } +} + +/* * thread_select: * * Select a new thread for the current processor to execute. @@ -1524,11 +1780,11 @@ thread_bind( static thread_t thread_select( thread_t thread, - processor_t processor) + processor_t processor, + ast_t reason) { processor_set_t pset = processor->processor_set; thread_t new_thread = THREAD_NULL; - boolean_t inactive_state; assert(processor == current_processor()); @@ -1541,13 +1797,25 @@ thread_select( processor->current_pri = thread->sched_pri; processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; pset_lock(pset); - assert(pset->low_count); - assert(pset->low_pri); + assert(processor->state != PROCESSOR_OFF_LINE); - inactive_state = processor->state != PROCESSOR_SHUTDOWN && machine_processor_is_inactive(processor); + 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) && !queue_empty(&pset->idle_queue) && !rt_runq.count) { + goto idle; + } + } simple_lock(&rt_lock); @@ -1557,23 +1825,18 @@ thread_select( * bound to a different processor, nor be in the wrong * processor set. */ - if ( ((thread->state & ~TH_SUSP) == TH_RUN) && - (thread->sched_pri >= BASEPRI_RTQUEUES || - processor->processor_meta == PROCESSOR_META_NULL || - processor->processor_meta->primary == processor) && - (thread->bound_processor == PROCESSOR_NULL || - thread->bound_processor == processor) && - (thread->affinity_set == AFFINITY_SET_NULL || - thread->affinity_set->aset_pset == pset) ) { - if ( thread->sched_pri >= BASEPRI_RTQUEUES && - first_timeslice(processor) ) { + if (((thread->state & ~TH_SUSP) == TH_RUN) && + (thread->sched_pri >= BASEPRI_RTQUEUES || processor->processor_primary == processor) && + (thread->bound_processor == PROCESSOR_NULL || thread->bound_processor == processor) && + (thread->affinity_set == AFFINITY_SET_NULL || thread->affinity_set->aset_pset == pset)) { + if (thread->sched_pri >= BASEPRI_RTQUEUES && first_timeslice(processor)) { if (rt_runq.count > 0) { - register queue_t q; + thread_t next_rt; - q = &rt_runq.queue; - if (((thread_t)q->next)->realtime.deadline < - processor->deadline) { - thread = (thread_t)dequeue_head(q); + next_rt = (thread_t)queue_first(&rt_runq.queue); + if (next_rt->realtime.deadline < processor->deadline && + (next_rt->bound_processor == PROCESSOR_NULL || next_rt->bound_processor == processor)) { + thread = (thread_t)dequeue_head(&rt_runq.queue); thread->runq = PROCESSOR_NULL; SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count); rt_runq.count--; @@ -1589,16 +1852,11 @@ thread_select( return (thread); } - if (!inactive_state && (thread->sched_mode != TH_MODE_FAIRSHARE || SCHED(fairshare_runq_count)() == 0) && (rt_runq.count == 0 || BASEPRI_RTQUEUES < thread->sched_pri) && - (new_thread = SCHED(choose_thread)(processor, thread->sched_mode == TH_MODE_FAIRSHARE ? MINPRI : thread->sched_pri)) == THREAD_NULL) { + if ((thread->sched_mode != TH_MODE_FAIRSHARE || SCHED(fairshare_runq_count)() == 0) && (rt_runq.count == 0 || BASEPRI_RTQUEUES < thread->sched_pri) && (new_thread = SCHED(choose_thread)(processor, thread->sched_mode == TH_MODE_FAIRSHARE ? MINPRI : thread->sched_pri, reason)) == THREAD_NULL) { simple_unlock(&rt_lock); - /* I am the highest priority runnable (non-idle) thread */ - - pset_pri_hint(pset, processor, processor->current_pri); - - pset_count_hint(pset, processor, SCHED(processor_runq_count)(processor)); + /* This thread is still the highest priority runnable (non-idle) thread */ processor->deadline = UINT64_MAX; @@ -1610,15 +1868,9 @@ thread_select( if (new_thread != THREAD_NULL || (SCHED(processor_queue_has_priority)(processor, rt_runq.count == 0 ? IDLEPRI : BASEPRI_RTQUEUES, TRUE) && - (new_thread = SCHED(choose_thread)(processor, MINPRI)) != THREAD_NULL)) { + (new_thread = SCHED(choose_thread)(processor, MINPRI, reason)) != THREAD_NULL)) { simple_unlock(&rt_lock); - if (!inactive_state) { - pset_pri_hint(pset, processor, new_thread->sched_pri); - - pset_count_hint(pset, processor, SCHED(processor_runq_count)(processor)); - } - processor->deadline = UINT64_MAX; pset_unlock(pset); @@ -1626,18 +1878,22 @@ thread_select( } if (rt_runq.count > 0) { - thread = (thread_t)dequeue_head(&rt_runq.queue); + thread_t next_rt = (thread_t)queue_first(&rt_runq.queue); - thread->runq = PROCESSOR_NULL; - SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count); - rt_runq.count--; + if (__probable((next_rt->bound_processor == NULL || (next_rt->bound_processor == processor)))) { + thread = (thread_t)dequeue_head(&rt_runq.queue); - simple_unlock(&rt_lock); + thread->runq = PROCESSOR_NULL; + SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count); + rt_runq.count--; - processor->deadline = thread->realtime.deadline; - pset_unlock(pset); + simple_unlock(&rt_lock); - return (thread); + processor->deadline = thread->realtime.deadline; + pset_unlock(pset); + + return (thread); + } } simple_unlock(&rt_lock); @@ -1655,24 +1911,6 @@ thread_select( processor->deadline = UINT64_MAX; - /* - * Set processor inactive based on - * indication from the platform code. - */ - if (inactive_state) { - if (processor->state == PROCESSOR_RUNNING) - remqueue((queue_entry_t)processor); - else - if (processor->state == PROCESSOR_IDLE) - remqueue((queue_entry_t)processor); - - processor->state = PROCESSOR_INACTIVE; - - pset_unlock(pset); - - return (processor->idle_thread); - } - /* * No runnable threads, attempt to steal * from other processors. @@ -1691,6 +1929,7 @@ thread_select( pset_lock(pset); + idle: /* * Nothing is runnable, so set this processor idle if it * was running. @@ -1699,24 +1938,24 @@ thread_select( remqueue((queue_entry_t)processor); processor->state = PROCESSOR_IDLE; - if (processor->processor_meta == PROCESSOR_META_NULL || processor->processor_meta->primary == processor) { + if (processor->processor_primary == processor) { enqueue_head(&pset->idle_queue, (queue_entry_t)processor); - pset_pri_init_hint(pset, processor); - pset_count_init_hint(pset, processor); } else { - enqueue_head(&processor->processor_meta->idle_queue, (queue_entry_t)processor); - pset_unlock(pset); - return (processor->idle_thread); + enqueue_head(&pset->idle_secondary_queue, (queue_entry_t)processor); } } - pset_unlock(pset); + /* Invoked with pset locked, returns with pset unlocked */ + sched_SMT_balance(processor, pset); #if CONFIG_SCHED_IDLE_IN_PLACE /* * Choose idle thread if fast idle is not possible. */ + if (processor->processor_primary != processor) + return (processor->idle_thread); + if ((thread->state & (TH_IDLE|TH_TERMINATE|TH_SUSP)) || !(thread->state & TH_WAIT) || thread->wake_active || thread->sched_pri >= BASEPRI_RTQUEUES) return (processor->idle_thread); @@ -1757,21 +1996,36 @@ thread_select_idle( processor_t processor) { thread_t new_thread; + uint64_t arg1, arg2; + int urgency; - if (thread->sched_mode == TH_MODE_TIMESHARE) - sched_share_decr(); - sched_run_decr(); + if (thread->sched_mode == TH_MODE_TIMESHARE) { + if (thread->sched_flags & TH_SFLAG_THROTTLED) + sched_background_decr(thread); + + sched_share_decr(thread); + } + sched_run_decr(thread); thread->state |= TH_IDLE; processor->current_pri = IDLEPRI; processor->current_thmode = TH_MODE_NONE; + processor->current_sfi_class = SFI_CLASS_KERNEL; + /* Reload precise timing global policy to thread-local policy */ + thread->precise_user_kernel_time = use_precise_user_kernel_time(thread); + thread_unlock(thread); /* * Switch execution timing to processor idle thread. */ processor->last_dispatch = mach_absolute_time(); + +#ifdef CONFIG_MACH_APPROXIMATE_TIME + commpage_update_mach_approximate_time(processor->last_dispatch); +#endif + thread->last_run_time = processor->last_dispatch; thread_timer_event(processor->last_dispatch, &processor->idle_thread->system_timer); PROCESSOR_DATA(processor, kernel_timer) = &processor->idle_thread->system_timer; @@ -1784,7 +2038,7 @@ thread_select_idle( (*thread->sched_call)(SCHED_CALL_BLOCK, thread); - thread_tell_urgency(THREAD_URGENCY_NONE, 0, 0); + thread_tell_urgency(THREAD_URGENCY_NONE, 0, 0, NULL); /* * Enable interrupts and perform idling activities. No @@ -1799,23 +2053,6 @@ thread_select_idle( thread_lock(thread); - /* - * If we idled in place, simulate a context switch back - * to the original priority of the thread so that the - * platform layer cannot distinguish this from a true - * switch to the idle thread. - */ - if (thread->sched_mode == TH_MODE_REALTIME) - thread_tell_urgency(THREAD_URGENCY_REAL_TIME, thread->realtime.period, thread->realtime.deadline); - /* Identify non-promoted threads which have requested a - * "background" priority. - */ - else if ((thread->sched_pri <= MAXPRI_THROTTLE) && - (thread->priority <= MAXPRI_THROTTLE)) - thread_tell_urgency(THREAD_URGENCY_BACKGROUND, thread->sched_pri, thread->priority); - else - thread_tell_urgency(THREAD_URGENCY_NORMAL, thread->sched_pri, thread->priority); - /* * If awakened, switch to thread timer and start a new quantum. * Otherwise skip; we will context switch to another thread or return here. @@ -1826,10 +2063,8 @@ thread_select_idle( PROCESSOR_DATA(processor, kernel_timer) = &thread->system_timer; thread_quantum_init(thread); - thread->last_quantum_refill_time = processor->last_dispatch; - - processor->quantum_end = processor->last_dispatch + thread->current_quantum; - timer_call_enter1(&processor->quantum_timer, thread, processor->quantum_end, 0); + processor->quantum_end = processor->last_dispatch + thread->quantum_remaining; + timer_call_enter1(&processor->quantum_timer, thread, processor->quantum_end, TIMER_CALL_SYS_CRITICAL | TIMER_CALL_LOCAL); processor->timeslice = 1; thread->computation_epoch = processor->last_dispatch; @@ -1837,9 +2072,24 @@ thread_select_idle( thread->state &= ~TH_IDLE; - sched_run_incr(); - if (thread->sched_mode == TH_MODE_TIMESHARE) - sched_share_incr(); + /* + * If we idled in place, simulate a context switch back + * to the original priority of the thread so that the + * platform layer cannot distinguish this from a true + * switch to the idle thread. + */ + + urgency = thread_get_urgency(thread, &arg1, &arg2); + + thread_tell_urgency(urgency, arg1, arg2, new_thread); + + sched_run_incr(thread); + if (thread->sched_mode == TH_MODE_TIMESHARE) { + sched_share_incr(thread); + + if (thread->sched_flags & TH_SFLAG_THROTTLED) + sched_background_incr(thread); + } return (new_thread); } @@ -1848,12 +2098,13 @@ thread_select_idle( #if defined(CONFIG_SCHED_TRADITIONAL) static thread_t sched_traditional_choose_thread( - processor_t processor, - int priority) + processor_t processor, + int priority, + __unused ast_t reason) { thread_t thread; - thread = choose_thread(processor, runq_for_processor(processor), priority); + thread = choose_thread_from_runq(processor, runq_for_processor(processor), priority); if (thread != THREAD_NULL) { runq_consider_decr_bound_count(processor, thread); } @@ -1863,10 +2114,10 @@ sched_traditional_choose_thread( #endif /* defined(CONFIG_SCHED_TRADITIONAL) */ -#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_FIXEDPRIORITY) +#if defined(CONFIG_SCHED_TRADITIONAL) /* - * choose_thread: + * choose_thread_from_runq: * * Locate a thread to execute from the processor run queue * and return it. Only choose a thread with greater or equal @@ -1876,7 +2127,7 @@ sched_traditional_choose_thread( * on failure. */ thread_t -choose_thread( +choose_thread_from_runq( processor_t processor, run_queue_t rq, int priority) @@ -1917,7 +2168,7 @@ choose_thread( return (THREAD_NULL); } -#endif /* defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_FIXEDPRIORITY) */ +#endif /* defined(CONFIG_SCHED_TRADITIONAL) */ /* * Perform a context switch and start executing the new thread. @@ -1927,43 +2178,29 @@ choose_thread( * Called at splsched. */ -#define funnel_release_check(thread, debug) \ -MACRO_BEGIN \ - if ((thread)->funnel_state & TH_FN_OWNED) { \ - (thread)->funnel_state = TH_FN_REFUNNEL; \ - KERNEL_DEBUG(0x603242c | DBG_FUNC_NONE, \ - (thread)->funnel_lock, (debug), 0, 0, 0); \ - funnel_unlock((thread)->funnel_lock); \ - } \ -MACRO_END - -#define funnel_refunnel_check(thread, debug) \ -MACRO_BEGIN \ - if ((thread)->funnel_state & TH_FN_REFUNNEL) { \ - kern_return_t result = (thread)->wait_result; \ - \ - (thread)->funnel_state = 0; \ - KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, \ - (thread)->funnel_lock, (debug), 0, 0, 0); \ - funnel_lock((thread)->funnel_lock); \ - KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, \ - (thread)->funnel_lock, (debug), 0, 0, 0); \ - (thread)->funnel_state = TH_FN_OWNED; \ - (thread)->wait_result = result; \ - } \ -MACRO_END - +/* + * thread_invoke + * + * "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( - register thread_t self, - register thread_t thread, + thread_t self, + thread_t thread, ast_t reason) { thread_continue_t continuation = self->continuation; - void *parameter = self->parameter; - processor_t processor; + 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 (get_preemption_level() != 0) { + 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" : @@ -1971,16 +2208,27 @@ thread_invoke( } assert(self == current_thread()); + assert(self->runq == PROCESSOR_NULL); +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + sched_traditional_consider_maintenance(ctime); +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + /* * Mark thread interruptible. */ thread_lock(thread); thread->state &= ~TH_UNINT; -#if DEBUG assert(thread_runnable(thread)); -#endif + 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); /* * Allow time constraint threads to hang onto @@ -2009,6 +2257,7 @@ thread_invoke( processor->active_thread = thread; processor->current_pri = thread->sched_pri; processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; if (thread->last_processor != processor && thread->last_processor != NULL) { if (thread->last_processor->processor_set != processor->processor_set) thread->ps_switch++; @@ -2021,15 +2270,26 @@ thread_invoke( self->reason = reason; - processor->last_dispatch = mach_absolute_time(); - self->last_run_time = processor->last_dispatch; - thread_timer_event(processor->last_dispatch, &thread->system_timer); + processor->last_dispatch = ctime; + self->last_run_time = ctime; + thread_timer_event(ctime, &thread->system_timer); PROCESSOR_DATA(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_switch(PROCESSOR_DATA(processor, current_state), + ctime, + PROCESSOR_DATA(processor, current_state)); + } - KERNEL_DEBUG_CONSTANT(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); + 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 != NULL)) { + if ((thread->chosen_processor != processor) && (thread->chosen_processor != PROCESSOR_NULL)) { 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); } @@ -2049,7 +2309,6 @@ thread_invoke( counter(c_thread_invoke_hits++); - funnel_refunnel_check(thread, 2); (void) spllo(); assert(continuation); @@ -2062,12 +2321,12 @@ thread_invoke( counter(++c_thread_invoke_same); thread_unlock(self); - KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED,MACH_SCHED) | DBG_FUNC_NONE, - self->reason, (uintptr_t)thread_tid(thread), self->sched_pri, thread->sched_pri, 0); + 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); self->continuation = self->parameter = NULL; - funnel_refunnel_check(self, 3); (void) spllo(); call_continuation(continuation, parameter, self->wait_result); @@ -2092,8 +2351,9 @@ need_stack: counter(++c_thread_invoke_same); thread_unlock(self); - KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED,MACH_SCHED) | DBG_FUNC_NONE, - self->reason, (uintptr_t)thread_tid(thread), self->sched_pri, thread->sched_pri, 0); + 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); } @@ -2106,6 +2366,7 @@ need_stack: processor->active_thread = thread; processor->current_pri = thread->sched_pri; processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; if (thread->last_processor != processor && thread->last_processor != NULL) { if (thread->last_processor->processor_set != processor->processor_set) thread->ps_switch++; @@ -2121,13 +2382,24 @@ need_stack: assert(self->runq == PROCESSOR_NULL); self->reason = reason; - processor->last_dispatch = mach_absolute_time(); - self->last_run_time = processor->last_dispatch; - thread_timer_event(processor->last_dispatch, &thread->system_timer); + processor->last_dispatch = ctime; + self->last_run_time = ctime; + thread_timer_event(ctime, &thread->system_timer); PROCESSOR_DATA(processor, kernel_timer) = &thread->system_timer; - KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED,MACH_SCHED) | DBG_FUNC_NONE, - self->reason, (uintptr_t)thread_tid(thread), self->sched_pri, thread->sched_pri, 0); + /* + * 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_switch(PROCESSOR_DATA(processor, current_state), + ctime, + PROCESSOR_DATA(processor, current_state)); + } + + 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)) { KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_MOVED)|DBG_FUNC_NONE, @@ -2143,7 +2415,9 @@ need_stack: * and address space if required. We will next run * as a result of a subsequent context switch. */ + assert(continuation == self->continuation); thread = machine_switch_context(self, continuation, thread); + assert(self == current_thread()); TLOG(1,"thread_invoke: returning machine_switch_context: self %p continuation %p thread %p\n", self, continuation, thread); DTRACE_SCHED(on__cpu); @@ -2156,7 +2430,6 @@ need_stack: if (continuation) { self->continuation = self->parameter = NULL; - funnel_refunnel_check(self, 3); (void) spllo(); call_continuation(continuation, parameter, self->wait_result); @@ -2174,6 +2447,9 @@ need_stack: * special actions. Update quantum for other thread and begin * the quantum for ourselves. * + * "self" is our new current thread that we have context switched + * to, "thread" is the old thread that we have switched away from. + * * Called at splsched. */ void @@ -2192,26 +2468,54 @@ thread_dispatch( stack_free(thread); if (!(thread->state & TH_IDLE)) { + 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->t_ledger, + task_ledgers.cpu_time, consumed); + ledger_credit(thread->t_threadledger, + thread_ledgers.cpu_time, consumed); +#ifdef CONFIG_BANK + if (thread->t_bankledger) { + ledger_credit(thread->t_bankledger, + bank_ledgers.cpu_time, + (consumed - thread->t_deduct_bank_ledger_time)); + + } + thread->t_deduct_bank_ledger_time =0; +#endif + } + wake_lock(thread); thread_lock(thread); /* * Compute remainder of current quantum. */ - if ( first_timeslice(processor) && - processor->quantum_end > processor->last_dispatch ) - thread->current_quantum = (uint32_t)(processor->quantum_end - processor->last_dispatch); + if (first_timeslice(processor) && + processor->quantum_end > processor->last_dispatch) + thread->quantum_remaining = (uint32_t)remainder; else - thread->current_quantum = 0; + thread->quantum_remaining = 0; if (thread->sched_mode == TH_MODE_REALTIME) { /* * Cancel the deadline if the thread has * consumed the entire quantum. */ - if (thread->current_quantum == 0) { + if (thread->quantum_remaining == 0) { thread->realtime.deadline = UINT64_MAX; - thread->reason |= AST_QUANTUM; } } else { #if defined(CONFIG_SCHED_TRADITIONAL) @@ -2220,9 +2524,9 @@ thread_dispatch( * remaining quantum as an expired quantum * but include what's left next time. */ - if (thread->current_quantum < min_std_quantum) { + if (thread->quantum_remaining < min_std_quantum) { thread->reason |= AST_QUANTUM; - thread->current_quantum += std_quantum; + thread->quantum_remaining += SCHED(initial_quantum_size)(thread); } #endif } @@ -2232,13 +2536,49 @@ thread_dispatch( * take the remainder of the quantum. */ if ((thread->reason & (AST_HANDOFF|AST_QUANTUM)) == AST_HANDOFF) { - self->current_quantum = thread->current_quantum; + self->quantum_remaining = thread->quantum_remaining; thread->reason |= AST_QUANTUM; - thread->current_quantum = 0; + thread->quantum_remaining = 0; + } else { +#if defined(CONFIG_SCHED_MULTIQ) + if (sched_groups_enabled && thread->sched_group == self->sched_group) { + /* TODO: Remove tracepoint */ + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED, MACH_QUANTUM_HANDOFF) | DBG_FUNC_NONE, + self->reason, (uintptr_t)thread_tid(thread), + self->quantum_remaining, thread->quantum_remaining, 0); + + self->quantum_remaining = thread->quantum_remaining; + thread->quantum_remaining = 0; + /* TODO: Should we set AST_QUANTUM here? */ + } +#endif /* defined(CONFIG_SCHED_MULTIQ) */ } thread->computation_metered += (processor->last_dispatch - thread->computation_epoch); + if ((thread->rwlock_count != 0) && !(LcksOpts & disLkRWPrio)) { + integer_t priority; + + priority = thread->sched_pri; + + if (priority < thread->priority) + priority = thread->priority; + if (priority < BASEPRI_BACKGROUND) + priority = BASEPRI_BACKGROUND; + + if ((thread->sched_pri < priority) || !(thread->sched_flags & TH_SFLAG_RW_PROMOTED)) { + KERNEL_DEBUG_CONSTANT( + MACHDBG_CODE(DBG_MACH_SCHED, MACH_RW_PROMOTE) | DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), thread->sched_pri, thread->priority, priority, 0); + + thread->sched_flags |= TH_SFLAG_RW_PROMOTED; + + if (thread->sched_pri < priority) + set_sched_pri(thread, priority); + } + } + if (!(thread->state & TH_WAIT)) { /* * Still running. @@ -2253,7 +2593,19 @@ thread_dispatch( thread->reason = AST_NONE; - thread_unlock(thread); + 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_count, 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 { @@ -2261,6 +2613,7 @@ thread_dispatch( * Waiting. */ boolean_t should_terminate = FALSE; + uint32_t new_run_count; /* Only the first call to thread_dispatch * after explicit termination should add @@ -2272,10 +2625,25 @@ thread_dispatch( } thread->state &= ~TH_RUN; + thread->chosen_processor = PROCESSOR_NULL; + + if (thread->sched_mode == TH_MODE_TIMESHARE) { + if (thread->sched_flags & TH_SFLAG_THROTTLED) + sched_background_decr(thread); - if (thread->sched_mode == TH_MODE_TIMESHARE) - sched_share_decr(); - sched_run_decr(); + sched_share_decr(thread); + } + new_run_count = sched_run_decr(thread); + + if ((thread->state & (TH_WAIT | TH_TERMINATE)) == TH_WAIT) { + if (thread->reason & AST_SFI) { + thread->wait_sfi_begin_time = processor->last_dispatch; + } + } + + 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); (*thread->sched_call)(SCHED_CALL_BLOCK, thread); @@ -2297,30 +2665,34 @@ thread_dispatch( } if (!(self->state & TH_IDLE)) { + uint64_t arg1, arg2; + int urgency; + ast_t new_ast; - if (self->sched_mode == TH_MODE_REALTIME) - thread_tell_urgency(THREAD_URGENCY_REAL_TIME, self->realtime.period, self->realtime.deadline); - /* Identify non-promoted threads which have requested a - * "background" priority. - */ - else if ((self->sched_pri <= MAXPRI_THROTTLE) && - (self->priority <= MAXPRI_THROTTLE)) - thread_tell_urgency(THREAD_URGENCY_BACKGROUND, self->sched_pri, self->priority); - else - thread_tell_urgency(THREAD_URGENCY_NORMAL, self->sched_pri, self->priority); + thread_lock(self); + new_ast = sfi_thread_needs_ast(self, NULL); + thread_unlock(self); + + if (new_ast != AST_NONE) { + ast_on(new_ast); + } + + urgency = thread_get_urgency(self, &arg1, &arg2); + + thread_tell_urgency(urgency, arg1, arg2, self); + /* * Get a new quantum if none remaining. */ - if (self->current_quantum == 0) { + if (self->quantum_remaining == 0) { thread_quantum_init(self); - self->last_quantum_refill_time = processor->last_dispatch; } /* * Set up quantum timer and timeslice. */ - processor->quantum_end = (processor->last_dispatch + self->current_quantum); - timer_call_enter1(&processor->quantum_timer, self, processor->quantum_end, 0); + processor->quantum_end = processor->last_dispatch + self->quantum_remaining; + timer_call_enter1(&processor->quantum_timer, self, processor->quantum_end, TIMER_CALL_SYS_CRITICAL | TIMER_CALL_LOCAL); processor->timeslice = 1; @@ -2330,15 +2702,10 @@ thread_dispatch( timer_call_cancel(&processor->quantum_timer); processor->timeslice = 0; - thread_tell_urgency(THREAD_URGENCY_NONE, 0, 0); + thread_tell_urgency(THREAD_URGENCY_NONE, 0, 0, NULL); } } -#include - -uint32_t kdebug_thread_block = 0; - - /* * thread_block_reason: * @@ -2367,9 +2734,6 @@ thread_block_reason( s = splsched(); - if (!(reason & AST_PREEMPT)) - funnel_release_check(self, 2); - processor = current_processor(); /* If we're explicitly yielding, force a subsequent quantum */ @@ -2382,22 +2746,18 @@ thread_block_reason( self->continuation = continuation; self->parameter = parameter; - if (__improbable(kdebug_thread_block && kdebug_enable && self->state != TH_RUN)) { - uint32_t bt[8]; - - OSBacktrace((void **)&bt[0], 8); - - KERNEL_DEBUG_CONSTANT(0x140004c | DBG_FUNC_START, bt[0], bt[1], bt[2], bt[3], 0); - KERNEL_DEBUG_CONSTANT(0x140004c | DBG_FUNC_END, bt[4], bt[5], bt[6], bt[7], 0); + 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); + new_thread = thread_select(self, processor, reason); thread_unlock(self); } while (!thread_invoke(self, new_thread, reason)); - funnel_refunnel_check(self, 5); splx(s); return (self->wait_result); @@ -2442,8 +2802,6 @@ thread_run( { ast_t handoff = AST_HANDOFF; - funnel_release_check(self, 3); - self->continuation = continuation; self->parameter = parameter; @@ -2451,13 +2809,11 @@ thread_run( processor_t processor = current_processor(); thread_lock(self); - new_thread = thread_select(self, processor); + new_thread = thread_select(self, processor, AST_NONE); thread_unlock(self); handoff = AST_NONE; } - funnel_refunnel_check(self, 6); - return (self->wait_result); } @@ -2471,9 +2827,9 @@ void thread_continue( register thread_t thread) { - register thread_t self = current_thread(); + register thread_t self = current_thread(); register thread_continue_t continuation; - register void *parameter; + register void *parameter; DTRACE_SCHED(on__cpu); @@ -2484,8 +2840,6 @@ thread_continue( self->continuation = self->parameter = NULL; - funnel_refunnel_check(self, 4); - if (thread != THREAD_NULL) (void)spllo(); @@ -2498,19 +2852,27 @@ void thread_quantum_init(thread_t thread) { if (thread->sched_mode == TH_MODE_REALTIME) { - thread->current_quantum = thread->realtime.computation; + thread->quantum_remaining = thread->realtime.computation; } else { - thread->current_quantum = SCHED(initial_quantum_size)(thread); + thread->quantum_remaining = SCHED(initial_quantum_size)(thread); } } -#if defined(CONFIG_SCHED_TRADITIONAL) -static uint32_t -sched_traditional_initial_quantum_size(thread_t thread __unused) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + +uint32_t +sched_traditional_initial_quantum_size(thread_t thread) { - return std_quantum; + if ((thread == THREAD_NULL) || !(thread->sched_flags & TH_SFLAG_THROTTLED)) + return std_quantum; + else + return bg_quantum; } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + +#if defined(CONFIG_SCHED_TRADITIONAL) + static sched_mode_t sched_traditional_initial_thread_sched_mode(task_t parent_task) { @@ -2520,12 +2882,6 @@ sched_traditional_initial_thread_sched_mode(task_t parent_task) return TH_MODE_TIMESHARE; } -static boolean_t -sched_traditional_supports_timeshare_mode(void) -{ - return TRUE; -} - #endif /* CONFIG_SCHED_TRADITIONAL */ /* @@ -2548,7 +2904,7 @@ run_queue_init( queue_init(&rq->queues[i]); } -#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY) +#if defined(CONFIG_SCHED_FAIRSHARE_CORE) int sched_traditional_fairshare_runq_count(void) { @@ -2627,7 +2983,7 @@ sched_traditional_fairshare_queue_remove(thread_t thread) } } -#endif /* defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY) */ +#endif /* CONFIG_SCHED_FAIRSHARE_CORE */ /* * run_queue_dequeue: @@ -2693,13 +3049,12 @@ run_queue_enqueue( rq->highq = thread->sched_pri; result = TRUE; } - } - else + } else { if (options & SCHED_TAILQ) enqueue_tail(queue, (queue_entry_t)thread); else enqueue_head(queue, (queue_entry_t)thread); - + } if (SCHED(priority_is_urgent)(thread->sched_pri)) rq->urgency++; SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count); @@ -2758,10 +3113,11 @@ fairshare_setrun( SCHED(fairshare_enqueue)(thread); + pset_unlock(pset); + if (processor != current_processor()) machine_signal_idle(processor); - pset_unlock(pset); } @@ -2826,9 +3182,15 @@ realtime_setrun( thread_t thread) { processor_set_t pset = processor->processor_set; + ast_t preempt; + + boolean_t do_signal_idle = FALSE, do_cause_ast = FALSE; thread->chosen_processor = processor; + /* */ + assert(thread->bound_processor == PROCESSOR_NULL); + /* * Dispatch directly onto idle processor. */ @@ -2838,36 +3200,98 @@ realtime_setrun( enqueue_tail(&pset->active_queue, (queue_entry_t)processor); processor->next_thread = thread; + processor->current_pri = thread->sched_pri; + processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; processor->deadline = thread->realtime.deadline; processor->state = PROCESSOR_DISPATCHING; + + if (processor != current_processor()) { + if (!(pset->pending_AST_cpu_mask & (1U << processor->cpu_id))) { + /* cleared on exit from main processor_idle() loop */ + pset->pending_AST_cpu_mask |= (1U << processor->cpu_id); + do_signal_idle = TRUE; + } + } pset_unlock(pset); - if (processor != current_processor()) + if (do_signal_idle) { machine_signal_idle(processor); + } return; } - if (realtime_queue_insert(thread)) { - int prstate = processor->state; - if (processor == current_processor()) - ast_on(AST_PREEMPT | AST_URGENT); - else if ((prstate == PROCESSOR_DISPATCHING) || (prstate == PROCESSOR_IDLE)) - machine_signal_idle(processor); - else - cause_ast_check(processor); + 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; + + realtime_queue_insert(thread); + + if (preempt != AST_NONE) { + if (processor->state == PROCESSOR_IDLE) { + remqueue((queue_entry_t)processor); + enqueue_tail(&pset->active_queue, (queue_entry_t)processor); + processor->next_thread = THREAD_NULL; + processor->current_pri = thread->sched_pri; + processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; + processor->deadline = thread->realtime.deadline; + processor->state = PROCESSOR_DISPATCHING; + if (processor == current_processor()) { + ast_on(preempt); + } else { + if (!(pset->pending_AST_cpu_mask & (1U << processor->cpu_id))) { + /* cleared on exit from main processor_idle() loop */ + pset->pending_AST_cpu_mask |= (1U << processor->cpu_id); + do_signal_idle = TRUE; + } + } + } else if (processor->state == PROCESSOR_DISPATCHING) { + if ((processor->next_thread == THREAD_NULL) && ((processor->current_pri < thread->sched_pri) || (processor->deadline > thread->realtime.deadline))) { + processor->current_pri = thread->sched_pri; + processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; + processor->deadline = thread->realtime.deadline; + } + } else { + if (processor == current_processor()) { + ast_on(preempt); + } else { + if (!(pset->pending_AST_cpu_mask & (1U << processor->cpu_id))) { + /* cleared after IPI causes csw_check() to be called */ + pset->pending_AST_cpu_mask |= (1U << processor->cpu_id); + do_cause_ast = TRUE; + } + } + } + } else { + /* Selected processor was too busy, just keep thread enqueued and let other processors drain it naturally. */ } pset_unlock(pset); + + if (do_signal_idle) { + machine_signal_idle(processor); + } else if (do_cause_ast) { + cause_ast_check(processor); + } } -#if defined(CONFIG_SCHED_TRADITIONAL) -static boolean_t +#if defined(CONFIG_SCHED_TIMESHARE_CORE) + +boolean_t priority_is_urgent(int priority) { return testbit(priority, sched_preempt_pri) ? TRUE : FALSE; } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + +#if defined(CONFIG_SCHED_TRADITIONAL) /* * processor_enqueue: * @@ -2915,6 +3339,9 @@ processor_setrun( { processor_set_t pset = processor->processor_set; ast_t preempt; + enum { eExitIdle, eInterruptRunning, eDoNothing } ipi_action = eDoNothing; + + boolean_t do_signal_idle = FALSE, do_cause_ast = FALSE; thread->chosen_processor = processor; @@ -2928,12 +3355,23 @@ processor_setrun( enqueue_tail(&pset->active_queue, (queue_entry_t)processor); processor->next_thread = thread; + processor->current_pri = thread->sched_pri; + processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; processor->deadline = UINT64_MAX; processor->state = PROCESSOR_DISPATCHING; - pset_unlock(pset); - if (processor != current_processor()) + if (!(pset->pending_AST_cpu_mask & (1U << processor->cpu_id))) { + /* cleared on exit from main processor_idle() loop */ + pset->pending_AST_cpu_mask |= (1U << processor->cpu_id); + do_signal_idle = TRUE; + } + + pset_unlock(pset); + if (do_signal_idle) { machine_signal_idle(processor); + } + return; } @@ -2944,44 +3382,101 @@ processor_setrun( preempt = (AST_PREEMPT | AST_URGENT); else if(processor->active_thread && thread_eager_preemption(processor->active_thread)) preempt = (AST_PREEMPT | AST_URGENT); - else - if ((thread->sched_mode == TH_MODE_TIMESHARE) && thread->sched_pri < thread->priority) - preempt = AST_NONE; - else + else if ((thread->sched_mode == TH_MODE_TIMESHARE) && (thread->sched_pri < thread->priority)) { + if(SCHED(priority_is_urgent)(thread->priority) && 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 (!SCHED(processor_enqueue)(processor, thread, options)) - preempt = AST_NONE; + SCHED(processor_enqueue)(processor, thread, options); if (preempt != AST_NONE) { - if (processor == current_processor()) { - if (csw_check(processor) != AST_NONE) - ast_on(preempt); - } - else - if ( processor->state == PROCESSOR_IDLE || processor->state == PROCESSOR_DISPATCHING) { - machine_signal_idle(processor); - } - else - if ( (processor->state == PROCESSOR_RUNNING || - processor->state == PROCESSOR_SHUTDOWN) && - (thread->sched_pri >= processor->current_pri || + if (processor->state == PROCESSOR_IDLE) { + remqueue((queue_entry_t)processor); + enqueue_tail(&pset->active_queue, (queue_entry_t)processor); + processor->next_thread = THREAD_NULL; + processor->current_pri = thread->sched_pri; + processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; + processor->deadline = UINT64_MAX; + processor->state = PROCESSOR_DISPATCHING; + + ipi_action = eExitIdle; + } else if ( processor->state == PROCESSOR_DISPATCHING) { + if ((processor->next_thread == THREAD_NULL) && (processor->current_pri < thread->sched_pri)) { + processor->current_pri = thread->sched_pri; + processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; + processor->deadline = UINT64_MAX; + } + } else if ( (processor->state == PROCESSOR_RUNNING || + processor->state == PROCESSOR_SHUTDOWN) && + (thread->sched_pri >= processor->current_pri || processor->current_thmode == TH_MODE_FAIRSHARE)) { - cause_ast_check(processor); + ipi_action = eInterruptRunning; } - } - else - if ( processor->state == PROCESSOR_SHUTDOWN && + } 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 ) { - cause_ast_check(processor); + ipi_action = eInterruptRunning; + } else if ( processor->state == PROCESSOR_IDLE && + processor != current_processor() ) { + remqueue((queue_entry_t)processor); + enqueue_tail(&pset->active_queue, (queue_entry_t)processor); + processor->next_thread = THREAD_NULL; + processor->current_pri = thread->sched_pri; + processor->current_thmode = thread->sched_mode; + processor->current_sfi_class = thread->sfi_class; + processor->deadline = UINT64_MAX; + processor->state = PROCESSOR_DISPATCHING; + + ipi_action = eExitIdle; + } } - else - if ( processor->state == PROCESSOR_IDLE && - processor != current_processor() ) { - machine_signal_idle(processor); + + switch (ipi_action) { + case eDoNothing: + break; + case eExitIdle: + if (processor == current_processor()) { + if (csw_check_locked(processor, pset, AST_NONE) != AST_NONE) + ast_on(preempt); + } else { + if (!(pset->pending_AST_cpu_mask & (1U << processor->cpu_id))) { + /* cleared on exit from main processor_idle() loop */ + pset->pending_AST_cpu_mask |= (1U << processor->cpu_id); + do_signal_idle = TRUE; + } + } + break; + case eInterruptRunning: + if (processor == current_processor()) { + if (csw_check_locked(processor, pset, AST_NONE) != AST_NONE) + ast_on(preempt); + } else { + if (!(pset->pending_AST_cpu_mask & (1U << processor->cpu_id))) { + /* cleared after IPI causes csw_check() to be called */ + pset->pending_AST_cpu_mask |= (1U << processor->cpu_id); + do_cause_ast = TRUE; + } + } + break; } pset_unlock(pset); + + if (do_signal_idle) { + machine_signal_idle(processor); + } else if (do_cause_ast) { + cause_ast_check(processor); + } } #if defined(CONFIG_SCHED_TRADITIONAL) @@ -3021,11 +3516,17 @@ static ast_t processor_csw_check(processor_t processor) { run_queue_t runq; + boolean_t has_higher; assert(processor->active_thread != NULL); runq = runq_for_processor(processor); - if (runq->highq > processor->current_pri) { + if (first_timeslice(processor)) { + has_higher = (runq->highq > processor->current_pri); + } else { + has_higher = (runq->highq >= processor->current_pri); + } + if (has_higher) { if (runq->urgency > 0) return (AST_PREEMPT | AST_URGENT); @@ -3053,8 +3554,7 @@ static boolean_t should_current_thread_rechoose_processor(processor_t processor) { return (processor->current_pri < BASEPRI_RTQUEUES - && processor->processor_meta != PROCESSOR_META_NULL - && processor->processor_meta->primary != processor); + && processor->processor_primary != processor); } static int @@ -3063,7 +3563,6 @@ sched_traditional_processor_runq_count(processor_t processor) return runq_for_processor(processor)->count; } - static uint64_t sched_traditional_processor_runq_stats_count_sum(processor_t processor) { @@ -3079,9 +3578,13 @@ sched_traditional_with_pset_runqueue_processor_runq_stats_count_sum(processor_t return 0ULL; } -#endif /* CONFIG_SCHED_TRADITIONAL */ +static int +sched_traditional_processor_bound_count(processor_t processor) +{ + return processor->runq_bound_count; +} -#define next_pset(p) (((p)->pset_list != PROCESSOR_SET_NULL)? (p)->pset_list: (p)->node->psets) +#endif /* CONFIG_SCHED_TRADITIONAL */ /* * choose_next_pset: @@ -3124,147 +3627,228 @@ choose_processor( thread_t thread) { processor_set_t nset, cset = pset; - processor_meta_t pmeta = PROCESSOR_META_NULL; - processor_t mprocessor; /* - * Prefer the hinted processor, when appropriate. + * Prefer the hinted processor, when appropriate. */ + /* Fold last processor hint from secondary processor to its primary */ if (processor != PROCESSOR_NULL) { - if (processor->processor_meta != PROCESSOR_META_NULL) - processor = processor->processor_meta->primary; + processor = processor->processor_primary; } - mprocessor = machine_choose_processor(pset, processor); - if (mprocessor != PROCESSOR_NULL) - processor = mprocessor; + /* + * 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->state == PROCESSOR_INACTIVE || - processor->state == PROCESSOR_SHUTDOWN || - processor->state == PROCESSOR_OFF_LINE) + if (processor->processor_set != pset) { processor = PROCESSOR_NULL; - else - if (processor->state == PROCESSOR_IDLE || - ((thread->sched_pri >= BASEPRI_RTQUEUES) && - (processor->current_pri < BASEPRI_RTQUEUES))) - return (processor); + } 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. + */ + return (processor); + 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->current_pri < BASEPRI_RTQUEUES)) + 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. + * 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_unpaired_primary_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_unpaired_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; + } + do { + /* - * Choose an idle processor. + * Choose an idle processor, in pset traversal order */ if (!queue_empty(&cset->idle_queue)) return ((processor_t)queue_first(&cset->idle_queue)); - if (thread->sched_pri >= BASEPRI_RTQUEUES) { - integer_t lowest_priority = MAXPRI + 1; - integer_t lowest_unpaired = MAXPRI + 1; - uint64_t furthest_deadline = 1; - processor_t lp_processor = PROCESSOR_NULL; - processor_t lp_unpaired = PROCESSOR_NULL; - processor_t fd_processor = PROCESSOR_NULL; - - lp_processor = cset->low_pri; - /* Consider hinted processor */ - if (lp_processor != PROCESSOR_NULL && - ((lp_processor->processor_meta == PROCESSOR_META_NULL) || - ((lp_processor == lp_processor->processor_meta->primary) && - !queue_empty(&lp_processor->processor_meta->idle_queue))) && - lp_processor->state != PROCESSOR_INACTIVE && - lp_processor->state != PROCESSOR_SHUTDOWN && - lp_processor->state != PROCESSOR_OFF_LINE && - (lp_processor->current_pri < thread->sched_pri)) - return lp_processor; + /* + * Otherwise, enumerate active and idle processors to find candidates + * with lower priority/etc. + */ - processor = (processor_t)queue_first(&cset->active_queue); - while (!queue_end(&cset->active_queue, (queue_entry_t)processor)) { - /* Discover the processor executing the - * thread with the lowest priority within - * this pset, or the one with the furthest - * deadline - */ - integer_t cpri = processor->current_pri; - if (cpri < lowest_priority) { - lowest_priority = cpri; - lp_processor = processor; - } + processor = (processor_t)queue_first(&cset->active_queue); + while (!queue_end(&cset->active_queue, (queue_entry_t)processor)) { - if ((cpri >= BASEPRI_RTQUEUES) && (processor->deadline > furthest_deadline)) { - furthest_deadline = processor->deadline; - fd_processor = processor; - } + integer_t cpri = processor->current_pri; + 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; + } - if (processor->processor_meta != PROCESSOR_META_NULL && - !queue_empty(&processor->processor_meta->idle_queue)) { - if (cpri < lowest_unpaired) { - lowest_unpaired = cpri; - lp_unpaired = processor; - pmeta = processor->processor_meta; - } - else - if (pmeta == PROCESSOR_META_NULL) - pmeta = processor->processor_meta; + integer_t ccount = SCHED(processor_runq_count)(processor); + if (ccount < lowest_count) { + lowest_count = ccount; + lc_processor = processor; + } + + processor = (processor_t)queue_next((queue_entry_t)processor); + } + + /* + * For SMT configs, these idle secondary processors must have active primary. Otherwise + * the idle primary would have short-circuited the loop above + */ + processor = (processor_t)queue_first(&cset->idle_secondary_queue); + while (!queue_end(&cset->idle_secondary_queue, (queue_entry_t)processor)) { + processor_t cprimary = processor->processor_primary; + + /* 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) { + integer_t primary_pri = cprimary->current_pri; + + if (primary_pri < lowest_unpaired_primary_priority) { + lowest_unpaired_primary_priority = primary_pri; + lp_unpaired_primary_processor = cprimary; + lp_unpaired_secondary_processor = processor; } - processor = (processor_t)queue_next((queue_entry_t)processor); } - if (thread->sched_pri > lowest_unpaired) - return lp_unpaired; + processor = (processor_t)queue_next((queue_entry_t)processor); + } + + + if (thread->sched_pri >= BASEPRI_RTQUEUES) { + + /* + * For realtime threads, the most important aspect is + * scheduling latency, so we attempt to assign threads + * to good preemption candidates (assuming an idle primary + * processor was not available above). + */ - if (pmeta != PROCESSOR_META_NULL) - return ((processor_t)queue_first(&pmeta->idle_queue)); - if (thread->sched_pri > lowest_priority) + if (thread->sched_pri > lowest_unpaired_primary_priority) { + /* Move to end of active queue so that the next thread doesn't also pick it */ + remqueue((queue_entry_t)lp_unpaired_primary_processor); + enqueue_tail(&cset->active_queue, (queue_entry_t)lp_unpaired_primary_processor); + return lp_unpaired_primary_processor; + } + if (thread->sched_pri > lowest_priority) { + /* Move to end of active queue so that the next thread doesn't also pick it */ + remqueue((queue_entry_t)lp_processor); + enqueue_tail(&cset->active_queue, (queue_entry_t)lp_processor); return lp_processor; + } if (thread->realtime.deadline < furthest_deadline) return fd_processor; - processor = PROCESSOR_NULL; - } - else { /* - * Check any hinted processors in the processor set if available. + * If all primary and secondary CPUs are busy with realtime + * threads with deadlines earlier than us, move on to next + * pset. */ - if (cset->low_pri != PROCESSOR_NULL && cset->low_pri->state != PROCESSOR_INACTIVE && - cset->low_pri->state != PROCESSOR_SHUTDOWN && cset->low_pri->state != PROCESSOR_OFF_LINE && - (processor == PROCESSOR_NULL || - (thread->sched_pri > BASEPRI_DEFAULT && cset->low_pri->current_pri < thread->sched_pri))) { - processor = cset->low_pri; + } + else { + + if (thread->sched_pri > lowest_unpaired_primary_priority) { + /* Move to end of active queue so that the next thread doesn't also pick it */ + remqueue((queue_entry_t)lp_unpaired_primary_processor); + enqueue_tail(&cset->active_queue, (queue_entry_t)lp_unpaired_primary_processor); + return lp_unpaired_primary_processor; } - else - if (cset->low_count != PROCESSOR_NULL && cset->low_count->state != PROCESSOR_INACTIVE && - cset->low_count->state != PROCESSOR_SHUTDOWN && cset->low_count->state != PROCESSOR_OFF_LINE && - (processor == PROCESSOR_NULL || (thread->sched_pri <= BASEPRI_DEFAULT && - SCHED(processor_runq_count)(cset->low_count) < SCHED(processor_runq_count)(processor)))) { - processor = cset->low_count; + if (thread->sched_pri > lowest_priority) { + /* Move to end of active queue so that the next thread doesn't also pick it */ + remqueue((queue_entry_t)lp_processor); + enqueue_tail(&cset->active_queue, (queue_entry_t)lp_processor); + return lp_processor; } /* - * Otherwise, choose an available processor in the set. + * If all primary processor in this pset are running a higher + * priority thread, move on to next pset. Only when we have + * exhausted this search do we fall back to other heuristics. */ - if (processor == PROCESSOR_NULL) { - processor = (processor_t)dequeue_head(&cset->active_queue); - if (processor != PROCESSOR_NULL) - enqueue_tail(&cset->active_queue, (queue_entry_t)processor); - } - - if (processor != PROCESSOR_NULL && pmeta == PROCESSOR_META_NULL) { - if (processor->processor_meta != PROCESSOR_META_NULL && - !queue_empty(&processor->processor_meta->idle_queue)) - pmeta = processor->processor_meta; - } } /* - * Move onto the next processor set. + * Move onto the next processor set. */ nset = next_pset(cset); @@ -3277,62 +3861,54 @@ choose_processor( } while (nset != pset); /* - * Make sure that we pick a running processor, - * and that the correct processor set is locked. + * Make sure that we pick a running processor, + * and that the correct processor set is locked. + * Since we may have unlock 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. */ do { - if (pmeta != PROCESSOR_META_NULL) { - if (cset != pmeta->primary->processor_set) { - pset_unlock(cset); - - cset = pmeta->primary->processor_set; - pset_lock(cset); - } - - if (!queue_empty(&pmeta->idle_queue)) - return ((processor_t)queue_first(&pmeta->idle_queue)); - - pmeta = PROCESSOR_META_NULL; - } - - /* - * If we haven't been able to choose a processor, - * pick the boot processor and return it. - */ - if (processor == PROCESSOR_NULL) { - processor = master_processor; + /* lowest_priority is evaluated in the main loops above */ + if (lp_unpaired_secondary_processor != PROCESSOR_NULL) { + processor = lp_unpaired_secondary_processor; + lp_unpaired_secondary_processor = PROCESSOR_NULL; + } else if (lc_processor != PROCESSOR_NULL) { + processor = lc_processor; + lc_processor = PROCESSOR_NULL; + } else { /* - * Check that the correct processor set is - * returned locked. + * All processors are executing higher + * priority threads, and the lowest_count + * candidate was not usable */ - if (cset != processor->processor_set) { - pset_unlock(cset); - - cset = processor->processor_set; - pset_lock(cset); - } - - return (processor); + processor = master_processor; } /* - * Check that the processor set for the chosen - * processor is locked. + * Check that the correct processor set is + * returned locked. */ if (cset != processor->processor_set) { pset_unlock(cset); - cset = processor->processor_set; pset_lock(cset); } /* - * We must verify that the chosen processor is still available. + * We must verify that the chosen processor is still available. + * master_processor is an exception, since we may need to preempt + * a running thread on it during processor shutdown (for sleep), + * and that thread needs to be enqueued on its runqueue to run + * when the processor is restarted. */ - if (processor->state == PROCESSOR_INACTIVE || - processor->state == PROCESSOR_SHUTDOWN || processor->state == PROCESSOR_OFF_LINE) + if (processor != master_processor && (processor->state == PROCESSOR_SHUTDOWN || processor->state == PROCESSOR_OFF_LINE)) processor = PROCESSOR_NULL; + } while (processor == PROCESSOR_NULL); return (processor); @@ -3355,9 +3931,7 @@ thread_setrun( processor_t processor; processor_set_t pset; -#if DEBUG assert(thread_runnable(thread)); -#endif /* * Update priority if needed. @@ -3365,6 +3939,8 @@ thread_setrun( 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) { @@ -3379,6 +3955,9 @@ thread_setrun( pset_lock(pset); processor = SCHED(choose_processor)(pset, PROCESSOR_NULL, thread); + + 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 if (thread->last_processor != PROCESSOR_NULL) { @@ -3390,11 +3969,8 @@ thread_setrun( pset_lock(pset); processor = SCHED(choose_processor)(pset, processor, thread); - if ((thread->last_processor != processor) && (thread->last_processor != PROCESSOR_NULL)) { - KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_LPA_BROKEN)|DBG_FUNC_NONE, - (uintptr_t)thread_tid(thread), (uintptr_t)thread->last_processor->cpu_id, (uintptr_t)processor->cpu_id, thread->last_processor->state, 0); - } - + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_CHOOSE_PROCESSOR)|DBG_FUNC_NONE, + (uintptr_t)thread_tid(thread), thread->last_processor->cpu_id, processor->cpu_id, processor->state, 0); } else { /* @@ -3414,6 +3990,9 @@ thread_setrun( processor = SCHED(choose_processor)(pset, PROCESSOR_NULL, thread); task->pset_hint = processor->processor_set; + + 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 { @@ -3425,10 +4004,14 @@ thread_setrun( processor = thread->bound_processor; pset = processor->processor_set; pset_lock(pset); + + 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 choosen processor. + * TODO: This should be based on sched_mode, not sched_pri */ if (thread->sched_pri >= BASEPRI_RTQUEUES) realtime_setrun(processor, thread); @@ -3522,42 +4105,71 @@ processor_queue_shutdown( * Check for a preemption point in * the current context. * - * Called at splsched. + * Called at splsched with thread locked. */ ast_t csw_check( - processor_t processor) + processor_t processor, + ast_t check_reason) { - ast_t result = AST_NONE; + processor_set_t pset = processor->processor_set; + ast_t result; + + pset_lock(pset); + + /* If we were sent a remote AST and interrupted a running processor, acknowledge it here with pset lock held */ + pset->pending_AST_cpu_mask &= ~(1U << processor->cpu_id); + + result = csw_check_locked(processor, pset, check_reason); + + pset_unlock(pset); + + return result; +} + +/* + * Check for preemption at splsched with + * pset and thread locked + */ +ast_t +csw_check_locked( + processor_t processor, + processor_set_t pset __unused, + ast_t check_reason) +{ + ast_t result; + thread_t thread = processor->active_thread; if (first_timeslice(processor)) { if (rt_runq.count > 0) - return (AST_PREEMPT | AST_URGENT); - - result |= SCHED(processor_csw_check)(processor); - if (result & AST_URGENT) - return result; + return (check_reason | AST_PREEMPT | AST_URGENT); } else { - if (rt_runq.count > 0 && BASEPRI_RTQUEUES >= processor->current_pri) - return (AST_PREEMPT | AST_URGENT); - - result |= SCHED(processor_csw_check)(processor); - if (result & AST_URGENT) - return result; + if (rt_runq.count > 0) { + if (BASEPRI_RTQUEUES > processor->current_pri) + return (check_reason | AST_PREEMPT | AST_URGENT); + else + return (check_reason | AST_PREEMPT); + } } + result = SCHED(processor_csw_check)(processor); if (result != AST_NONE) - return (result); + return (check_reason | result); if (SCHED(should_current_thread_rechoose_processor)(processor)) - return (AST_PREEMPT); + return (check_reason | AST_PREEMPT); - if (machine_processor_is_inactive(processor)) - return (AST_PREEMPT); + if (thread->state & TH_SUSP) + return (check_reason | AST_PREEMPT); - if (processor->active_thread->state & TH_SUSP) - return (AST_PREEMPT); + /* + * 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); return (AST_NONE); } @@ -3574,11 +4186,31 @@ csw_check( void set_sched_pri( thread_t thread, - int priority) + int priority) { boolean_t removed = thread_run_queue_remove(thread); + int curgency, nurgency; + uint64_t urgency_param1, urgency_param2; + thread_t cthread = current_thread(); + if (thread == cthread) { + curgency = thread_get_urgency(thread, &urgency_param1, &urgency_param2); + } + thread->sched_pri = priority; + + if (thread == cthread) { + nurgency = thread_get_urgency(thread, &urgency_param1, &urgency_param2); +/* 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 (nurgency != curgency) { + thread_tell_urgency(nurgency, urgency_param1, urgency_param2, thread); + } + } + if (removed) thread_setrun(thread, SCHED_PREEMPT | SCHED_TAILQ); else @@ -3590,7 +4222,8 @@ set_sched_pri( processor->current_pri = priority; processor->current_thmode = thread->sched_mode; - if ((preempt = csw_check(processor)) != AST_NONE) + processor->current_sfi_class = thread->sfi_class = sfi_thread_classify(thread); + if ((preempt = csw_check(processor, AST_NONE)) != AST_NONE) ast_on(preempt); } else @@ -3632,8 +4265,11 @@ run_queue_check( #if defined(CONFIG_SCHED_TRADITIONAL) -/* locks the runqueue itself */ - +/* + * Locks the runqueue itself. + * + * Thread must be locked. + */ static boolean_t processor_queue_remove( processor_t processor, @@ -3670,69 +4306,82 @@ processor_queue_remove( #endif /* CONFIG_SCHED_TRADITIONAL */ + /* * thread_run_queue_remove: * - * Remove a thread from a current run queue and + * 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) + thread_t thread) { - processor_t processor = thread->runq; + boolean_t removed = FALSE; + processor_t processor = thread->runq; - /* - * If processor is PROCESSOR_NULL, the thread will stay out of 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. - */ - if (processor != PROCESSOR_NULL) { - queue_t q; + 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 processor run queues are locked by the - * processor set. Real-time priorities use a - * global queue with a dedicated lock. + * 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. */ - if (thread->sched_mode == TH_MODE_FAIRSHARE) { - return SCHED(fairshare_queue_remove)(thread); - } - - if (thread->sched_pri < BASEPRI_RTQUEUES) { - return SCHED(processor_queue_remove)(processor, thread); - } - simple_lock(&rt_lock); - q = &rt_runq.queue; + return FALSE; + } - if (processor == thread->runq) { - /* - * Thread is on a run queue and we have a lock on - * that run queue. - */ - remqueue((queue_entry_t)thread); - SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count); - rt_runq.count--; + if (thread->sched_mode == TH_MODE_FAIRSHARE) { + return SCHED(fairshare_queue_remove)(thread); + } + + if (thread->sched_pri < BASEPRI_RTQUEUES) { + return SCHED(processor_queue_remove)(processor, thread); + } - thread->runq = PROCESSOR_NULL; - } - else { - /* - * The thread left the run queue before we could - * lock the run queue. - */ - assert(thread->runq == PROCESSOR_NULL); - processor = PROCESSOR_NULL; - } + simple_lock(&rt_lock); - simple_unlock(&rt_lock); + if (thread->runq != PROCESSOR_NULL) { + /* + * Thread is on a run queue and we have a lock on + * that run queue. + */ + + assert(thread->runq == RT_RUNQ); + + remqueue((queue_entry_t)thread); + SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count); + rt_runq.count--; + + thread->runq = PROCESSOR_NULL; + + removed = TRUE; } - return (processor != PROCESSOR_NULL); + simple_unlock(&rt_lock); + + return (removed); } #if defined(CONFIG_SCHED_TRADITIONAL) @@ -3849,41 +4498,47 @@ static thread_t steal_thread_disabled( #endif /* CONFIG_SCHED_TRADITIONAL */ -int -thread_get_urgency(uint64_t *rt_period, uint64_t *rt_deadline) +void +sys_override_cpu_throttle(int flag) { - processor_t processor; - thread_t thread; - - processor = current_processor(); - - thread = processor->next_thread; - - if (thread != NULL) { - if (thread->sched_mode == TH_MODE_REALTIME) { - - if (rt_period != NULL) - *rt_period = thread->realtime.period; - if (rt_deadline != NULL) - *rt_deadline = thread->realtime.deadline; - - KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_GET_URGENCY), THREAD_URGENCY_REAL_TIME, thread->realtime.period, - (thread->realtime.deadline >> 32), thread->realtime.deadline, 0); + if (flag == CPU_THROTTLE_ENABLE) + cpu_throttle_enabled = 1; + if (flag == CPU_THROTTLE_DISABLE) + cpu_throttle_enabled = 0; +} - return (THREAD_URGENCY_REAL_TIME); - } else if ((thread->sched_pri <= MAXPRI_THROTTLE) && - (thread->priority <= MAXPRI_THROTTLE)) { - KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_GET_URGENCY), THREAD_URGENCY_BACKGROUND, thread->sched_pri, thread->priority, 0, 0); - return (THREAD_URGENCY_BACKGROUND); - } - else - KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_GET_URGENCY), THREAD_URGENCY_NORMAL, 0, 0, 0, 0); +int +thread_get_urgency(thread_t thread, uint64_t *arg1, uint64_t *arg2) +{ + if (thread == NULL || (thread->state & TH_IDLE)) { + *arg1 = 0; + *arg2 = 0; + + return (THREAD_URGENCY_NONE); + } else if (thread->sched_mode == TH_MODE_REALTIME) { + *arg1 = thread->realtime.period; + *arg2 = thread->realtime.deadline; + + return (THREAD_URGENCY_REAL_TIME); + } else if (cpu_throttle_enabled && + ((thread->sched_pri <= MAXPRI_THROTTLE) && (thread->priority <= MAXPRI_THROTTLE))) { + /* + * Background urgency applied when thread priority is MAXPRI_THROTTLE or lower and thread is not promoted + * TODO: Use TH_SFLAG_THROTTLED instead? + */ + *arg1 = thread->sched_pri; + *arg2 = thread->priority; + return (THREAD_URGENCY_BACKGROUND); + } else { + /* For otherwise unclassified threads, report throughput QoS + * parameters + */ + *arg1 = thread->effective_policy.t_through_qos; + *arg2 = thread->task->effective_policy.t_through_qos; + return (THREAD_URGENCY_NORMAL); } - else - KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_GET_URGENCY), THREAD_URGENCY_NONE, 0, 0, 0, 0); - return (THREAD_URGENCY_NONE); } @@ -3911,8 +4566,9 @@ processor_idle( int state; (void)splsched(); - KERNEL_DEBUG_CONSTANT( - MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_START, (uintptr_t)thread_tid(thread), 0, 0, 0, 0); + 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); SCHED_STATS_CPU_IDLE_START(processor); @@ -3920,20 +4576,42 @@ processor_idle( mach_absolute_time(), &PROCESSOR_DATA(processor, idle_state)); PROCESSOR_DATA(processor, current_state) = &PROCESSOR_DATA(processor, idle_state); - while (processor->next_thread == THREAD_NULL && SCHED(processor_queue_empty)(processor) && rt_runq.count == 0 && SCHED(fairshare_runq_count)() == 0 && - (thread == THREAD_NULL || ((thread->state & (TH_WAIT|TH_SUSP)) == TH_WAIT && !thread->wake_active))) { + while (1) { + if (processor->state != PROCESSOR_IDLE) /* unsafe, but worst case we loop around once */ + break; + if (pset->pending_AST_cpu_mask & (1U << processor->cpu_id)) + break; + if (rt_runq.count) + break; +#if CONFIG_SCHED_IDLE_IN_PLACE + if (thread != THREAD_NULL) { + /* Did idle-in-place thread wake up */ + if ((thread->state & (TH_WAIT|TH_SUSP)) != TH_WAIT || thread->wake_active) + break; + } +#endif + IDLE_KERNEL_DEBUG_CONSTANT( MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_NONE, (uintptr_t)thread_tid(thread), rt_runq.count, SCHED(processor_runq_count)(processor), -1, 0); + machine_track_platform_idle(TRUE); + machine_idle(); + machine_track_platform_idle(FALSE); + (void)splsched(); IDLE_KERNEL_DEBUG_CONSTANT( MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_NONE, (uintptr_t)thread_tid(thread), rt_runq.count, SCHED(processor_runq_count)(processor), -2, 0); - if (processor->state == PROCESSOR_INACTIVE && !machine_processor_is_inactive(processor)) - break; + 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; + } } timer_switch(&PROCESSOR_DATA(processor, idle_state), @@ -3942,6 +4620,9 @@ processor_idle( pset_lock(pset); + /* If we were sent a remote AST and came out of idle, acknowledge it here with pset lock held */ + pset->pending_AST_cpu_mask &= ~(1U << processor->cpu_id); + state = processor->state; if (state == PROCESSOR_DISPATCHING) { /* @@ -3951,8 +4632,12 @@ processor_idle( processor->next_thread = THREAD_NULL; processor->state = PROCESSOR_RUNNING; - if (SCHED(processor_queue_has_priority)(processor, new_thread->sched_pri, FALSE) || - (rt_runq.count > 0 && BASEPRI_RTQUEUES >= new_thread->sched_pri) ) { + if ((new_thread != THREAD_NULL) && (SCHED(processor_queue_has_priority)(processor, new_thread->sched_pri, FALSE) || + (rt_runq.count > 0 && BASEPRI_RTQUEUES >= new_thread->sched_pri)) ) { + /* Something higher priority has popped up on the runqueue - redispatch this thread elsewhere */ + processor->current_pri = IDLEPRI; + processor->current_thmode = TH_MODE_FIXED; + processor->current_sfi_class = SFI_CLASS_KERNEL; processor->deadline = UINT64_MAX; pset_unlock(pset); @@ -3962,16 +4647,18 @@ processor_idle( thread_setrun(new_thread, SCHED_HEADQ); thread_unlock(new_thread); - KERNEL_DEBUG_CONSTANT( - MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, (uintptr_t)thread_tid(thread), state, 0, 0, 0); + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, + (uintptr_t)thread_tid(thread), state, 0, 0, 0); return (THREAD_NULL); } pset_unlock(pset); - KERNEL_DEBUG_CONSTANT( - MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, (uintptr_t)thread_tid(thread), state, (uintptr_t)thread_tid(new_thread), 0, 0); + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, + (uintptr_t)thread_tid(thread), state, (uintptr_t)thread_tid(new_thread), 0, 0); return (new_thread); } @@ -3980,11 +4667,10 @@ processor_idle( remqueue((queue_entry_t)processor); processor->state = PROCESSOR_RUNNING; - enqueue_tail(&pset->active_queue, (queue_entry_t)processor); - } - else - if (state == PROCESSOR_INACTIVE) { - processor->state = PROCESSOR_RUNNING; + processor->current_pri = IDLEPRI; + processor->current_thmode = TH_MODE_FIXED; + processor->current_sfi_class = SFI_CLASS_KERNEL; + processor->deadline = UINT64_MAX; enqueue_tail(&pset->active_queue, (queue_entry_t)processor); } else @@ -3995,6 +4681,9 @@ processor_idle( */ if ((new_thread = processor->next_thread) != THREAD_NULL) { processor->next_thread = THREAD_NULL; + processor->current_pri = IDLEPRI; + processor->current_thmode = TH_MODE_FIXED; + processor->current_sfi_class = SFI_CLASS_KERNEL; processor->deadline = UINT64_MAX; pset_unlock(pset); @@ -4003,8 +4692,9 @@ processor_idle( thread_setrun(new_thread, SCHED_HEADQ); thread_unlock(new_thread); - KERNEL_DEBUG_CONSTANT( - MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, (uintptr_t)thread_tid(thread), state, 0, 0, 0); + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, + (uintptr_t)thread_tid(thread), state, 0, 0, 0); return (THREAD_NULL); } @@ -4012,8 +4702,9 @@ processor_idle( pset_unlock(pset); - KERNEL_DEBUG_CONSTANT( - MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, (uintptr_t)thread_tid(thread), state, 0, 0, 0); + KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, + MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, + (uintptr_t)thread_tid(thread), state, 0, 0, 0); return (THREAD_NULL); } @@ -4057,6 +4748,7 @@ idle_thread_create( processor->idle_thread = thread; thread->sched_pri = thread->priority = IDLEPRI; thread->state = (TH_RUN | TH_IDLE); + thread->options |= TH_OPT_IDLE_THREAD; thread_unlock(thread); splx(s); @@ -4079,134 +4771,171 @@ sched_startup(void) thread_t thread; result = kernel_thread_start_priority((thread_continue_t)sched_init_thread, - (void *)SCHED(maintenance_continuation), - MAXPRI_KERNEL, &thread); + (void *)SCHED(maintenance_continuation), MAXPRI_KERNEL, &thread); if (result != KERN_SUCCESS) panic("sched_startup"); thread_deallocate(thread); /* - * Yield to the sched_init_thread while it times - * a series of context switches back. It stores - * the baseline value in sched_cswtime. + * 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. */ - while (sched_cswtime == 0) - thread_block(THREAD_CONTINUE_NULL); + thread_block(THREAD_CONTINUE_NULL); } -#if defined(CONFIG_SCHED_TRADITIONAL) - -static uint64_t sched_tick_deadline = 0; +#if defined(CONFIG_SCHED_TIMESHARE_CORE) +static volatile uint64_t sched_maintenance_deadline; +#if defined(CONFIG_TELEMETRY) +static volatile uint64_t sched_telemetry_deadline = 0; +#endif +static uint64_t sched_tick_last_abstime; +static uint64_t sched_tick_delta; +uint64_t sched_tick_max_delta; /* * sched_init_thread: * * Perform periodic bookkeeping functions about ten * times per second. */ -static void -sched_traditional_tick_continue(void) +void +sched_traditional_maintenance_continue(void) { - uint64_t abstime = mach_absolute_time(); + uint64_t sched_tick_ctime, late_time; + + 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); + } - sched_tick++; + 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; /* * Compute various averages. */ - compute_averages(); + compute_averages(sched_tick_delta); /* * Scan the run queues for threads which * may need to be updated. */ - thread_update_scan(); + SCHED(thread_update_scan)(); - if (sched_tick_deadline == 0) - sched_tick_deadline = abstime; - - clock_deadline_for_periodic_event(sched_tick_interval, abstime, - &sched_tick_deadline); + KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_MAINTENANCE)|DBG_FUNC_END, + sched_pri_shift, + sched_background_pri_shift, + 0, + 0, + 0); - assert_wait_deadline((event_t)sched_traditional_tick_continue, THREAD_UNINT, sched_tick_deadline); - thread_block((thread_continue_t)sched_traditional_tick_continue); + assert_wait((event_t)sched_traditional_maintenance_continue, THREAD_UNINT); + thread_block((thread_continue_t)sched_traditional_maintenance_continue); /*NOTREACHED*/ } -#endif /* CONFIG_SCHED_TRADITIONAL */ +static uint64_t sched_maintenance_wakeups; -static uint32_t -time_individual_cswitch(void) -{ - uint32_t switches = 0; - uint64_t newtime, starttime; +/* + * 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_traditional_consider_maintenance(uint64_t ctime) { + uint64_t ndeadline, deadline = sched_maintenance_deadline; - /* Wait for absolute time to increase. */ - starttime = mach_absolute_time(); - do { - newtime = mach_absolute_time(); - } while (newtime == starttime); + if (__improbable(ctime >= deadline)) { + if (__improbable(current_thread() == sched_maintenance_thread)) + return; + OSMemoryBarrier(); - /* Measure one or more context switches until time increases again. - * This ensures we get non-zero timings even if absolute time - * increases very infrequently compared to CPU clock. */ - starttime = newtime; - do { - thread_block(THREAD_CONTINUE_NULL); - newtime = mach_absolute_time(); - ++switches; - } while (newtime == starttime); - /* Round up. */ - return (uint32_t) ((newtime - starttime + switches - 1) / switches); -} + ndeadline = ctime + sched_tick_interval; -/* - * Time a series of context switches to determine - * a baseline. Toss the high and low and return - * the one-way value. - */ -static uint32_t -time_cswitch(void) -{ - uint32_t new, hi, low, accum; - int i, tries = 7, denom; + if (__probable(__sync_bool_compare_and_swap(&sched_maintenance_deadline, deadline, ndeadline))) { + thread_wakeup((event_t)sched_traditional_maintenance_continue); + sched_maintenance_wakeups++; + } + } - accum = hi = low = 0; - for (i = 0; i < tries; ++i) { - new = time_individual_cswitch(); +#if defined(CONFIG_TELEMETRY) + /* + * Windowed telemetry is driven by the scheduler. It should be safe + * to call compute_telemetry_windowed() even when windowed telemetry + * is disabled, but we should try to avoid doing extra work for no + * reason. + */ + if (telemetry_window_enabled) { + deadline = sched_telemetry_deadline; - if (i == 0) - accum = hi = low = new; - else { - if (new < low) - low = new; - else - if (new > hi) - hi = new; - accum += new; + if (__improbable(ctime >= deadline)) { + ndeadline = ctime + sched_telemetry_interval; + + if (__probable(__sync_bool_compare_and_swap(&sched_telemetry_deadline, deadline, ndeadline))) { + compute_telemetry_windowed(); + } } } - /* Round up. */ - denom = 2 * (tries - 2); - return (accum - hi - low + denom - 1) / denom; +#endif /* CONFIG_TELEMETRY */ } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + void sched_init_thread(void (*continuation)(void)) { - sched_cswtime = time_cswitch(); - assert(sched_cswtime > 0); + thread_block(THREAD_CONTINUE_NULL); + sched_maintenance_thread = current_thread(); continuation(); /*NOTREACHED*/ } -#if defined(CONFIG_SCHED_TRADITIONAL) +#if defined(CONFIG_SCHED_TIMESHARE_CORE) /* * thread_update_scan / runq_scan: @@ -4229,12 +4958,44 @@ sched_init_thread(void (*continuation)(void)) static thread_t thread_update_array[THREAD_UPDATE_SIZE]; static int 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 +thread_update_process_threads(void) +{ + while (thread_update_count > 0) { + spl_t s; + thread_t thread = thread_update_array[--thread_update_count]; + thread_update_array[thread_update_count] = THREAD_NULL; + + s = splsched(); + thread_lock(thread); + if (!(thread->state & (TH_WAIT)) && (SCHED(can_update_priority)(thread))) { + SCHED(update_priority)(thread); + } + thread_unlock(thread); + splx(s); + + thread_deallocate(thread); + } +} + /* * Scan a runq for candidate threads. * * Returns TRUE if retry is needed. */ -static boolean_t +boolean_t runq_scan( run_queue_t runq) { @@ -4248,11 +5009,8 @@ runq_scan( queue_iterate(q, thread, thread_t, links) { if ( thread->sched_stamp != sched_tick && (thread->sched_mode == TH_MODE_TIMESHARE) ) { - if (thread_update_count == THREAD_UPDATE_SIZE) + if (thread_update_add_thread(thread) == FALSE) return (TRUE); - - thread_update_array[thread_update_count++] = thread; - thread_reference_internal(thread); } count--; @@ -4265,6 +5023,10 @@ runq_scan( return (FALSE); } +#endif /* CONFIG_SCHED_TIMESHARE_CORE */ + +#if defined(CONFIG_SCHED_TRADITIONAL) + static void thread_update_scan(void) { @@ -4276,6 +5038,10 @@ thread_update_scan(void) do { do { + /* + * TODO: in sched_traditional_use_pset_runqueue case, + * avoid scanning the same runq multiple times + */ pset = processor->processor_set; s = splsched(); @@ -4291,34 +5057,15 @@ thread_update_scan(void) thread = processor->idle_thread; if (thread != THREAD_NULL && thread->sched_stamp != sched_tick) { - if (thread_update_count == THREAD_UPDATE_SIZE) { + if (thread_update_add_thread(thread) == FALSE) { restart_needed = TRUE; break; } - - thread_update_array[thread_update_count++] = thread; - thread_reference_internal(thread); } } while ((processor = processor->processor_list) != NULL); - /* - * Ok, we now have a collection of candidates -- fix them. - */ - while (thread_update_count > 0) { - thread = thread_update_array[--thread_update_count]; - thread_update_array[thread_update_count] = THREAD_NULL; - - s = splsched(); - thread_lock(thread); - if ( !(thread->state & (TH_WAIT)) ) { - if (SCHED(can_update_priority)(thread)) - SCHED(update_priority)(thread); - } - thread_unlock(thread); - splx(s); - - thread_deallocate(thread); - } + /* Ok, we now have a collection of candidates -- fix them. */ + thread_update_process_threads(); } while (restart_needed); } @@ -4344,9 +5091,9 @@ thread_set_eager_preempt(thread_t thread) thread->sched_flags |= TH_SFLAG_EAGERPREEMPT; if (thread == current_thread()) { - thread_unlock(thread); - ast = csw_check(p); + ast = csw_check(p, AST_NONE); + thread_unlock(thread); if (ast != AST_NONE) { (void) thread_block_reason(THREAD_CONTINUE_NULL, NULL, ast); } @@ -4438,43 +5185,15 @@ preemption_enabled(void) return (get_preemption_level() == 0 && ml_get_interrupts_enabled()); } -#if DEBUG -static boolean_t +__assert_only static boolean_t thread_runnable( thread_t thread) { return ((thread->state & (TH_RUN|TH_WAIT)) == TH_RUN); } -#endif /* DEBUG */ - -#if MACH_KDB -#include -#define printf kdbprintf -void db_sched(void); - -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\n", - c_idle_thread_handoff, - c_idle_thread_block); - iprintf("Sched thread blocks: %d\n", c_sched_thread_block); -#endif /* MACH_COUNTERS */ - db_indent -= 2; -} - -#include -void db_show_thread_log(void); -void -db_show_thread_log(void) -{ +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); } -#endif /* MACH_KDB */