/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2009 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License"). You may not use this file except in compliance with the
- * License. Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
*
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
*
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
/*
* @OSF_FREE_COPYRIGHT@
*/
#include <debug.h>
-#include <cpus.h>
#include <mach_kdb.h>
-#include <simple_clock.h>
-#include <power_save.h>
-#include <task_swapper.h>
#include <ddb/db_output.h>
+
+#include <mach/mach_types.h>
#include <mach/machine.h>
+#include <mach/policy.h>
+#include <mach/sync_policy.h>
+#include <mach/thread_act.h>
+
#include <machine/machine_routines.h>
#include <machine/sched_param.h>
-#include <kern/ast.h>
+#include <machine/machine_cpu.h>
+#include <machine/machlimits.h>
+
+#include <kern/kern_types.h>
#include <kern/clock.h>
#include <kern/counters.h>
#include <kern/cpu_number.h>
#include <kern/cpu_data.h>
-#include <kern/etap_macros.h>
+#include <kern/debug.h>
#include <kern/lock.h>
#include <kern/macro_help.h>
#include <kern/machine.h>
#include <kern/syscall_subr.h>
#include <kern/task.h>
#include <kern/thread.h>
-#include <kern/thread_swap.h>
+#include <kern/wait_queue.h>
+
#include <vm/pmap.h>
#include <vm/vm_kern.h>
#include <vm/vm_map.h>
-#include <mach/policy.h>
-#include <mach/sync_policy.h>
-#include <kern/sf.h>
-#include <kern/mk_sp.h> /*** ??? fix so this can be removed ***/
+
+#include <mach/sdt.h>
+
#include <sys/kdebug.h>
-#if TASK_SWAPPER
-#include <kern/task_swap.h>
-extern int task_swap_on;
-#endif /* TASK_SWAPPER */
+#include <kern/pms.h>
+
+struct rt_queue rt_runq;
+#define RT_RUNQ ((processor_t)-1)
+decl_simple_lock_data(static,rt_lock);
-extern int hz;
+#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY)
+static struct fairshare_queue fs_runq;
+#define FS_RUNQ ((processor_t)-2)
+decl_simple_lock_data(static,fs_lock);
+#endif
-#define DEFAULT_PREEMPTION_RATE 100 /* (1/s) */
+#define DEFAULT_PREEMPTION_RATE 100 /* (1/s) */
int default_preemption_rate = DEFAULT_PREEMPTION_RATE;
-#define NO_KERNEL_PREEMPT 0
-#define KERNEL_PREEMPT 1
-int kernel_preemption_mode = KERNEL_PREEMPT;
+#define MAX_UNSAFE_QUANTA 800
+int max_unsafe_quanta = MAX_UNSAFE_QUANTA;
+
+#define MAX_POLL_QUANTA 2
+int max_poll_quanta = MAX_POLL_QUANTA;
+
+#define SCHED_POLL_YIELD_SHIFT 4 /* 1/16 */
+int sched_poll_yield_shift = SCHED_POLL_YIELD_SHIFT;
+
+uint64_t max_poll_computation;
-int min_quantum;
-natural_t min_quantum_ms;
+uint64_t max_unsafe_computation;
+uint64_t sched_safe_duration;
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+uint32_t std_quantum;
+uint32_t min_std_quantum;
+
+uint32_t std_quantum_us;
+
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+uint32_t thread_depress_time;
+uint32_t default_timeshare_computation;
+uint32_t default_timeshare_constraint;
+
+uint32_t max_rt_quantum;
+uint32_t min_rt_quantum;
+
+uint32_t sched_cswtime;
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
unsigned sched_tick;
+uint32_t sched_tick_interval;
+
+uint32_t sched_pri_shift = INT8_MAX;
+uint32_t sched_fixed_shift;
+
+static boolean_t sched_traditional_use_pset_runqueue = FALSE;
+
+__attribute__((always_inline))
+static inline run_queue_t runq_for_processor(processor_t processor)
+{
+ if (sched_traditional_use_pset_runqueue)
+ return &processor->processor_set->pset_runq;
+ else
+ return &processor->runq;
+}
+
+__attribute__((always_inline))
+static inline void runq_consider_incr_bound_count(processor_t processor, thread_t thread)
+{
+ if (thread->bound_processor == PROCESSOR_NULL)
+ return;
+
+ assert(thread->bound_processor == processor);
+
+ if (sched_traditional_use_pset_runqueue)
+ processor->processor_set->pset_runq_bound_count++;
+
+ processor->runq_bound_count++;
+}
+
+__attribute__((always_inline))
+static inline void runq_consider_decr_bound_count(processor_t processor, thread_t thread)
+{
+ if (thread->bound_processor == PROCESSOR_NULL)
+ return;
+
+ assert(thread->bound_processor == processor);
+
+ if (sched_traditional_use_pset_runqueue)
+ processor->processor_set->pset_runq_bound_count--;
+
+ processor->runq_bound_count--;
+}
+
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+uint64_t sched_one_second_interval;
-#if SIMPLE_CLOCK
-int sched_usec;
-#endif /* SIMPLE_CLOCK */
+uint32_t sched_run_count, sched_share_count;
+uint32_t sched_load_average, sched_mach_factor;
/* Forwards */
-void thread_continue(thread_t);
-void wait_queues_init(void);
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+static void load_shift_init(void) __attribute__((section("__TEXT, initcode")));
+static void preempt_pri_init(void) __attribute__((section("__TEXT, initcode")));
+
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+static thread_t thread_select(
+ thread_t thread,
+ processor_t processor);
+
+#if CONFIG_SCHED_IDLE_IN_PLACE
+static thread_t thread_select_idle(
+ thread_t thread,
+ processor_t processor);
+#endif
+
+thread_t processor_idle(
+ thread_t thread,
+ processor_t processor);
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+static thread_t steal_thread(
+ processor_set_t pset);
+
+static thread_t steal_thread_disabled(
+ processor_set_t pset) __attribute__((unused));
+
+
+static thread_t steal_processor_thread(
+ processor_t processor);
+
+static void thread_update_scan(void);
+
+static void processor_setrun(
+ processor_t processor,
+ thread_t thread,
+ integer_t options);
+
+static boolean_t
+processor_enqueue(
+ processor_t processor,
+ thread_t thread,
+ integer_t options);
+
+static boolean_t
+processor_queue_remove(
+ processor_t processor,
+ thread_t thread);
+
+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,
+ int priority,
+ boolean_t gte);
+
+static boolean_t should_current_thread_rechoose_processor(processor_t processor);
+
+static int sched_traditional_processor_runq_count(processor_t processor);
+
+static boolean_t sched_traditional_with_pset_runqueue_processor_queue_empty(processor_t processor);
+
+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 void
+sched_traditional_init(void);
+
+static void
+sched_traditional_timebase_init(void);
+
+static void
+sched_traditional_processor_init(processor_t processor);
+
+static void
+sched_traditional_pset_init(processor_set_t pset);
+
+static void
+sched_traditional_with_pset_runqueue_init(void);
-void set_pri(
- thread_t thread,
- int pri,
- int resched);
+#endif
+
+static void
+sched_realtime_init(void) __attribute__((section("__TEXT, initcode")));
+
+static void
+sched_realtime_timebase_init(void);
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+static void
+sched_traditional_tick_continue(void);
-thread_t choose_pset_thread(
- processor_t myprocessor,
- processor_set_t pset);
+static uint32_t
+sched_traditional_initial_quantum_size(thread_t thread);
-thread_t choose_thread(
- processor_t myprocessor);
+static sched_mode_t
+sched_traditional_initial_thread_sched_mode(task_t parent_task);
-int run_queue_enqueue(
- run_queue_t runq,
- thread_t thread,
- boolean_t tail);
+static boolean_t
+sched_traditional_supports_timeshare_mode(void);
-void idle_thread_continue(void);
-void do_thread_scan(void);
+static thread_t
+sched_traditional_choose_thread(
+ processor_t processor,
+ int priority);
-void clear_wait_internal(
- thread_t thread,
- int result);
+#endif
#if DEBUG
-void dump_run_queues(
- run_queue_t rq);
-void dump_run_queue_struct(
- run_queue_t rq);
-void dump_processor(
- processor_t p);
-void dump_processor_set(
- processor_set_t ps);
-
-void checkrq(
- run_queue_t rq,
- char *msg);
-
-void thread_check(
- thread_t thread,
- run_queue_t runq);
-#endif /*DEBUG*/
+extern int debug_task;
+#define TLOG(a, fmt, args...) if(debug_task & a) kprintf(fmt, ## args)
+#else
+#define TLOG(a, fmt, args...) do {} while (0)
+#endif
+#if DEBUG
+static
boolean_t thread_runnable(
thread_t thread);
+#endif /*DEBUG*/
+
/*
* State machine
*
*
*/
+#if defined(CONFIG_SCHED_TRADITIONAL)
+int8_t sched_load_shifts[NRQS];
+int sched_preempt_pri[NRQBM];
+#endif
+
+
+#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 */
+};
+
+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 */
+};
+
+#endif
+
+const struct sched_dispatch_table *sched_current_dispatch = NULL;
+
/*
- * Waiting protocols and implementation:
- *
- * Each thread may be waiting for exactly one event; this event
- * is set using assert_wait(). That thread may be awakened either
- * by performing a thread_wakeup_prim() on its event,
- * or by directly waking that thread up with clear_wait().
- *
- * The implementation of wait events uses a hash table. Each
- * bucket is queue of threads having the same hash function
- * value; the chain for the queue (linked list) is the run queue
- * field. [It is not possible to be waiting and runnable at the
- * same time.]
+ * Statically allocate a buffer to hold the longest possible
+ * scheduler description string, as currently implemented.
+ * bsd/kern/kern_sysctl.c has a corresponding definition in bsd/
+ * to export to userspace via sysctl(3). If either version
+ * changes, update the other.
*
- * Locks on both the thread and on the hash buckets govern the
- * wait event field and the queue chain field. Because wakeup
- * operations only have the event as an argument, the event hash
- * bucket must be locked before any thread.
- *
- * Scheduling operations may also occur at interrupt level; therefore,
- * interrupts below splsched() must be prevented when holding
- * thread or hash bucket locks.
- *
- * The wait event hash table declarations are as follows:
+ * Note that in addition to being an upper bound on the strings
+ * in the kernel, it's also an exact parameter to PE_get_default(),
+ * which interrogates the device tree on some platforms. That
+ * API requires the caller know the exact size of the device tree
+ * property, so we need both a legacy size (32) and the current size
+ * (48) to deal with old and new device trees. The device tree property
+ * is similarly padded to a fixed size so that the same kernel image
+ * can run on multiple devices with different schedulers configured
+ * in the device tree.
*/
+#define SCHED_STRING_MAX_LENGTH (48)
-#define NUMQUEUES 59
+char sched_string[SCHED_STRING_MAX_LENGTH];
+static enum sched_enum _sched_enum = sched_enum_unknown;
-struct wait_queue wait_queues[NUMQUEUES];
+void
+sched_init(void)
+{
+ char sched_arg[SCHED_STRING_MAX_LENGTH] = { '\0' };
+
+ /* Check for runtime selection of the scheduler algorithm */
+ if (!PE_parse_boot_argn("sched", sched_arg, sizeof (sched_arg))) {
+ /* If no boot-args override, look in device tree */
+ if (!PE_get_default("kern.sched", sched_arg,
+ SCHED_STRING_MAX_LENGTH)) {
+ sched_arg[0] = '\0';
+ }
+ }
-#define wait_hash(event) \
- ((((int)(event) < 0)? ~(int)(event): (int)(event)) % NUMQUEUES)
+ if (strlen(sched_arg) > 0) {
+ if (0) {
+ /* Allow pattern below */
+#if defined(CONFIG_SCHED_TRADITIONAL)
+ } else if (0 == strcmp(sched_arg, kSchedTraditionalString)) {
+ 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);
+#endif
+ } else {
+ panic("Unrecognized scheduler algorithm: %s", sched_arg);
+ }
+ } 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);
+#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
+ }
+
+ SCHED(init)();
+ SCHED(fairshare_init)();
+ sched_realtime_init();
+ ast_init();
+
+ SCHED(pset_init)(&pset0);
+ SCHED(processor_init)(master_processor);
+}
void
-sched_init(void)
+sched_timebase_init(void)
+{
+ uint64_t abstime;
+
+ clock_interval_to_absolutetime_interval(1, NSEC_PER_SEC, &abstime);
+ sched_one_second_interval = abstime;
+
+ SCHED(timebase_init)();
+ sched_realtime_timebase_init();
+}
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+static void
+sched_traditional_init(void)
{
/*
- * Calculate the minimum quantum
- * in ticks.
+ * Calculate the timeslicing quantum
+ * in us.
*/
if (default_preemption_rate < 1)
default_preemption_rate = DEFAULT_PREEMPTION_RATE;
- min_quantum = hz / default_preemption_rate;
+ std_quantum_us = (1000 * 1000) / default_preemption_rate;
+
+ printf("standard timeslicing quantum is %d us\n", std_quantum_us);
+
+ load_shift_init();
+ preempt_pri_init();
+ sched_tick = 0;
+}
+
+static void
+sched_traditional_timebase_init(void)
+{
+ uint64_t abstime;
+ uint32_t shift;
+
+ /* standard timeslicing quantum */
+ clock_interval_to_absolutetime_interval(
+ std_quantum_us, NSEC_PER_USEC, &abstime);
+ assert((abstime >> 32) == 0 && (uint32_t)abstime != 0);
+ std_quantum = (uint32_t)abstime;
+
+ /* smallest remaining quantum (250 us) */
+ clock_interval_to_absolutetime_interval(250, NSEC_PER_USEC, &abstime);
+ assert((abstime >> 32) == 0 && (uint32_t)abstime != 0);
+ min_std_quantum = (uint32_t)abstime;
+
+ /* scheduler tick interval */
+ clock_interval_to_absolutetime_interval(USEC_PER_SEC >> SCHED_TICK_SHIFT,
+ NSEC_PER_USEC, &abstime);
+ assert((abstime >> 32) == 0 && (uint32_t)abstime != 0);
+ sched_tick_interval = (uint32_t)abstime;
/*
- * Round up result (4/5) to an
- * integral number of ticks.
+ * Compute conversion factor from usage to
+ * timesharing priorities with 5/8 ** n aging.
*/
- if (((hz * 10) / default_preemption_rate) - (min_quantum * 10) >= 5)
- min_quantum++;
- if (min_quantum < 1)
- min_quantum = 1;
+ abstime = (abstime * 5) / 3;
+ for (shift = 0; abstime > BASEPRI_DEFAULT; ++shift)
+ abstime >>= 1;
+ sched_fixed_shift = shift;
- min_quantum_ms = (1000 / hz) * min_quantum;
+ max_unsafe_computation = max_unsafe_quanta * std_quantum;
+ sched_safe_duration = 2 * max_unsafe_quanta * std_quantum;
+
+ max_poll_computation = max_poll_quanta * std_quantum;
+ thread_depress_time = 1 * std_quantum;
+ default_timeshare_computation = std_quantum / 2;
+ default_timeshare_constraint = std_quantum;
- printf("scheduling quantum is %d ms\n", min_quantum_ms);
+}
- wait_queues_init();
- pset_sys_bootstrap(); /* initialize processor mgmt. */
- processor_action();
- sched_tick = 0;
-#if SIMPLE_CLOCK
- sched_usec = 0;
-#endif /* SIMPLE_CLOCK */
- ast_init();
- sf_init();
+static void
+sched_traditional_processor_init(processor_t processor)
+{
+ if (!sched_traditional_use_pset_runqueue) {
+ run_queue_init(&processor->runq);
+ }
+ processor->runq_bound_count = 0;
+}
+
+static void
+sched_traditional_pset_init(processor_set_t pset)
+{
+ if (sched_traditional_use_pset_runqueue) {
+ run_queue_init(&pset->pset_runq);
+ }
+ pset->pset_runq_bound_count = 0;
+}
+
+static void
+sched_traditional_with_pset_runqueue_init(void)
+{
+ sched_traditional_init();
+ sched_traditional_use_pset_runqueue = TRUE;
}
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY)
void
-wait_queues_init(void)
+sched_traditional_fairshare_init(void)
+{
+ simple_lock_init(&fs_lock, 0);
+
+ fs_runq.count = 0;
+ queue_init(&fs_runq.queue);
+}
+#endif
+
+static void
+sched_realtime_init(void)
+{
+ simple_lock_init(&rt_lock, 0);
+
+ rt_runq.count = 0;
+ queue_init(&rt_runq.queue);
+}
+
+static void
+sched_realtime_timebase_init(void)
+{
+ uint64_t abstime;
+
+ /* smallest rt computaton (50 us) */
+ clock_interval_to_absolutetime_interval(50, NSEC_PER_USEC, &abstime);
+ assert((abstime >> 32) == 0 && (uint32_t)abstime != 0);
+ min_rt_quantum = (uint32_t)abstime;
+
+ /* maximum rt computation (50 ms) */
+ clock_interval_to_absolutetime_interval(
+ 50, 1000*NSEC_PER_USEC, &abstime);
+ assert((abstime >> 32) == 0 && (uint32_t)abstime != 0);
+ max_rt_quantum = (uint32_t)abstime;
+
+}
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+/*
+ * Set up values for timeshare
+ * loading factors.
+ */
+static void
+load_shift_init(void)
{
- register int i;
+ int8_t k, *p = sched_load_shifts;
+ uint32_t i, j;
+
+ *p++ = INT8_MIN; *p++ = 0;
- for (i = 0; i < NUMQUEUES; i++) {
- wait_queue_init(&wait_queues[i], SYNC_POLICY_FIFO);
+ for (i = j = 2, k = 1; i < NRQS; ++k) {
+ for (j <<= 1; i < j; ++i)
+ *p++ = k;
}
}
+static void
+preempt_pri_init(void)
+{
+ int i, *p = sched_preempt_pri;
+
+ for (i = BASEPRI_FOREGROUND + 1; i < MINPRI_KERNEL; ++i)
+ setbit(i, p);
+
+ for (i = BASEPRI_PREEMPT; i <= MAXPRI; ++i)
+ setbit(i, p);
+}
+
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
/*
- * Thread timeout routine, called when timer expires.
+ * Thread wait timer expiration.
*/
void
thread_timer_expire(
- timer_call_param_t p0,
- timer_call_param_t p1)
+ void *p0,
+ __unused void *p1)
{
thread_t thread = p0;
spl_t s;
s = splsched();
- wake_lock(thread);
- if ( thread->wait_timer_is_set &&
- !timer_call_is_delayed(&thread->wait_timer, NULL) ) {
- thread->wait_timer_active--;
- thread->wait_timer_is_set = FALSE;
- thread_lock(thread);
- if (thread->active)
+ thread_lock(thread);
+ if (--thread->wait_timer_active == 0) {
+ if (thread->wait_timer_is_set) {
+ thread->wait_timer_is_set = FALSE;
clear_wait_internal(thread, THREAD_TIMED_OUT);
- thread_unlock(thread);
+ }
}
- else
- if (--thread->wait_timer_active == 0)
- thread_wakeup_one(&thread->wait_timer_active);
- wake_unlock(thread);
+ thread_unlock(thread);
splx(s);
}
+#ifndef __LP64__
+
/*
* thread_set_timer:
*
*/
void
thread_set_timer(
- natural_t interval,
- natural_t scale_factor)
+ uint32_t interval,
+ uint32_t scale_factor)
{
thread_t thread = current_thread();
- AbsoluteTime deadline;
+ uint64_t deadline;
spl_t s;
s = splsched();
- wake_lock(thread);
thread_lock(thread);
if ((thread->state & TH_WAIT) != 0) {
clock_interval_to_deadline(interval, scale_factor, &deadline);
- timer_call_enter(&thread->wait_timer, deadline);
- assert(!thread->wait_timer_is_set);
- thread->wait_timer_active++;
+ 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);
- wake_unlock(thread);
splx(s);
}
void
thread_set_timer_deadline(
- AbsoluteTime deadline)
+ uint64_t deadline)
{
thread_t thread = current_thread();
spl_t s;
s = splsched();
- wake_lock(thread);
thread_lock(thread);
if ((thread->state & TH_WAIT) != 0) {
- timer_call_enter(&thread->wait_timer, deadline);
- assert(!thread->wait_timer_is_set);
- thread->wait_timer_active++;
+ 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);
- wake_unlock(thread);
splx(s);
}
spl_t s;
s = splsched();
- wake_lock(thread);
+ 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;
}
- wake_unlock(thread);
+ thread_unlock(thread);
splx(s);
}
-/*
- * thread_depress_timeout:
- *
- * Timeout routine for priority depression.
- */
-void
-thread_depress_timeout(
- thread_call_param_t p0,
- thread_call_param_t p1)
-{
- thread_t thread = p0;
- sched_policy_t *policy;
- spl_t s;
-
- s = splsched();
- thread_lock(thread);
- policy = policy_id_to_sched_policy(thread->policy);
- thread_unlock(thread);
- splx(s);
-
- if (policy != SCHED_POLICY_NULL)
- policy->sp_ops.sp_thread_depress_timeout(policy, thread);
-
- thread_deallocate(thread);
-}
+#endif /* __LP64__ */
/*
- * Set up thread timeout element when thread is created.
+ * thread_unblock:
+ *
+ * Unblock thread on wake up.
+ *
+ * Returns TRUE if the thread is still running.
+ *
+ * Thread must be locked.
*/
-void
-thread_timer_setup(
- thread_t thread)
+boolean_t
+thread_unblock(
+ thread_t thread,
+ wait_result_t wresult)
{
- timer_call_setup(&thread->wait_timer, thread_timer_expire, thread);
- thread->wait_timer_is_set = FALSE;
- thread->wait_timer_active = 1;
- thread->ref_count++;
-
- thread_call_setup(&thread->depress_timer, thread_depress_timeout, thread);
-}
+ boolean_t result = FALSE;
-void
-thread_timer_terminate(void)
-{
- thread_t thread = current_thread();
- spl_t s;
+ /*
+ * Set wait_result.
+ */
+ thread->wait_result = wresult;
- s = splsched();
- wake_lock(thread);
+ /*
+ * Cancel pending wait timer.
+ */
if (thread->wait_timer_is_set) {
if (timer_call_cancel(&thread->wait_timer))
thread->wait_timer_active--;
thread->wait_timer_is_set = FALSE;
}
- thread->wait_timer_active--;
+ /*
+ * Update scheduling state: not waiting,
+ * set running.
+ */
+ thread->state &= ~(TH_WAIT|TH_UNINT);
- while (thread->wait_timer_active > 0) {
- assert_wait((event_t)&thread->wait_timer_active, THREAD_UNINT);
- wake_unlock(thread);
- splx(s);
+ if (!(thread->state & TH_RUN)) {
+ thread->state |= TH_RUN;
- thread_block((void (*)(void)) 0);
+ (*thread->sched_call)(SCHED_CALL_UNBLOCK, thread);
- s = splsched();
- wake_lock(thread);
+ /*
+ * Update run counts.
+ */
+ sched_run_incr();
+ if (thread->sched_mode == TH_MODE_TIMESHARE)
+ sched_share_incr();
+ }
+ else {
+ /*
+ * Signal if idling on another processor.
+ */
+#if CONFIG_SCHED_IDLE_IN_PLACE
+ if (thread->state & TH_IDLE) {
+ processor_t processor = thread->last_processor;
+
+ if (processor != current_processor())
+ machine_signal_idle(processor);
+ }
+#else
+ assert((thread->state & TH_IDLE) == 0);
+#endif
+
+ result = TRUE;
}
- wake_unlock(thread);
- splx(s);
+ /*
+ * 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;
+ }
- thread_deallocate(thread);
+ /*
+ * Clear old quantum, fail-safe computation, etc.
+ */
+ thread->current_quantum = 0;
+ thread->computation_metered = 0;
+ thread->reason = AST_NONE;
+
+ KERNEL_DEBUG_CONSTANT(
+ MACHDBG_CODE(DBG_MACH_SCHED,MACH_MAKE_RUNNABLE) | DBG_FUNC_NONE,
+ (uintptr_t)thread_tid(thread), thread->sched_pri, 0, 0, 0);
+
+ DTRACE_SCHED2(wakeup, struct thread *, thread, struct proc *, thread->task->bsd_info);
+
+ return (result);
}
/*
- * Routine: thread_go_locked
+ * Routine: thread_go
* Purpose:
- * Start a thread running.
+ * Unblock and dispatch thread.
* Conditions:
* thread lock held, IPC locks may be held.
* thread must have been pulled from wait queue under same lock hold.
+ * Returns:
+ * KERN_SUCCESS - Thread was set running
+ * KERN_NOT_WAITING - Thread was not waiting
*/
-void
-thread_go_locked(
+kern_return_t
+thread_go(
thread_t thread,
- int result)
+ wait_result_t wresult)
{
- int state;
- sched_policy_t *policy;
- sf_return_t sfr;
-
assert(thread->at_safe_point == FALSE);
- assert(thread->wait_event == NO_EVENT);
+ assert(thread->wait_event == NO_EVENT64);
assert(thread->wait_queue == WAIT_QUEUE_NULL);
- if (thread->state & TH_WAIT) {
-
- thread->state &= ~(TH_WAIT|TH_UNINT);
- if (!(thread->state & TH_RUN)) {
- thread->state |= TH_RUN;
-#if THREAD_SWAPPER
- if (thread->state & TH_SWAPPED_OUT)
- thread_swapin(thread->top_act, FALSE);
- else
-#endif /* THREAD_SWAPPER */
- {
- policy = &sched_policy[thread->policy];
- sfr = policy->sp_ops.sp_thread_unblock(policy, thread);
- assert(sfr == SF_SUCCESS);
- }
- }
- thread->wait_result = result;
+ if ((thread->state & (TH_WAIT|TH_TERMINATE)) == TH_WAIT) {
+ if (!thread_unblock(thread, wresult))
+ thread_setrun(thread, SCHED_PREEMPT | SCHED_TAILQ);
+
+ return (KERN_SUCCESS);
}
-
- /*
- * The next few lines are a major hack. Hopefully this will get us
- * around all of the scheduling framework hooha. We can't call
- * sp_thread_unblock yet because we could still be finishing up the
- * durn two stage block on another processor and thread_setrun
- * could be called by s_t_u and we'll really be messed up then.
- */
- /* Don't mess with this if we are still swapped out */
- if (!(thread->state & TH_SWAPPED_OUT))
- thread->sp_state = MK_SP_RUNNABLE;
-
+ return (KERN_NOT_WAITING);
}
-void
+/*
+ * Routine: thread_mark_wait_locked
+ * Purpose:
+ * Mark a thread as waiting. If, given the circumstances,
+ * it doesn't want to wait (i.e. already aborted), then
+ * indicate that in the return value.
+ * Conditions:
+ * at splsched() and thread is locked.
+ */
+__private_extern__
+wait_result_t
thread_mark_wait_locked(
- thread_t thread,
- int interruptible)
+ thread_t thread,
+ wait_interrupt_t interruptible)
{
+ boolean_t at_safe_point;
assert(thread == current_thread());
- thread->wait_result = -1; /* JMM - Needed for non-assert kernel */
- thread->state |= (interruptible && thread->interruptible) ?
- TH_WAIT : (TH_WAIT | TH_UNINT);
- thread->at_safe_point = (interruptible == THREAD_ABORTSAFE) && (thread->interruptible);
- thread->sleep_stamp = sched_tick;
-}
+ /*
+ * The thread may have certain types of interrupts/aborts masked
+ * off. Even if the wait location says these types of interrupts
+ * are OK, we have to honor mask settings (outer-scoped code may
+ * not be able to handle aborts at the moment).
+ */
+ if (interruptible > (thread->options & TH_OPT_INTMASK))
+ interruptible = thread->options & TH_OPT_INTMASK;
+
+ at_safe_point = (interruptible == THREAD_ABORTSAFE);
+
+ if ( interruptible == THREAD_UNINT ||
+ !(thread->sched_flags & TH_SFLAG_ABORT) ||
+ (!at_safe_point &&
+ (thread->sched_flags & TH_SFLAG_ABORTSAFELY))) {
+
+ DTRACE_SCHED(sleep);
+ thread->state |= (interruptible) ? TH_WAIT : (TH_WAIT | TH_UNINT);
+ thread->at_safe_point = at_safe_point;
+ return (thread->wait_result = THREAD_WAITING);
+ }
+ else
+ if (thread->sched_flags & TH_SFLAG_ABORTSAFELY)
+ thread->sched_flags &= ~TH_SFLAG_ABORTED_MASK;
+ return (thread->wait_result = THREAD_INTERRUPTED);
+}
/*
- * Routine: assert_wait_timeout
+ * Routine: thread_interrupt_level
* Purpose:
- * Assert that the thread intends to block,
- * waiting for a timeout (no user known event).
+ * Set the maximum interruptible state for the
+ * current thread. The effective value of any
+ * interruptible flag passed into assert_wait
+ * will never exceed this.
+ *
+ * Useful for code that must not be interrupted,
+ * but which calls code that doesn't know that.
+ * Returns:
+ * The old interrupt level for the thread.
*/
-unsigned int assert_wait_timeout_event;
-
-void
-assert_wait_timeout(
- mach_msg_timeout_t msecs,
- int interruptible)
+__private_extern__
+wait_interrupt_t
+thread_interrupt_level(
+ wait_interrupt_t new_level)
{
- spl_t s;
+ thread_t thread = current_thread();
+ wait_interrupt_t result = thread->options & TH_OPT_INTMASK;
- assert_wait((event_t)&assert_wait_timeout_event, interruptible);
- thread_set_timer(msecs, 1000*NSEC_PER_USEC);
+ thread->options = (thread->options & ~TH_OPT_INTMASK) | (new_level & TH_OPT_INTMASK);
+
+ return result;
}
/*
{
thread_t thread;
- extern unsigned int debug_mode;
#if DEBUG
if(debug_mode) return TRUE; /* Always succeed in debug mode */
* Assert that the current thread is about to go to
* sleep until the specified event occurs.
*/
-void
+wait_result_t
assert_wait(
event_t event,
- int interruptible)
+ wait_interrupt_t interruptible)
{
register wait_queue_t wq;
register int index;
assert(event != NO_EVENT);
- assert(assert_wait_possible());
index = wait_hash(event);
wq = &wait_queues[index];
- wait_queue_assert_wait(wq,
- event,
- interruptible);
+ return wait_queue_assert_wait(wq, event, interruptible, 0);
+}
+
+wait_result_t
+assert_wait_timeout(
+ event_t event,
+ wait_interrupt_t interruptible,
+ uint32_t interval,
+ uint32_t scale_factor)
+{
+ thread_t thread = current_thread();
+ wait_result_t wresult;
+ wait_queue_t wqueue;
+ uint64_t deadline;
+ spl_t s;
+
+ assert(event != NO_EVENT);
+ wqueue = &wait_queues[wait_hash(event)];
+
+ s = splsched();
+ wait_queue_lock(wqueue);
+ thread_lock(thread);
+
+ clock_interval_to_deadline(interval, scale_factor, &deadline);
+ wresult = wait_queue_assert_wait64_locked(wqueue, CAST_DOWN(event64_t, event),
+ interruptible, deadline, thread);
+
+ thread_unlock(thread);
+ wait_queue_unlock(wqueue);
+ splx(s);
+
+ return (wresult);
+}
+
+wait_result_t
+assert_wait_deadline(
+ event_t event,
+ wait_interrupt_t interruptible,
+ uint64_t deadline)
+{
+ thread_t thread = current_thread();
+ wait_result_t wresult;
+ wait_queue_t wqueue;
+ spl_t s;
+
+ assert(event != NO_EVENT);
+ wqueue = &wait_queues[wait_hash(event)];
+
+ s = splsched();
+ wait_queue_lock(wqueue);
+ thread_lock(thread);
+
+ wresult = wait_queue_assert_wait64_locked(wqueue, CAST_DOWN(event64_t,event),
+ interruptible, deadline, thread);
+
+ thread_unlock(thread);
+ wait_queue_unlock(wqueue);
+ splx(s);
+
+ 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 res;
+
+ res = assert_wait(event, interruptible);
+ if (res == THREAD_WAITING) {
+ simple_unlock(lock);
+ res = thread_block(THREAD_CONTINUE_NULL);
+ simple_lock(lock);
+ }
+ return res;
+}
+
+
+/*
+ * 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;
+
+ res = assert_wait(event, interruptible);
+ if (res == THREAD_WAITING) {
+ usimple_unlock(lock);
+ res = thread_block(THREAD_CONTINUE_NULL);
+ usimple_lock(lock);
+ }
+ return res;
+}
+
+/*
+ * thread_sleep_lock_write:
+ *
+ * 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.
+ */
+wait_result_t
+thread_sleep_lock_write(
+ event_t event,
+ lock_t *lock,
+ wait_interrupt_t interruptible)
+{
+ wait_result_t res;
+
+ res = assert_wait(event, interruptible);
+ if (res == THREAD_WAITING) {
+ lock_write_done(lock);
+ res = thread_block(THREAD_CONTINUE_NULL);
+ lock_write(lock);
+ }
+ return res;
}
-
/*
- * thread_[un]stop(thread)
- * Once a thread has blocked interruptibly (via assert_wait) prevent
- * it from running until thread_unstop.
+ * thread_stop:
*
- * If someone else has already stopped the thread, wait for the
- * stop to be cleared, and then stop it again.
+ * Force a preemption point for a thread and wait
+ * for it to stop running. Arbitrates access among
+ * multiple stop requests. (released by unstop)
*
- * Return FALSE if interrupted.
+ * The thread must enter a wait state and stop via a
+ * separate means.
*
- * NOTE: thread_hold/thread_suspend should be called on the activation
- * before calling thread_stop. TH_SUSP is only recognized when
- * a thread blocks and only prevents clear_wait/thread_wakeup
- * from restarting an interruptible wait. The wake_active flag is
- * used to indicate that someone is waiting on the thread.
+ * Returns FALSE if interrupted.
*/
boolean_t
thread_stop(
- thread_t thread)
+ thread_t thread)
{
- spl_t s;
+ wait_result_t wresult;
+ spl_t s = splsched();
- s = splsched();
wake_lock(thread);
+ thread_lock(thread);
while (thread->state & TH_SUSP) {
thread->wake_active = TRUE;
- assert_wait((event_t)&thread->wake_active, THREAD_ABORTSAFE);
+ thread_unlock(thread);
+
+ wresult = assert_wait(&thread->wake_active, THREAD_ABORTSAFE);
wake_unlock(thread);
splx(s);
- thread_block((void (*)(void)) 0);
- if (current_thread()->wait_result != THREAD_AWAKENED)
+ if (wresult == THREAD_WAITING)
+ wresult = thread_block(THREAD_CONTINUE_NULL);
+
+ if (wresult != THREAD_AWAKENED)
return (FALSE);
s = splsched();
wake_lock(thread);
+ thread_lock(thread);
}
- thread_lock(thread);
+
thread->state |= TH_SUSP;
- thread_unlock(thread);
+ while (thread->state & TH_RUN) {
+ processor_t processor = thread->last_processor;
+
+ if (processor != PROCESSOR_NULL && processor->active_thread == thread)
+ cause_ast_check(processor);
+
+ thread->wake_active = TRUE;
+ thread_unlock(thread);
+
+ wresult = assert_wait(&thread->wake_active, THREAD_ABORTSAFE);
+ wake_unlock(thread);
+ splx(s);
+
+ if (wresult == THREAD_WAITING)
+ wresult = thread_block(THREAD_CONTINUE_NULL);
+
+ if (wresult != THREAD_AWAKENED) {
+ thread_unstop(thread);
+ return (FALSE);
+ }
+
+ s = splsched();
+ wake_lock(thread);
+ thread_lock(thread);
+ }
+
+ thread_unlock(thread);
wake_unlock(thread);
splx(s);
}
/*
- * Clear TH_SUSP and if the thread has been stopped and is now runnable,
- * put it back on the run queue.
+ * thread_unstop:
+ *
+ * Release a previous stop request and set
+ * the thread running if appropriate.
+ *
+ * Use only after a successful stop operation.
*/
void
thread_unstop(
- thread_t thread)
+ thread_t thread)
{
- sched_policy_t *policy;
- sf_return_t sfr;
- spl_t s;
+ spl_t s = splsched();
- s = splsched();
wake_lock(thread);
thread_lock(thread);
- if ((thread->state & (TH_RUN|TH_WAIT|TH_SUSP/*|TH_UNINT*/)) == TH_SUSP) {
- thread->state = (thread->state & ~TH_SUSP) | TH_RUN;
-#if THREAD_SWAPPER
- if (thread->state & TH_SWAPPED_OUT)
- thread_swapin(thread->top_act, FALSE);
- else
-#endif /* THREAD_SWAPPER */
- {
- policy = &sched_policy[thread->policy];
- sfr = policy->sp_ops.sp_thread_unblock(policy, thread);
- assert(sfr == SF_SUCCESS);
- }
+ if ((thread->state & (TH_RUN|TH_WAIT|TH_SUSP)) == TH_SUSP) {
+ thread->state &= ~TH_SUSP;
+ thread_unblock(thread, THREAD_AWAKENED);
+
+ thread_setrun(thread, SCHED_PREEMPT | SCHED_TAILQ);
}
else
if (thread->state & TH_SUSP) {
if (thread->wake_active) {
thread->wake_active = FALSE;
thread_unlock(thread);
+
+ thread_wakeup(&thread->wake_active);
wake_unlock(thread);
splx(s);
- thread_wakeup((event_t)&thread->wake_active);
return;
}
}
/*
- * Wait for the thread's RUN bit to clear
+ * thread_wait:
+ *
+ * Wait for a thread to stop running. (non-interruptible)
+ *
*/
-boolean_t
+void
thread_wait(
thread_t thread)
{
- spl_t s;
+ wait_result_t wresult;
+ spl_t s = splsched();
- s = splsched();
wake_lock(thread);
+ thread_lock(thread);
- while (thread->state & (TH_RUN/*|TH_UNINT*/)) {
- if (thread->last_processor != PROCESSOR_NULL)
- cause_ast_check(thread->last_processor);
+ while (thread->state & TH_RUN) {
+ processor_t processor = thread->last_processor;
+
+ if (processor != PROCESSOR_NULL && processor->active_thread == thread)
+ cause_ast_check(processor);
thread->wake_active = TRUE;
- assert_wait((event_t)&thread->wake_active, THREAD_ABORTSAFE);
+ thread_unlock(thread);
+
+ wresult = assert_wait(&thread->wake_active, THREAD_UNINT);
wake_unlock(thread);
splx(s);
- thread_block((void (*)(void))0);
- if (current_thread()->wait_result != THREAD_AWAKENED)
- return (FALSE);
+ if (wresult == THREAD_WAITING)
+ thread_block(THREAD_CONTINUE_NULL);
s = splsched();
wake_lock(thread);
+ thread_lock(thread);
}
+ thread_unlock(thread);
wake_unlock(thread);
splx(s);
-
- return (TRUE);
-}
-
-
-/*
- * thread_stop_wait(thread)
- * Stop the thread then wait for it to block interruptibly
- */
-boolean_t
-thread_stop_wait(
- thread_t thread)
-{
- if (thread_stop(thread)) {
- if (thread_wait(thread))
- return (TRUE);
-
- thread_unstop(thread);
- }
-
- return (FALSE);
}
-
/*
* Routine: clear_wait_internal
*
* Conditions:
* At splsched
* the thread is locked.
+ * Returns:
+ * KERN_SUCCESS thread was rousted out a wait
+ * KERN_FAILURE thread was waiting but could not be rousted
+ * KERN_NOT_WAITING thread was not waiting
*/
-void
+__private_extern__ kern_return_t
clear_wait_internal(
- thread_t thread,
- int result)
+ thread_t thread,
+ wait_result_t wresult)
{
- /*
- * If the thread isn't in a wait queue, just set it running. Otherwise,
- * try to remove it from the queue and, if successful, then set it
- * running. NEVER interrupt an uninterruptible thread.
- */
- if (!((result == THREAD_INTERRUPTED) && (thread->state & TH_UNINT))) {
- if (wait_queue_assert_possible(thread) ||
- (wait_queue_remove(thread) == KERN_SUCCESS)) {
- thread_go_locked(thread, result);
+ wait_queue_t wq = thread->wait_queue;
+ uint32_t i = LockTimeOut;
+
+ do {
+ if (wresult == THREAD_INTERRUPTED && (thread->state & TH_UNINT))
+ return (KERN_FAILURE);
+
+ if (wq != WAIT_QUEUE_NULL) {
+ if (wait_queue_lock_try(wq)) {
+ wait_queue_pull_thread_locked(wq, thread, TRUE);
+ /* wait queue unlocked, thread still locked */
+ }
+ else {
+ thread_unlock(thread);
+ delay(1);
+
+ thread_lock(thread);
+ if (wq != thread->wait_queue)
+ return (KERN_NOT_WAITING);
+
+ continue;
+ }
}
- }
+
+ return (thread_go(thread, wresult));
+ } while ((--i > 0) || machine_timeout_suspended());
+
+ panic("clear_wait_internal: deadlock: thread=%p, wq=%p, cpu=%d\n",
+ thread, wq, cpu_number());
+
+ return (KERN_FAILURE);
}
* thread thread to awaken
* result Wakeup result the thread should see
*/
-void
+kern_return_t
clear_wait(
- thread_t thread,
- int result)
+ thread_t thread,
+ wait_result_t result)
{
+ kern_return_t ret;
spl_t s;
s = splsched();
thread_lock(thread);
- clear_wait_internal(thread, result);
+ ret = clear_wait_internal(thread, result);
thread_unlock(thread);
splx(s);
+ return ret;
}
* and thread_wakeup_one.
*
*/
-void
+kern_return_t
thread_wakeup_prim(
event_t event,
boolean_t one_thread,
- int result)
+ wait_result_t result)
+{
+ return (thread_wakeup_prim_internal(event, one_thread, result, -1));
+}
+
+
+kern_return_t
+thread_wakeup_prim_internal(
+ event_t event,
+ boolean_t one_thread,
+ wait_result_t result,
+ int priority)
{
register wait_queue_t wq;
register int index;
index = wait_hash(event);
wq = &wait_queues[index];
if (one_thread)
- wait_queue_wakeup_one(wq, event, result);
+ return (wait_queue_wakeup_one(wq, event, result, priority));
else
- wait_queue_wakeup_all(wq, event, result);
+ return (wait_queue_wakeup_all(wq, event, result));
}
/*
* thread_bind:
*
- * Force a thread to execute on the specified processor.
- * If the thread is currently executing, it may wait until its
- * time slice is up before switching onto the specified processor.
+ * Force the current thread to execute on the specified processor.
+ *
+ * Returns the previous binding. PROCESSOR_NULL means
+ * not bound.
*
- * A processor of PROCESSOR_NULL causes the thread to be unbound.
- * xxx - DO NOT export this to users.
+ * XXX - DO NOT export this to users - XXX
*/
-void
+processor_t
thread_bind(
- register thread_t thread,
- processor_t processor)
+ processor_t processor)
{
- spl_t s;
+ thread_t self = current_thread();
+ processor_t prev;
+ spl_t s;
s = splsched();
- thread_lock(thread);
- thread_bind_locked(thread, processor);
- thread_unlock(thread);
+ thread_lock(self);
+
+ prev = self->bound_processor;
+ self->bound_processor = processor;
+
+ thread_unlock(self);
splx(s);
+
+ return (prev);
}
/*
- * Select a thread for this processor (the current processor) to run.
- * May select the current thread, which must already be locked.
+ * thread_select:
+ *
+ * Select a new thread for the current processor to execute.
+ *
+ * May select the current thread, which must be locked.
*/
-thread_t
+static thread_t
thread_select(
- register processor_t myprocessor)
+ thread_t thread,
+ processor_t processor)
{
- register thread_t thread;
- processor_set_t pset;
- register run_queue_t runq = &myprocessor->runq;
- boolean_t other_runnable;
- sched_policy_t *policy;
-
- /*
- * Check for other non-idle runnable threads.
- */
- myprocessor->first_quantum = TRUE;
- pset = myprocessor->processor_set;
- thread = current_thread();
+ processor_set_t pset = processor->processor_set;
+ thread_t new_thread = THREAD_NULL;
+ boolean_t inactive_state;
-#if 0 /* CHECKME! */
- thread->unconsumed_quantum = myprocessor->quantum;
-#endif
+ assert(processor == current_processor());
- simple_lock(&runq->lock);
- simple_lock(&pset->runq.lock);
+ do {
+ /*
+ * Update the priority.
+ */
+ if (SCHED(can_update_priority)(thread))
+ SCHED(update_priority)(thread);
+
+ processor->current_pri = thread->sched_pri;
+ processor->current_thmode = thread->sched_mode;
- other_runnable = runq->count > 0 || pset->runq.count > 0;
+ pset_lock(pset);
- if ( thread->state == TH_RUN &&
- (!other_runnable ||
- (runq->highq < thread->sched_pri &&
- pset->runq.highq < thread->sched_pri)) &&
- thread->processor_set == pset &&
- (thread->bound_processor == PROCESSOR_NULL ||
- thread->bound_processor == myprocessor) ) {
+ assert(pset->low_count);
+ assert(pset->low_pri);
- /* I am the highest priority runnable (non-idle) thread */
- simple_unlock(&pset->runq.lock);
- simple_unlock(&runq->lock);
+ inactive_state = processor->state != PROCESSOR_SHUTDOWN && machine_processor_is_inactive(processor);
- /* Update the thread's meta-priority */
- policy = policy_id_to_sched_policy(thread->policy);
- assert(policy != SCHED_POLICY_NULL);
- (void)policy->sp_ops.sp_thread_update_mpri(policy, thread);
- }
- else
- if (other_runnable) {
- simple_unlock(&pset->runq.lock);
- simple_unlock(&runq->lock);
- thread = choose_thread(myprocessor);
- }
- else {
- simple_unlock(&pset->runq.lock);
- simple_unlock(&runq->lock);
+ simple_lock(&rt_lock);
/*
- * Nothing is runnable, so set this processor idle if it
- * was running. If it was in an assignment or shutdown,
- * leave it alone. Return its idle thread.
+ * Test to see if the current thread should continue
+ * to run on this processor. Must be runnable, and not
+ * bound to a different processor, nor be in the wrong
+ * processor set.
*/
- simple_lock(&pset->idle_lock);
- if (myprocessor->state == PROCESSOR_RUNNING) {
- myprocessor->state = PROCESSOR_IDLE;
- /*
- * XXX Until it goes away, put master on end of queue, others
- * XXX on front so master gets used last.
- */
- if (myprocessor == master_processor)
- queue_enter(&(pset->idle_queue), myprocessor,
- processor_t, processor_queue);
- else
- queue_enter_first(&(pset->idle_queue), myprocessor,
- processor_t, processor_queue);
+ if ( ((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 (rt_runq.count > 0) {
+ register queue_t q;
+
+ q = &rt_runq.queue;
+ if (((thread_t)q->next)->realtime.deadline <
+ processor->deadline) {
+ thread = (thread_t)dequeue_head(q);
+ thread->runq = PROCESSOR_NULL;
+ SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count);
+ rt_runq.count--;
+ }
+ }
- pset->idle_count++;
- }
- simple_unlock(&pset->idle_lock);
+ simple_unlock(&rt_lock);
- thread = myprocessor->idle_thread;
- }
+ processor->deadline = thread->realtime.deadline;
- return (thread);
-}
+ pset_unlock(pset);
+ return (thread);
+ }
-/*
- * Stop running the current thread and start running the new thread.
- * If continuation is non-zero, and the current thread is blocked,
- * then it will resume by executing continuation on a new stack.
- * Returns TRUE if the hand-off succeeds.
- * The reason parameter == AST_QUANTUM if the thread blocked
- * because its quantum expired.
- * Assumes splsched.
- */
+ 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) {
+ simple_unlock(&rt_lock);
-static thread_t
-__current_thread(void)
-{
- return (current_thread());
-}
+ /* I am the highest priority runnable (non-idle) thread */
-boolean_t
-thread_invoke(
- register thread_t old_thread,
- register thread_t new_thread,
- int reason,
- void (*continuation)(void))
-{
- sched_policy_t *policy;
- sf_return_t sfr;
- void (*lcont)(void);
+ pset_pri_hint(pset, processor, processor->current_pri);
- /*
- * Mark thread interruptible.
- */
- thread_lock(new_thread);
- new_thread->state &= ~TH_UNINT;
+ pset_count_hint(pset, processor, SCHED(processor_runq_count)(processor));
- if (cpu_data[cpu_number()].preemption_level != 1)
- panic("thread_invoke: preemption_level %d\n",
- cpu_data[cpu_number()].preemption_level);
+ processor->deadline = UINT64_MAX;
+ pset_unlock(pset);
- assert(thread_runnable(new_thread));
+ return (thread);
+ }
+ }
- assert(old_thread->continuation == (void (*)(void))0);
+ 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)) {
+ simple_unlock(&rt_lock);
- if ((old_thread->sched_mode & TH_MODE_REALTIME) && (!old_thread->stack_privilege)) {
- old_thread->stack_privilege = old_thread->kernel_stack;
- }
+ if (!inactive_state) {
+ pset_pri_hint(pset, processor, new_thread->sched_pri);
- if (continuation != (void (*)()) 0) {
- switch (new_thread->state & TH_STACK_STATE) {
- case TH_STACK_HANDOFF:
+ pset_count_hint(pset, processor, SCHED(processor_runq_count)(processor));
+ }
- /*
- * If the old thread has stack privilege, we can't give
- * his stack away. So go and get him one and treat this
- * as a traditional context switch.
- */
- if (old_thread->stack_privilege == current_stack())
- goto get_new_stack;
+ processor->deadline = UINT64_MAX;
+ pset_unlock(pset);
- /*
- * Make the whole handoff/dispatch atomic to match the
- * non-handoff case.
- */
- disable_preemption();
+ return (new_thread);
+ }
- /*
- * Set up ast context of new thread and switch to its timer.
- */
- new_thread->state &= ~(TH_STACK_HANDOFF|TH_UNINT);
- new_thread->last_processor = current_processor();
- ast_context(new_thread->top_act, cpu_number());
- timer_switch(&new_thread->system_timer);
- thread_unlock(new_thread);
+ if (rt_runq.count > 0) {
+ thread = (thread_t)dequeue_head(&rt_runq.queue);
- old_thread->continuation = continuation;
- stack_handoff(old_thread, new_thread);
+ thread->runq = PROCESSOR_NULL;
+ SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count);
+ rt_runq.count--;
- wake_lock(old_thread);
- thread_lock(old_thread);
- act_machine_sv_free(old_thread->top_act);
+ simple_unlock(&rt_lock);
- /*
- * inline thread_dispatch but don't free stack
- */
+ processor->deadline = thread->realtime.deadline;
+ pset_unlock(pset);
- switch (old_thread->state & (TH_RUN|TH_WAIT|TH_UNINT|TH_IDLE)) {
- sched_policy_t *policy;
- sf_return_t sfr;
-
- case TH_RUN | TH_UNINT:
- case TH_RUN:
- /*
- * No reason to stop. Put back on a run queue.
- */
- old_thread->state |= TH_STACK_HANDOFF;
-
- /* Get pointer to scheduling policy "object" */
- policy = &sched_policy[old_thread->policy];
-
- /* Leave enqueueing thread up to scheduling policy */
- sfr = policy->sp_ops.sp_thread_dispatch(policy, old_thread);
- assert(sfr == SF_SUCCESS);
- break;
-
- case TH_RUN | TH_WAIT | TH_UNINT:
- case TH_RUN | TH_WAIT:
- old_thread->sleep_stamp = sched_tick;
- /* fallthrough */
-
- case TH_WAIT: /* this happens! */
- /*
- * Waiting
- */
- old_thread->state |= TH_STACK_HANDOFF;
- old_thread->state &= ~TH_RUN;
- if (old_thread->state & TH_TERMINATE)
- thread_reaper_enqueue(old_thread);
-
- if (old_thread->wake_active) {
- old_thread->wake_active = FALSE;
- thread_unlock(old_thread);
- wake_unlock(old_thread);
- thread_wakeup((event_t)&old_thread->wake_active);
- wake_lock(old_thread);
- thread_lock(old_thread);
- }
- break;
-
- case TH_RUN | TH_IDLE:
- /*
- * Drop idle thread -- it is already in
- * idle_thread_array.
- */
- old_thread->state |= TH_STACK_HANDOFF;
- break;
-
- default:
- panic("State 0x%x \n",old_thread->state);
- }
-
- /* Get pointer to scheduling policy "object" */
- policy = &sched_policy[old_thread->policy];
-
- /* Indicate to sched policy that old thread has stopped execution */
- /*** ??? maybe use a macro -- rkc, 1/4/96 ***/
- sfr = policy->sp_ops.sp_thread_done(policy, old_thread);
- assert(sfr == SF_SUCCESS);
- thread_unlock(old_thread);
- wake_unlock(old_thread);
- thread_lock(new_thread);
-
- assert(thread_runnable(new_thread));
-
- /* Get pointer to scheduling policy "object" */
- policy = &sched_policy[new_thread->policy];
-
- /* Indicate to sched policy that new thread has started execution */
- /*** ??? maybe use a macro ***/
- sfr = policy->sp_ops.sp_thread_begin(policy, new_thread);
- assert(sfr == SF_SUCCESS);
-
- lcont = new_thread->continuation;
- new_thread->continuation = (void(*)(void))0;
-
- thread_unlock(new_thread);
- enable_preemption();
-
- counter_always(c_thread_invoke_hits++);
-
- if (new_thread->funnel_state & TH_FN_REFUNNEL) {
- kern_return_t save_wait_result;
- new_thread->funnel_state = 0;
- save_wait_result = new_thread->wait_result;
- KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, new_thread->funnel_lock, 2, 0, 0, 0);
- //mutex_lock(new_thread->funnel_lock);
- funnel_lock(new_thread->funnel_lock);
- KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, new_thread->funnel_lock, 2, 0, 0, 0);
- new_thread->funnel_state = TH_FN_OWNED;
- new_thread->wait_result = save_wait_result;
+ return (thread);
}
- (void) spllo();
- assert(lcont);
- call_continuation(lcont);
- /*NOTREACHED*/
- return TRUE;
+ simple_unlock(&rt_lock);
- case TH_STACK_COMING_IN:
- /*
- * waiting for a stack
+ /* No realtime threads and no normal threads on the per-processor
+ * runqueue. Finally check for global fairshare threads.
*/
- thread_swapin(new_thread);
- thread_unlock(new_thread);
- counter_always(c_thread_invoke_misses++);
- return FALSE;
-
- case 0:
- /*
- * already has a stack - can't handoff
- */
- if (new_thread == old_thread) {
-
- /* same thread but with continuation */
- counter(++c_thread_invoke_same);
- thread_unlock(new_thread);
-
- if (old_thread->funnel_state & TH_FN_REFUNNEL) {
- kern_return_t save_wait_result;
-
- old_thread->funnel_state = 0;
- save_wait_result = old_thread->wait_result;
- KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, old_thread->funnel_lock, 3, 0, 0, 0);
- funnel_lock(old_thread->funnel_lock);
- KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, old_thread->funnel_lock, 3, 0, 0, 0);
- old_thread->funnel_state = TH_FN_OWNED;
- old_thread->wait_result = save_wait_result;
- }
- (void) spllo();
- call_continuation(continuation);
- /*NOTREACHED*/
+ if ((new_thread = SCHED(fairshare_dequeue)()) != THREAD_NULL) {
+
+ processor->deadline = UINT64_MAX;
+ pset_unlock(pset);
+
+ return (new_thread);
}
- break;
- }
- } else {
- /*
- * check that the new thread has a stack
- */
- if (new_thread->state & TH_STACK_STATE) {
- get_new_stack:
- /* has no stack. if not already waiting for one try to get one */
- if ((new_thread->state & TH_STACK_COMING_IN) ||
- /* not already waiting. nonblocking try to get one */
- !stack_alloc_try(new_thread, thread_continue))
- {
- /* couldn't get one. schedule new thread to get a stack and
- return failure so we can try another thread. */
- thread_swapin(new_thread);
- thread_unlock(new_thread);
- counter_always(c_thread_invoke_misses++);
- return FALSE;
- }
- } else if (old_thread == new_thread) {
- counter(++c_thread_invoke_same);
- thread_unlock(new_thread);
- return TRUE;
- }
-
- /* new thread now has a stack. it has been setup to resume in
- thread_continue so it can dispatch the old thread, deal with
- funnelling and then go to it's true continuation point */
- }
-
- new_thread->state &= ~(TH_STACK_HANDOFF | TH_UNINT);
+
+ processor->deadline = UINT64_MAX;
- /*
- * Set up ast context of new thread and switch to its timer.
- */
- new_thread->last_processor = current_processor();
- ast_context(new_thread->top_act, cpu_number());
- timer_switch(&new_thread->system_timer);
- assert(thread_runnable(new_thread));
-
- /*
- * N.B. On return from the call to switch_context, 'old_thread'
- * points at the thread that yielded to us. Unfortunately, at
- * this point, there are no simple_locks held, so if we are preempted
- * before the call to thread_dispatch blocks preemption, it is
- * possible for 'old_thread' to terminate, leaving us with a
- * stale thread pointer.
- */
- disable_preemption();
+ /*
+ * 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.
+ */
+ new_thread = SCHED(steal_thread)(pset);
+ if (new_thread != THREAD_NULL) {
+ return (new_thread);
+ }
+
+ /*
+ * If other threads have appeared, shortcut
+ * around again.
+ */
+ if (!SCHED(processor_queue_empty)(processor) || rt_runq.count > 0 || SCHED(fairshare_runq_count)() > 0)
+ continue;
+
+ pset_lock(pset);
+
+ /*
+ * Nothing is runnable, so set this processor idle if it
+ * was running.
+ */
+ if (processor->state == PROCESSOR_RUNNING) {
+ remqueue((queue_entry_t)processor);
+ processor->state = PROCESSOR_IDLE;
+
+ if (processor->processor_meta == PROCESSOR_META_NULL || processor->processor_meta->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);
+ }
+ }
+
+ pset_unlock(pset);
+
+#if CONFIG_SCHED_IDLE_IN_PLACE
+ /*
+ * Choose idle thread if fast idle is not possible.
+ */
+ 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);
+
+ /*
+ * Perform idling activities directly without a
+ * context switch. Return dispatched thread,
+ * else check again for a runnable thread.
+ */
+ new_thread = thread_select_idle(thread, processor);
+
+#else /* !CONFIG_SCHED_IDLE_IN_PLACE */
+
+ /*
+ * Do a full context switch to idle so that the current
+ * thread can start running on another processor without
+ * waiting for the fast-idled processor to wake up.
+ */
+ return (processor->idle_thread);
+
+#endif /* !CONFIG_SCHED_IDLE_IN_PLACE */
+
+ } while (new_thread == THREAD_NULL);
+
+ return (new_thread);
+}
+
+#if CONFIG_SCHED_IDLE_IN_PLACE
+/*
+ * thread_select_idle:
+ *
+ * Idle the processor using the current thread context.
+ *
+ * Called with thread locked, then dropped and relocked.
+ */
+static thread_t
+thread_select_idle(
+ thread_t thread,
+ processor_t processor)
+{
+ thread_t new_thread;
+
+ if (thread->sched_mode == TH_MODE_TIMESHARE)
+ sched_share_decr();
+ sched_run_decr();
+
+ thread->state |= TH_IDLE;
+ processor->current_pri = IDLEPRI;
+ processor->current_thmode = TH_MODE_NONE;
+
+ thread_unlock(thread);
+
+ /*
+ * Switch execution timing to processor idle thread.
+ */
+ processor->last_dispatch = mach_absolute_time();
+ 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;
+
+ /*
+ * Cancel the quantum timer while idling.
+ */
+ timer_call_cancel(&processor->quantum_timer);
+ processor->timeslice = 0;
+
+ (*thread->sched_call)(SCHED_CALL_BLOCK, thread);
+
+ thread_tell_urgency(THREAD_URGENCY_NONE, 0, 0);
+
+ /*
+ * Enable interrupts and perform idling activities. No
+ * preemption due to TH_IDLE being set.
+ */
+ spllo(); new_thread = processor_idle(thread, processor);
+
+ /*
+ * Return at splsched.
+ */
+ (*thread->sched_call)(SCHED_CALL_UNBLOCK, thread);
+
+ 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.
+ */
+ if (!(thread->state & TH_WAIT)) {
+ processor->last_dispatch = mach_absolute_time();
+ thread_timer_event(processor->last_dispatch, &thread->system_timer);
+ 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->timeslice = 1;
+
+ thread->computation_epoch = processor->last_dispatch;
+ }
+
+ thread->state &= ~TH_IDLE;
+
+ sched_run_incr();
+ if (thread->sched_mode == TH_MODE_TIMESHARE)
+ sched_share_incr();
+
+ return (new_thread);
+}
+#endif /* CONFIG_SCHED_IDLE_IN_PLACE */
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+static thread_t
+sched_traditional_choose_thread(
+ processor_t processor,
+ int priority)
+{
+ thread_t thread;
+
+ thread = choose_thread(processor, runq_for_processor(processor), priority);
+ if (thread != THREAD_NULL) {
+ runq_consider_decr_bound_count(processor, thread);
+ }
+
+ return thread;
+}
+
+#endif /* defined(CONFIG_SCHED_TRADITIONAL) */
+
+#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_FIXEDPRIORITY)
+
+/*
+ * choose_thread:
+ *
+ * Locate a thread to execute from the processor run queue
+ * and return it. Only choose a thread with greater or equal
+ * priority.
+ *
+ * Associated pset must be locked. Returns THREAD_NULL
+ * on failure.
+ */
+thread_t
+choose_thread(
+ processor_t processor,
+ run_queue_t rq,
+ int priority)
+{
+ queue_t queue = rq->queues + rq->highq;
+ int pri = rq->highq, count = rq->count;
+ thread_t thread;
+
+ while (count > 0 && pri >= priority) {
+ thread = (thread_t)queue_first(queue);
+ while (!queue_end(queue, (queue_entry_t)thread)) {
+ if (thread->bound_processor == PROCESSOR_NULL ||
+ thread->bound_processor == processor) {
+ remqueue((queue_entry_t)thread);
+
+ thread->runq = PROCESSOR_NULL;
+ SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count);
+ rq->count--;
+ if (SCHED(priority_is_urgent)(pri)) {
+ rq->urgency--; assert(rq->urgency >= 0);
+ }
+ if (queue_empty(queue)) {
+ if (pri != IDLEPRI)
+ clrbit(MAXPRI - pri, rq->bitmap);
+ rq->highq = MAXPRI - ffsbit(rq->bitmap);
+ }
+
+ return (thread);
+ }
+ count--;
+
+ thread = (thread_t)queue_next((queue_entry_t)thread);
+ }
+
+ queue--; pri--;
+ }
+
+ return (THREAD_NULL);
+}
+
+#endif /* defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_FIXEDPRIORITY) */
+
+/*
+ * Perform a context switch and start executing the new thread.
+ *
+ * Returns FALSE on failure, and the thread is re-dispatched.
+ *
+ * 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
+
+static boolean_t
+thread_invoke(
+ register thread_t self,
+ register thread_t thread,
+ ast_t reason)
+{
+ thread_continue_t continuation = self->continuation;
+ void *parameter = self->parameter;
+ processor_t processor;
+
+ if (get_preemption_level() != 0) {
+ int pl = get_preemption_level();
+ panic("thread_invoke: preemption_level %d, possible cause: %s",
+ pl, (pl < 0 ? "unlocking an unlocked mutex or spinlock" :
+ "blocking while holding a spinlock, or within interrupt context"));
+ }
+
+ assert(self == current_thread());
+
+ /*
+ * Mark thread interruptible.
+ */
+ thread_lock(thread);
+ thread->state &= ~TH_UNINT;
+
+#if DEBUG
+ assert(thread_runnable(thread));
+#endif
+
+ /*
+ * Allow time constraint threads to hang onto
+ * a stack.
+ */
+ if ((self->sched_mode == TH_MODE_REALTIME) && !self->reserved_stack)
+ self->reserved_stack = self->kernel_stack;
+
+ if (continuation != NULL) {
+ if (!thread->kernel_stack) {
+ /*
+ * If we are using a privileged stack,
+ * check to see whether we can exchange it with
+ * that of the other thread.
+ */
+ if (self->kernel_stack == self->reserved_stack && !thread->reserved_stack)
+ goto need_stack;
+
+ /*
+ * Context switch by performing a stack handoff.
+ */
+ continuation = thread->continuation;
+ parameter = thread->parameter;
+
+ processor = current_processor();
+ processor->active_thread = thread;
+ processor->current_pri = thread->sched_pri;
+ processor->current_thmode = thread->sched_mode;
+ if (thread->last_processor != processor && thread->last_processor != NULL) {
+ if (thread->last_processor->processor_set != processor->processor_set)
+ thread->ps_switch++;
+ thread->p_switch++;
+ }
+ thread->last_processor = processor;
+ thread->c_switch++;
+ ast_context(thread);
+ thread_unlock(thread);
+
+ self->reason = reason;
+
+ processor->last_dispatch = mach_absolute_time();
+ self->last_run_time = processor->last_dispatch;
+ thread_timer_event(processor->last_dispatch, &thread->system_timer);
+ PROCESSOR_DATA(processor, kernel_timer) = &thread->system_timer;
+
+ 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);
+
+ if ((thread->chosen_processor != processor) && (thread->chosen_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);
+ }
+
+ DTRACE_SCHED2(off__cpu, struct thread *, thread, struct proc *, thread->task->bsd_info);
+
+ SCHED_STATS_CSW(processor, self->reason, self->sched_pri, thread->sched_pri);
+
+ TLOG(1, "thread_invoke: calling stack_handoff\n");
+ stack_handoff(self, thread);
+
+ DTRACE_SCHED(on__cpu);
+
+ thread_dispatch(self, thread);
+
+ thread->continuation = thread->parameter = NULL;
+
+ counter(c_thread_invoke_hits++);
+
+ funnel_refunnel_check(thread, 2);
+ (void) spllo();
+
+ assert(continuation);
+ call_continuation(continuation, parameter, thread->wait_result);
+ /*NOTREACHED*/
+ }
+ else if (thread == self) {
+ /* same thread but with continuation */
+ ast_context(self);
+ 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);
+
+ self->continuation = self->parameter = NULL;
+
+ funnel_refunnel_check(self, 3);
+ (void) spllo();
+
+ call_continuation(continuation, parameter, self->wait_result);
+ /*NOTREACHED*/
+ }
+ }
+ else {
+ /*
+ * Check that the other thread has a stack
+ */
+ if (!thread->kernel_stack) {
+need_stack:
+ if (!stack_alloc_try(thread)) {
+ counter(c_thread_invoke_misses++);
+ thread_unlock(thread);
+ thread_stack_enqueue(thread);
+ return (FALSE);
+ }
+ }
+ else if (thread == self) {
+ ast_context(self);
+ 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);
+
+ return (TRUE);
+ }
+ }
+
+ /*
+ * Context switch by full context save.
+ */
+ processor = current_processor();
+ processor->active_thread = thread;
+ processor->current_pri = thread->sched_pri;
+ processor->current_thmode = thread->sched_mode;
+ if (thread->last_processor != processor && thread->last_processor != NULL) {
+ if (thread->last_processor->processor_set != processor->processor_set)
+ thread->ps_switch++;
+ thread->p_switch++;
+ }
+ thread->last_processor = processor;
+ thread->c_switch++;
+ ast_context(thread);
+ thread_unlock(thread);
+
+ counter(c_thread_invoke_csw++);
+
+ 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_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);
+
+ if ((thread->chosen_processor != processor) && (thread->chosen_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);
+ }
+
+ DTRACE_SCHED2(off__cpu, struct thread *, thread, struct proc *, thread->task->bsd_info);
+
+ SCHED_STATS_CSW(processor, self->reason, self->sched_pri, thread->sched_pri);
+
+ /*
+ * This is where we actually switch register context,
+ * and address space if required. We will next run
+ * as a result of a subsequent context switch.
+ */
+ thread = machine_switch_context(self, continuation, thread);
+ TLOG(1,"thread_invoke: returning machine_switch_context: self %p continuation %p thread %p\n", self, continuation, thread);
+
+ DTRACE_SCHED(on__cpu);
+
+ /*
+ * We have been resumed and are set to run.
+ */
+ thread_dispatch(thread, self);
+
+ if (continuation) {
+ self->continuation = self->parameter = NULL;
+
+ funnel_refunnel_check(self, 3);
+ (void) spllo();
+
+ call_continuation(continuation, parameter, self->wait_result);
+ /*NOTREACHED*/
+ }
+
+ return (TRUE);
+}
+
+/*
+ * thread_dispatch:
+ *
+ * Handle threads at context switch. Re-dispatch other thread
+ * if still running, otherwise update run state and perform
+ * special actions. Update quantum for other thread and begin
+ * the quantum for ourselves.
+ *
+ * Called at splsched.
+ */
+void
+thread_dispatch(
+ thread_t thread,
+ thread_t self)
+{
+ processor_t processor = self->last_processor;
+
+ if (thread != THREAD_NULL) {
+ /*
+ * If blocked at a continuation, discard
+ * the stack.
+ */
+ if (thread->continuation != NULL && thread->kernel_stack != 0)
+ stack_free(thread);
+
+ if (!(thread->state & TH_IDLE)) {
+ 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);
+ else
+ thread->current_quantum = 0;
+
+ if (thread->sched_mode == TH_MODE_REALTIME) {
+ /*
+ * Cancel the deadline if the thread has
+ * consumed the entire quantum.
+ */
+ if (thread->current_quantum == 0) {
+ thread->realtime.deadline = UINT64_MAX;
+ thread->reason |= AST_QUANTUM;
+ }
+ } else {
+#if defined(CONFIG_SCHED_TRADITIONAL)
+ /*
+ * For non-realtime threads treat a tiny
+ * remaining quantum as an expired quantum
+ * but include what's left next time.
+ */
+ if (thread->current_quantum < min_std_quantum) {
+ thread->reason |= AST_QUANTUM;
+ thread->current_quantum += std_quantum;
+ }
+#endif
+ }
+
+ /*
+ * If we are doing a direct handoff then
+ * take the remainder of the quantum.
+ */
+ if ((thread->reason & (AST_HANDOFF|AST_QUANTUM)) == AST_HANDOFF) {
+ self->current_quantum = thread->current_quantum;
+ thread->reason |= AST_QUANTUM;
+ thread->current_quantum = 0;
+ }
+
+ thread->computation_metered += (processor->last_dispatch - thread->computation_epoch);
+
+ if (!(thread->state & TH_WAIT)) {
+ /*
+ * Still running.
+ */
+ if (thread->reason & AST_QUANTUM)
+ thread_setrun(thread, SCHED_TAILQ);
+ else
+ if (thread->reason & AST_PREEMPT)
+ thread_setrun(thread, SCHED_HEADQ);
+ else
+ thread_setrun(thread, SCHED_PREEMPT | SCHED_TAILQ);
+
+ thread->reason = AST_NONE;
+
+ thread_unlock(thread);
+ wake_unlock(thread);
+ }
+ else {
+ /*
+ * Waiting.
+ */
+ boolean_t should_terminate = FALSE;
+
+ /* Only the first call to thread_dispatch
+ * after explicit termination should add
+ * the thread to the termination queue
+ */
+ if ((thread->state & (TH_TERMINATE|TH_TERMINATE2)) == TH_TERMINATE) {
+ should_terminate = TRUE;
+ thread->state |= TH_TERMINATE2;
+ }
+
+ thread->state &= ~TH_RUN;
+
+ if (thread->sched_mode == TH_MODE_TIMESHARE)
+ sched_share_decr();
+ sched_run_decr();
+
+ (*thread->sched_call)(SCHED_CALL_BLOCK, thread);
+
+ if (thread->wake_active) {
+ thread->wake_active = FALSE;
+ thread_unlock(thread);
+
+ thread_wakeup(&thread->wake_active);
+ }
+ else
+ thread_unlock(thread);
+
+ wake_unlock(thread);
+
+ if (should_terminate)
+ thread_terminate_enqueue(thread);
+ }
+ }
+ }
+
+ if (!(self->state & TH_IDLE)) {
+
+ 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);
+ /*
+ * Get a new quantum if none remaining.
+ */
+ if (self->current_quantum == 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->timeslice = 1;
+
+ self->computation_epoch = processor->last_dispatch;
+ }
+ else {
+ timer_call_cancel(&processor->quantum_timer);
+ processor->timeslice = 0;
+
+ thread_tell_urgency(THREAD_URGENCY_NONE, 0, 0);
+ }
+}
+
+#include <libkern/OSDebug.h>
+
+uint32_t kdebug_thread_block = 0;
+
+
+/*
+ * thread_block_reason:
+ *
+ * Forces a reschedule, blocking the caller if a wait
+ * has been asserted.
+ *
+ * If a continuation is specified, then thread_invoke will
+ * attempt to discard the thread's kernel stack. When the
+ * thread resumes, it will execute the continuation function
+ * on a new kernel stack.
+ */
+counter(mach_counter_t c_thread_block_calls = 0;)
+
+wait_result_t
+thread_block_reason(
+ thread_continue_t continuation,
+ void *parameter,
+ ast_t reason)
+{
+ register thread_t self = current_thread();
+ register processor_t processor;
+ register thread_t new_thread;
+ spl_t s;
+
+ counter(++c_thread_block_calls);
+
+ s = splsched();
+
+ if (!(reason & AST_PREEMPT))
+ funnel_release_check(self, 2);
+
+ processor = current_processor();
+
+ /* If we're explicitly yielding, force a subsequent quantum */
+ if (reason & AST_YIELD)
+ processor->timeslice = 0;
+
+ /* We're handling all scheduling AST's */
+ ast_off(AST_SCHEDULING);
+
+ 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);
+ }
+
+ do {
+ thread_lock(self);
+ new_thread = thread_select(self, processor);
+ thread_unlock(self);
+ } while (!thread_invoke(self, new_thread, reason));
+
+ funnel_refunnel_check(self, 5);
+ splx(s);
+
+ return (self->wait_result);
+}
+
+/*
+ * thread_block:
+ *
+ * Block the current thread if a wait has been asserted.
+ */
+wait_result_t
+thread_block(
+ thread_continue_t continuation)
+{
+ return thread_block_reason(continuation, NULL, AST_NONE);
+}
+
+wait_result_t
+thread_block_parameter(
+ thread_continue_t continuation,
+ void *parameter)
+{
+ return thread_block_reason(continuation, parameter, AST_NONE);
+}
+
+/*
+ * thread_run:
+ *
+ * Switch directly from the current thread to the
+ * new thread, handing off our quantum if appropriate.
+ *
+ * New thread must be runnable, and not on a run queue.
+ *
+ * Called at splsched.
+ */
+int
+thread_run(
+ thread_t self,
+ thread_continue_t continuation,
+ void *parameter,
+ thread_t new_thread)
+{
+ ast_t handoff = AST_HANDOFF;
+
+ funnel_release_check(self, 3);
+
+ self->continuation = continuation;
+ self->parameter = parameter;
+
+ while (!thread_invoke(self, new_thread, handoff)) {
+ processor_t processor = current_processor();
+
+ thread_lock(self);
+ new_thread = thread_select(self, processor);
+ thread_unlock(self);
+ handoff = AST_NONE;
+ }
+
+ funnel_refunnel_check(self, 6);
+
+ return (self->wait_result);
+}
+
+/*
+ * thread_continue:
+ *
+ * Called at splsched when a thread first receives
+ * a new stack after a continuation.
+ */
+void
+thread_continue(
+ register thread_t thread)
+{
+ register thread_t self = current_thread();
+ register thread_continue_t continuation;
+ register void *parameter;
+
+ DTRACE_SCHED(on__cpu);
+
+ continuation = self->continuation;
+ parameter = self->parameter;
+
+ thread_dispatch(thread, self);
+
+ self->continuation = self->parameter = NULL;
+
+ funnel_refunnel_check(self, 4);
+
+ if (thread != THREAD_NULL)
+ (void)spllo();
+
+ TLOG(1, "thread_continue: calling call_continuation \n");
+ call_continuation(continuation, parameter, self->wait_result);
+ /*NOTREACHED*/
+}
+
+void
+thread_quantum_init(thread_t thread)
+{
+ if (thread->sched_mode == TH_MODE_REALTIME) {
+ thread->current_quantum = thread->realtime.computation;
+ } else {
+ thread->current_quantum = SCHED(initial_quantum_size)(thread);
+ }
+}
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+static uint32_t
+sched_traditional_initial_quantum_size(thread_t thread __unused)
+{
+ return std_quantum;
+}
+
+static sched_mode_t
+sched_traditional_initial_thread_sched_mode(task_t parent_task)
+{
+ if (parent_task == kernel_task)
+ return TH_MODE_FIXED;
+ else
+ return TH_MODE_TIMESHARE;
+}
+
+static boolean_t
+sched_traditional_supports_timeshare_mode(void)
+{
+ return TRUE;
+}
+
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+/*
+ * run_queue_init:
+ *
+ * Initialize a run queue before first use.
+ */
+void
+run_queue_init(
+ run_queue_t rq)
+{
+ int i;
+
+ rq->highq = IDLEPRI;
+ for (i = 0; i < NRQBM; i++)
+ rq->bitmap[i] = 0;
+ setbit(MAXPRI - IDLEPRI, rq->bitmap);
+ rq->urgency = rq->count = 0;
+ for (i = 0; i < NRQS; i++)
+ queue_init(&rq->queues[i]);
+}
+
+#if defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY)
+int
+sched_traditional_fairshare_runq_count(void)
+{
+ return fs_runq.count;
+}
+
+uint64_t
+sched_traditional_fairshare_runq_stats_count_sum(void)
+{
+ return fs_runq.runq_stats.count_sum;
+}
+
+void
+sched_traditional_fairshare_enqueue(thread_t thread)
+{
+ queue_t queue = &fs_runq.queue;
+
+ simple_lock(&fs_lock);
+
+ enqueue_tail(queue, (queue_entry_t)thread);
+
+ thread->runq = FS_RUNQ;
+ SCHED_STATS_RUNQ_CHANGE(&fs_runq.runq_stats, fs_runq.count);
+ fs_runq.count++;
+
+ simple_unlock(&fs_lock);
+}
+
+thread_t
+sched_traditional_fairshare_dequeue(void)
+{
+ thread_t thread;
+
+ simple_lock(&fs_lock);
+ if (fs_runq.count > 0) {
+ thread = (thread_t)dequeue_head(&fs_runq.queue);
+
+ thread->runq = PROCESSOR_NULL;
+ SCHED_STATS_RUNQ_CHANGE(&fs_runq.runq_stats, fs_runq.count);
+ fs_runq.count--;
+
+ simple_unlock(&fs_lock);
+
+ return (thread);
+ }
+ simple_unlock(&fs_lock);
+
+ return THREAD_NULL;
+}
+
+boolean_t
+sched_traditional_fairshare_queue_remove(thread_t thread)
+{
+ queue_t q;
+
+ simple_lock(&fs_lock);
+ q = &fs_runq.queue;
+
+ if (FS_RUNQ == thread->runq) {
+ remqueue((queue_entry_t)thread);
+ SCHED_STATS_RUNQ_CHANGE(&fs_runq.runq_stats, fs_runq.count);
+ fs_runq.count--;
+
+ thread->runq = PROCESSOR_NULL;
+ simple_unlock(&fs_lock);
+ return (TRUE);
+ }
+ else {
+ /*
+ * The thread left the run queue before we could
+ * lock the run queue.
+ */
+ assert(thread->runq == PROCESSOR_NULL);
+ simple_unlock(&fs_lock);
+ return (FALSE);
+ }
+}
+
+#endif /* defined(CONFIG_SCHED_TRADITIONAL) || defined(CONFIG_SCHED_PROTO) || defined(CONFIG_SCHED_GRRR) || defined(CONFIG_SCHED_FIXEDPRIORITY) */
+
+/*
+ * run_queue_dequeue:
+ *
+ * Perform a dequeue operation on a run queue,
+ * and return the resulting thread.
+ *
+ * The run queue must be locked (see thread_run_queue_remove()
+ * for more info), and not empty.
+ */
+thread_t
+run_queue_dequeue(
+ run_queue_t rq,
+ integer_t options)
+{
+ thread_t thread;
+ queue_t queue = rq->queues + rq->highq;
+
+ if (options & SCHED_HEADQ) {
+ thread = (thread_t)dequeue_head(queue);
+ }
+ else {
+ thread = (thread_t)dequeue_tail(queue);
+ }
+
+ thread->runq = PROCESSOR_NULL;
+ SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count);
+ rq->count--;
+ if (SCHED(priority_is_urgent)(rq->highq)) {
+ rq->urgency--; assert(rq->urgency >= 0);
+ }
+ if (queue_empty(queue)) {
+ if (rq->highq != IDLEPRI)
+ clrbit(MAXPRI - rq->highq, rq->bitmap);
+ rq->highq = MAXPRI - ffsbit(rq->bitmap);
+ }
+
+ return (thread);
+}
+
+/*
+ * run_queue_enqueue:
+ *
+ * Perform a enqueue operation on a run queue.
+ *
+ * The run queue must be locked (see thread_run_queue_remove()
+ * for more info).
+ */
+boolean_t
+run_queue_enqueue(
+ run_queue_t rq,
+ thread_t thread,
+ integer_t options)
+{
+ queue_t queue = rq->queues + thread->sched_pri;
+ boolean_t result = FALSE;
+
+ if (queue_empty(queue)) {
+ enqueue_tail(queue, (queue_entry_t)thread);
+
+ setbit(MAXPRI - thread->sched_pri, rq->bitmap);
+ if (thread->sched_pri > rq->highq) {
+ rq->highq = thread->sched_pri;
+ result = TRUE;
+ }
+ }
+ 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);
+ rq->count++;
+
+ return (result);
+
+}
+
+/*
+ * run_queue_remove:
+ *
+ * Remove a specific thread from a runqueue.
+ *
+ * The run queue must be locked.
+ */
+void
+run_queue_remove(
+ run_queue_t rq,
+ thread_t thread)
+{
- thread_unlock(new_thread);
+ remqueue((queue_entry_t)thread);
+ SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count);
+ rq->count--;
+ if (SCHED(priority_is_urgent)(thread->sched_pri)) {
+ rq->urgency--; assert(rq->urgency >= 0);
+ }
+
+ if (queue_empty(rq->queues + thread->sched_pri)) {
+ /* update run queue status */
+ if (thread->sched_pri != IDLEPRI)
+ clrbit(MAXPRI - thread->sched_pri, rq->bitmap);
+ rq->highq = MAXPRI - ffsbit(rq->bitmap);
+ }
+
+ thread->runq = PROCESSOR_NULL;
+}
- counter_always(c_thread_invoke_csw++);
- current_task()->csw++;
+/*
+ * fairshare_setrun:
+ *
+ * Dispatch a thread for round-robin execution.
+ *
+ * Thread must be locked. Associated pset must
+ * be locked, and is returned unlocked.
+ */
+static void
+fairshare_setrun(
+ processor_t processor,
+ thread_t thread)
+{
+ processor_set_t pset = processor->processor_set;
+
+ thread->chosen_processor = processor;
+ SCHED(fairshare_enqueue)(thread);
- thread_lock(old_thread);
- old_thread->reason = reason;
- assert(old_thread->runq == RUN_QUEUE_NULL);
+ if (processor != current_processor())
+ machine_signal_idle(processor);
+
+ pset_unlock(pset);
+
+}
+
+/*
+ * realtime_queue_insert:
+ *
+ * Enqueue a thread for realtime execution.
+ */
+static boolean_t
+realtime_queue_insert(
+ thread_t thread)
+{
+ queue_t queue = &rt_runq.queue;
+ uint64_t deadline = thread->realtime.deadline;
+ boolean_t preempt = FALSE;
+
+ simple_lock(&rt_lock);
+
+ if (queue_empty(queue)) {
+ enqueue_tail(queue, (queue_entry_t)thread);
+ preempt = TRUE;
+ }
+ else {
+ register thread_t entry = (thread_t)queue_first(queue);
+
+ while (TRUE) {
+ if ( queue_end(queue, (queue_entry_t)entry) ||
+ deadline < entry->realtime.deadline ) {
+ entry = (thread_t)queue_prev((queue_entry_t)entry);
+ break;
+ }
+
+ entry = (thread_t)queue_next((queue_entry_t)entry);
+ }
+
+ if ((queue_entry_t)entry == queue)
+ preempt = TRUE;
+
+ insque((queue_entry_t)thread, (queue_entry_t)entry);
+ }
- if (continuation != (void (*)(void))0)
- old_thread->continuation = continuation;
+ thread->runq = RT_RUNQ;
+ SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count);
+ rt_runq.count++;
- /* Indicate to sched policy that old thread has stopped execution */
- policy = &sched_policy[old_thread->policy];
- /*** ??? maybe use a macro -- ***/
- sfr = policy->sp_ops.sp_thread_done(policy, old_thread);
- assert(sfr == SF_SUCCESS);
- thread_unlock(old_thread);
+ simple_unlock(&rt_lock);
+
+ return (preempt);
+}
+
+/*
+ * realtime_setrun:
+ *
+ * Dispatch a thread for realtime execution.
+ *
+ * Thread must be locked. Associated pset must
+ * be locked, and is returned unlocked.
+ */
+static void
+realtime_setrun(
+ processor_t processor,
+ thread_t thread)
+{
+ processor_set_t pset = processor->processor_set;
+
+ thread->chosen_processor = processor;
/*
- * switch_context is machine-dependent. It does the
- * machine-dependent components of a context-switch, like
- * changing address spaces. It updates active_threads.
+ * Dispatch directly onto idle processor.
*/
- old_thread = switch_context(old_thread, continuation, new_thread);
+ if ( (thread->bound_processor == processor)
+ && processor->state == PROCESSOR_IDLE) {
+ remqueue((queue_entry_t)processor);
+ enqueue_tail(&pset->active_queue, (queue_entry_t)processor);
+
+ processor->next_thread = thread;
+ processor->deadline = thread->realtime.deadline;
+ processor->state = PROCESSOR_DISPATCHING;
+ pset_unlock(pset);
+
+ if (processor != current_processor())
+ 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);
+ }
+
+ pset_unlock(pset);
+}
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+static boolean_t
+priority_is_urgent(int priority)
+{
+ return testbit(priority, sched_preempt_pri) ? TRUE : FALSE;
+}
+
+/*
+ * processor_enqueue:
+ *
+ * Enqueue thread on a processor run queue. Thread must be locked,
+ * and not already be on a run queue.
+ *
+ * Returns TRUE if a preemption is indicated based on the state
+ * of the run queue.
+ *
+ * The run queue must be locked (see thread_run_queue_remove()
+ * for more info).
+ */
+static boolean_t
+processor_enqueue(
+ processor_t processor,
+ thread_t thread,
+ integer_t options)
+{
+ run_queue_t rq = runq_for_processor(processor);
+ boolean_t result;
- /* Now on new thread's stack. Set a local variable to refer to it. */
- new_thread = __current_thread();
- assert(old_thread != new_thread);
+ result = run_queue_enqueue(rq, thread, options);
+ thread->runq = processor;
+ runq_consider_incr_bound_count(processor, thread);
+
+ return (result);
+}
- assert(thread_runnable(new_thread));
+#endif /* CONFIG_SCHED_TRADITIONAL */
- thread_lock(new_thread);
- assert(thread_runnable(new_thread));
- /* Indicate to sched policy that new thread has started execution */
- policy = &sched_policy[new_thread->policy];
- /*** ??? maybe use a macro -- rkc, 1/4/96 ***/
- sfr = policy->sp_ops.sp_thread_begin(policy, new_thread);
- assert(sfr == SF_SUCCESS);
- thread_unlock(new_thread);
+/*
+ * processor_setrun:
+ *
+ * Dispatch a thread for execution on a
+ * processor.
+ *
+ * Thread must be locked. Associated pset must
+ * be locked, and is returned unlocked.
+ */
+static void
+processor_setrun(
+ processor_t processor,
+ thread_t thread,
+ integer_t options)
+{
+ processor_set_t pset = processor->processor_set;
+ ast_t preempt;
+
+ thread->chosen_processor = processor;
/*
- * We're back. Now old_thread is the thread that resumed
- * us, and we have to dispatch it.
+ * Dispatch directly onto idle processor.
*/
- /* CHECKME! */
-// Code from OSF in Grenoble deleted the following fields. They were
-// used in HPPA and 386 code, but not in the PPC for other than
-// just setting and resetting. They didn't delete these lines from
-// the MACH_RT builds, though, causing compile errors. I'm going
-// to make a wild guess and assume we can just delete these.
-#if 0
- if (old_thread->preempt == TH_NOT_PREEMPTABLE) {
- /*
- * Mark that we have been really preempted
- */
- old_thread->preempt = TH_PREEMPTED;
+ if ( (SCHED(direct_dispatch_to_idle_processors) ||
+ thread->bound_processor == processor)
+ && processor->state == PROCESSOR_IDLE) {
+ remqueue((queue_entry_t)processor);
+ enqueue_tail(&pset->active_queue, (queue_entry_t)processor);
+
+ processor->next_thread = thread;
+ processor->deadline = UINT64_MAX;
+ processor->state = PROCESSOR_DISPATCHING;
+ pset_unlock(pset);
+
+ if (processor != current_processor())
+ machine_signal_idle(processor);
+ return;
}
-#endif
- thread_dispatch(old_thread);
- enable_preemption();
- /* if we get here and 'continuation' is set that means the
- * switch_context() path returned and did not call out
- * to the continuation. we will do it manually here */
- if (continuation) {
- call_continuation(continuation);
- /* NOTREACHED */
+ /*
+ * Set preemption mode.
+ */
+ if (SCHED(priority_is_urgent)(thread->sched_pri) && thread->sched_pri > processor->current_pri)
+ 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
+ preempt = (options & SCHED_PREEMPT)? AST_PREEMPT: AST_NONE;
+
+ if (!SCHED(processor_enqueue)(processor, thread, options))
+ preempt = AST_NONE;
+
+ 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 ||
+ processor->current_thmode == TH_MODE_FAIRSHARE)) {
+ cause_ast_check(processor);
+ }
+ }
+ else
+ if ( processor->state == PROCESSOR_SHUTDOWN &&
+ thread->sched_pri >= processor->current_pri ) {
+ cause_ast_check(processor);
+ }
+ else
+ if ( processor->state == PROCESSOR_IDLE &&
+ processor != current_processor() ) {
+ machine_signal_idle(processor);
}
- return TRUE;
+ pset_unlock(pset);
+}
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+static boolean_t
+processor_queue_empty(processor_t processor)
+{
+ return runq_for_processor(processor)->count == 0;
+
+}
+
+static boolean_t
+sched_traditional_with_pset_runqueue_processor_queue_empty(processor_t processor)
+{
+ processor_set_t pset = processor->processor_set;
+ int count = runq_for_processor(processor)->count;
+
+ /*
+ * The pset runq contains the count of all runnable threads
+ * for all processors in the pset. However, for threads that
+ * are bound to another processor, the current "processor"
+ * is not eligible to execute the thread. So we only
+ * include bound threads that our bound to the current
+ * "processor". This allows the processor to idle when the
+ * count of eligible threads drops to 0, even if there's
+ * a runnable thread bound to a different processor in the
+ * shared runq.
+ */
+
+ count -= pset->pset_runq_bound_count;
+ count += processor->runq_bound_count;
+
+ return count == 0;
+}
+
+static ast_t
+processor_csw_check(processor_t processor)
+{
+ run_queue_t runq;
+
+ assert(processor->active_thread != NULL);
+
+ runq = runq_for_processor(processor);
+ if (runq->highq > processor->current_pri) {
+ if (runq->urgency > 0)
+ return (AST_PREEMPT | AST_URGENT);
+
+ if (processor->active_thread && thread_eager_preemption(processor->active_thread))
+ return (AST_PREEMPT | AST_URGENT);
+
+ return AST_PREEMPT;
+ }
+
+ return AST_NONE;
+}
+
+static boolean_t
+processor_queue_has_priority(processor_t processor,
+ int priority,
+ boolean_t gte)
+{
+ if (gte)
+ return runq_for_processor(processor)->highq >= priority;
+ else
+ return runq_for_processor(processor)->highq > priority;
+}
+
+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);
+}
+
+static int
+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)
+{
+ return runq_for_processor(processor)->runq_stats.count_sum;
+}
+
+static uint64_t
+sched_traditional_with_pset_runqueue_processor_runq_stats_count_sum(processor_t processor)
+{
+ if (processor->cpu_id == processor->processor_set->cpu_set_low)
+ return runq_for_processor(processor)->runq_stats.count_sum;
+ else
+ return 0ULL;
}
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+#define next_pset(p) (((p)->pset_list != PROCESSOR_SET_NULL)? (p)->pset_list: (p)->node->psets)
+
/*
- * thread_continue:
+ * choose_next_pset:
*
- * Called when the launching a new thread, at splsched();
+ * Return the next sibling pset containing
+ * available processors.
+ *
+ * Returns the original pset if none other is
+ * suitable.
*/
-void
-thread_continue(
- register thread_t old_thread)
+static processor_set_t
+choose_next_pset(
+ processor_set_t pset)
{
- register thread_t self;
- register void (*continuation)();
- sched_policy_t *policy;
- sf_return_t sfr;
+ processor_set_t nset = pset;
+
+ do {
+ nset = next_pset(nset);
+ } while (nset->online_processor_count < 1 && nset != pset);
+
+ return (nset);
+}
- self = current_thread();
+/*
+ * choose_processor:
+ *
+ * Choose a processor for the thread, beginning at
+ * the pset. Accepts an optional processor hint in
+ * the pset.
+ *
+ * Returns a processor, possibly from a different pset.
+ *
+ * The thread must be locked. The pset must be locked,
+ * and the resulting pset is locked on return.
+ */
+processor_t
+choose_processor(
+ processor_set_t pset,
+ processor_t processor,
+ thread_t thread)
+{
+ processor_set_t nset, cset = pset;
+ processor_meta_t pmeta = PROCESSOR_META_NULL;
+ processor_t mprocessor;
/*
- * We must dispatch the old thread and then
- * call the current thread's continuation.
- * There might not be an old thread, if we are
- * the first thread to run on this processor.
+ * Prefer the hinted processor, when appropriate.
*/
- if (old_thread != THREAD_NULL) {
- thread_dispatch(old_thread);
-
- thread_lock(self);
- /* Get pointer to scheduling policy "object" */
- policy = &sched_policy[self->policy];
+ if (processor != PROCESSOR_NULL) {
+ if (processor->processor_meta != PROCESSOR_META_NULL)
+ processor = processor->processor_meta->primary;
+ }
- /* Indicate to sched policy that new thread has started execution */
- /*** ??? maybe use a macro -- rkc, 1/4/96 ***/
- sfr = policy->sp_ops.sp_thread_begin(policy,self);
- assert(sfr == SF_SUCCESS);
- } else {
- thread_lock(self);
+ mprocessor = machine_choose_processor(pset, processor);
+ if (mprocessor != PROCESSOR_NULL)
+ processor = mprocessor;
+
+ if (processor != PROCESSOR_NULL) {
+ if (processor->processor_set != pset ||
+ processor->state == PROCESSOR_INACTIVE ||
+ processor->state == PROCESSOR_SHUTDOWN ||
+ processor->state == PROCESSOR_OFF_LINE)
+ processor = PROCESSOR_NULL;
+ else
+ if (processor->state == PROCESSOR_IDLE ||
+ ((thread->sched_pri >= BASEPRI_RTQUEUES) &&
+ (processor->current_pri < BASEPRI_RTQUEUES)))
+ return (processor);
}
-
- continuation = self->continuation;
- self->continuation = (void (*)(void))0;
- thread_unlock(self);
/*
- * N.B. - the following is necessary, since thread_invoke()
- * inhibits preemption on entry and reenables before it
- * returns. Unfortunately, the first time a newly-created
- * thread executes, it magically appears here, and never
- * executes the enable_preemption() call in thread_invoke().
+ * Iterate through the processor sets to locate
+ * an appropriate processor.
+ */
+ do {
+ /*
+ * Choose an idle processor.
+ */
+ 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;
+
+ 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;
+ }
+
+ 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;
+ }
+ processor = (processor_t)queue_next((queue_entry_t)processor);
+ }
+
+ if (thread->sched_pri > lowest_unpaired)
+ return lp_unpaired;
+
+ if (pmeta != PROCESSOR_META_NULL)
+ return ((processor_t)queue_first(&pmeta->idle_queue));
+ if (thread->sched_pri > lowest_priority)
+ 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 (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 (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;
+ }
+
+ /*
+ * Otherwise, choose an available processor in the set.
+ */
+ 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.
+ */
+ nset = next_pset(cset);
+
+ if (nset != pset) {
+ pset_unlock(cset);
+
+ cset = nset;
+ pset_lock(cset);
+ }
+ } while (nset != pset);
+
+ /*
+ * Make sure that we pick a running processor,
+ * and that the correct processor set is locked.
+ */
+ 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;
+
+ /*
+ * Check that the correct processor set is
+ * returned locked.
+ */
+ if (cset != processor->processor_set) {
+ pset_unlock(cset);
+
+ cset = processor->processor_set;
+ pset_lock(cset);
+ }
+
+ return (processor);
+ }
+
+ /*
+ * Check that the processor set for the chosen
+ * processor is 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.
+ */
+ if (processor->state == PROCESSOR_INACTIVE ||
+ processor->state == PROCESSOR_SHUTDOWN || processor->state == PROCESSOR_OFF_LINE)
+ processor = PROCESSOR_NULL;
+ } while (processor == PROCESSOR_NULL);
+
+ return (processor);
+}
+
+/*
+ * thread_setrun:
+ *
+ * Dispatch thread for execution, onto an idle
+ * processor or run queue, and signal a preemption
+ * as appropriate.
+ *
+ * Thread must be locked.
+ */
+void
+thread_setrun(
+ thread_t thread,
+ integer_t options)
+{
+ processor_t processor;
+ processor_set_t pset;
+
+#if DEBUG
+ assert(thread_runnable(thread));
+#endif
+
+ /*
+ * Update priority if needed.
*/
- enable_preemption();
-
- if (self->funnel_state & TH_FN_REFUNNEL) {
- kern_return_t save_wait_result;
- self->funnel_state = 0;
- save_wait_result = self->wait_result;
- KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, self->funnel_lock, 4, 0, 0, 0);
- funnel_lock(self->funnel_lock);
- KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, self->funnel_lock, 4, 0, 0, 0);
- self->wait_result = save_wait_result;
- self->funnel_state = TH_FN_OWNED;
- }
- spllo();
-
- assert(continuation);
- (*continuation)();
- /*NOTREACHED*/
-}
+ if (SCHED(can_update_priority)(thread))
+ SCHED(update_priority)(thread);
-#if MACH_LDEBUG || MACH_KDB
+ assert(thread->runq == PROCESSOR_NULL);
-#define THREAD_LOG_SIZE 300
+ if (thread->bound_processor == PROCESSOR_NULL) {
+ /*
+ * Unbound case.
+ */
+ if (thread->affinity_set != AFFINITY_SET_NULL) {
+ /*
+ * Use affinity set policy hint.
+ */
+ pset = thread->affinity_set->aset_pset;
+ pset_lock(pset);
-struct t64 {
- unsigned long h;
- unsigned long l;
-};
+ processor = SCHED(choose_processor)(pset, PROCESSOR_NULL, thread);
+ }
+ else
+ if (thread->last_processor != PROCESSOR_NULL) {
+ /*
+ * Simple (last processor) affinity case.
+ */
+ processor = thread->last_processor;
+ pset = processor->processor_set;
+ pset_lock(pset);
+ processor = SCHED(choose_processor)(pset, processor, thread);
-struct {
- struct t64 stamp;
- thread_t thread;
- long info1;
- long info2;
- long info3;
- char * action;
-} thread_log[THREAD_LOG_SIZE];
+ 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);
+ }
+
+ }
+ else {
+ /*
+ * No Affinity case:
+ *
+ * Utilitize a per task hint to spread threads
+ * among the available processor sets.
+ */
+ task_t task = thread->task;
-int thread_log_index;
+ pset = task->pset_hint;
+ if (pset == PROCESSOR_SET_NULL)
+ pset = current_processor()->processor_set;
-void check_thread_time(long n);
+ pset = choose_next_pset(pset);
+ pset_lock(pset);
+ processor = SCHED(choose_processor)(pset, PROCESSOR_NULL, thread);
+ task->pset_hint = processor->processor_set;
+ }
+ }
+ else {
+ /*
+ * Bound case:
+ *
+ * Unconditionally dispatch on the processor.
+ */
+ processor = thread->bound_processor;
+ pset = processor->processor_set;
+ pset_lock(pset);
+ }
-int check_thread_time_crash;
+ /*
+ * Dispatch the thread on the choosen processor.
+ */
+ if (thread->sched_pri >= BASEPRI_RTQUEUES)
+ realtime_setrun(processor, thread);
+ else if (thread->sched_mode == TH_MODE_FAIRSHARE)
+ fairshare_setrun(processor, thread);
+ else
+ processor_setrun(processor, thread, options);
+}
-#if 0
-void
-check_thread_time(long us)
+processor_set_t
+task_choose_pset(
+ task_t task)
{
- struct t64 temp;
-
- if (!check_thread_time_crash)
- return;
+ processor_set_t pset = task->pset_hint;
- temp = thread_log[0].stamp;
- cyctm05_diff (&thread_log[1].stamp, &thread_log[0].stamp, &temp);
+ if (pset != PROCESSOR_SET_NULL)
+ pset = choose_next_pset(pset);
- if (temp.l >= us && thread_log[1].info != 0x49) /* HACK!!! */
- panic ("check_thread_time");
+ return (pset);
}
-#endif
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+/*
+ * processor_queue_shutdown:
+ *
+ * Shutdown a processor run queue by
+ * re-dispatching non-bound threads.
+ *
+ * Associated pset must be locked, and is
+ * returned unlocked.
+ */
void
-log_thread_action(char * action, long info1, long info2, long info3)
+processor_queue_shutdown(
+ processor_t processor)
{
- int i;
- spl_t x;
- static unsigned int tstamp;
-
- x = splhigh();
+ processor_set_t pset = processor->processor_set;
+ run_queue_t rq = runq_for_processor(processor);
+ queue_t queue = rq->queues + rq->highq;
+ int pri = rq->highq, count = rq->count;
+ thread_t next, thread;
+ queue_head_t tqueue;
+
+ queue_init(&tqueue);
+
+ while (count > 0) {
+ thread = (thread_t)queue_first(queue);
+ while (!queue_end(queue, (queue_entry_t)thread)) {
+ next = (thread_t)queue_next((queue_entry_t)thread);
+
+ if (thread->bound_processor == PROCESSOR_NULL) {
+ remqueue((queue_entry_t)thread);
+
+ thread->runq = PROCESSOR_NULL;
+ SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count);
+ runq_consider_decr_bound_count(processor, thread);
+ rq->count--;
+ if (SCHED(priority_is_urgent)(pri)) {
+ rq->urgency--; assert(rq->urgency >= 0);
+ }
+ if (queue_empty(queue)) {
+ if (pri != IDLEPRI)
+ clrbit(MAXPRI - pri, rq->bitmap);
+ rq->highq = MAXPRI - ffsbit(rq->bitmap);
+ }
- for (i = THREAD_LOG_SIZE-1; i > 0; i--) {
- thread_log[i] = thread_log[i-1];
- }
+ enqueue_tail(&tqueue, (queue_entry_t)thread);
+ }
+ count--;
- thread_log[0].stamp.h = 0;
- thread_log[0].stamp.l = tstamp++;
- thread_log[0].thread = current_thread();
- thread_log[0].info1 = info1;
- thread_log[0].info2 = info2;
- thread_log[0].info3 = info3;
- thread_log[0].action = action;
-/* strcpy (&thread_log[0].action[0], action);*/
+ thread = next;
+ }
- splx(x);
-}
-#endif /* MACH_LDEBUG || MACH_KDB */
+ queue--; pri--;
+ }
-#if MACH_KDB
-#include <ddb/db_output.h>
-void db_show_thread_log(void);
+ pset_unlock(pset);
-void
-db_show_thread_log(void)
-{
- int i;
+ while ((thread = (thread_t)dequeue_head(&tqueue)) != THREAD_NULL) {
+ thread_lock(thread);
- db_printf ("%s %s %s %s %s %s\n", " Thread ", " Info1 ", " Info2 ",
- " Info3 ", " Timestamp ", "Action");
+ thread_setrun(thread, SCHED_TAILQ);
- for (i = 0; i < THREAD_LOG_SIZE; i++) {
- db_printf ("%08x %08x %08x %08x %08x/%08x %s\n",
- thread_log[i].thread,
- thread_log[i].info1,
- thread_log[i].info2,
- thread_log[i].info3,
- thread_log[i].stamp.h,
- thread_log[i].stamp.l,
- thread_log[i].action);
+ thread_unlock(thread);
}
}
-#endif /* MACH_KDB */
+
+#endif /* CONFIG_SCHED_TRADITIONAL */
/*
- * thread_block_reason:
- *
- * Block the current thread. If the thread is runnable
- * then someone must have woken it up between its request
- * to sleep and now. In this case, it goes back on a
- * run queue.
+ * Check for a preemption point in
+ * the current context.
*
- * If a continuation is specified, then thread_block will
- * attempt to discard the thread's kernel stack. When the
- * thread resumes, it will execute the continuation function
- * on a new kernel stack.
+ * Called at splsched.
*/
-counter(mach_counter_t c_thread_block_calls = 0;)
-
-int
-thread_block_reason(
- void (*continuation)(void),
- int reason)
+ast_t
+csw_check(
+ processor_t processor)
{
- register thread_t thread = current_thread();
- register processor_t myprocessor;
- register thread_t new_thread;
- spl_t s;
+ ast_t result = AST_NONE;
- counter(++c_thread_block_calls);
-
- check_simple_locks();
-
- machine_clock_assist();
-
- s = splsched();
+ if (first_timeslice(processor)) {
+ if (rt_runq.count > 0)
+ return (AST_PREEMPT | AST_URGENT);
- if ((thread->funnel_state & TH_FN_OWNED) && !(reason & AST_PREEMPT)) {
- thread->funnel_state = TH_FN_REFUNNEL;
- KERNEL_DEBUG(0x603242c | DBG_FUNC_NONE, thread->funnel_lock, 2, 0, 0, 0);
- funnel_unlock(thread->funnel_lock);
+ result |= SCHED(processor_csw_check)(processor);
+ if (result & AST_URGENT)
+ return result;
}
+ else {
+ if (rt_runq.count > 0 && BASEPRI_RTQUEUES >= processor->current_pri)
+ return (AST_PREEMPT | AST_URGENT);
- myprocessor = current_processor();
-
- thread_lock(thread);
- if (thread->state & TH_ABORT)
- clear_wait_internal(thread, THREAD_INTERRUPTED);
-
- /* Unconditionally remove either | both */
- ast_off(AST_QUANTUM|AST_BLOCK|AST_URGENT);
-
- new_thread = thread_select(myprocessor);
- assert(new_thread);
- assert(thread_runnable(new_thread));
- thread_unlock(thread);
- while (!thread_invoke(thread, new_thread, reason, continuation)) {
- thread_lock(thread);
- new_thread = thread_select(myprocessor);
- assert(new_thread);
- assert(thread_runnable(new_thread));
- thread_unlock(thread);
+ result |= SCHED(processor_csw_check)(processor);
+ if (result & AST_URGENT)
+ return result;
}
- if (thread->funnel_state & TH_FN_REFUNNEL) {
- kern_return_t save_wait_result;
+ if (result != AST_NONE)
+ return (result);
- save_wait_result = thread->wait_result;
- thread->funnel_state = 0;
- KERNEL_DEBUG(0x6032428 | DBG_FUNC_NONE, thread->funnel_lock, 5, 0, 0, 0);
- funnel_lock(thread->funnel_lock);
- KERNEL_DEBUG(0x6032430 | DBG_FUNC_NONE, thread->funnel_lock, 5, 0, 0, 0);
- thread->funnel_state = TH_FN_OWNED;
- thread->wait_result = save_wait_result;
- }
+ if (SCHED(should_current_thread_rechoose_processor)(processor))
+ return (AST_PREEMPT);
+
+ if (machine_processor_is_inactive(processor))
+ return (AST_PREEMPT);
- splx(s);
+ if (processor->active_thread->state & TH_SUSP)
+ return (AST_PREEMPT);
- return thread->wait_result;
+ return (AST_NONE);
}
/*
- * thread_block:
+ * set_sched_pri:
*
- * Now calls thread_block_reason() which forwards the
- * the reason parameter to thread_invoke() so it can
- * do the right thing if the thread's quantum expired.
- */
-int
-thread_block(
- void (*continuation)(void))
-{
- return thread_block_reason(continuation, 0);
-}
-
-/*
- * thread_run:
+ * Set the scheduled priority of the specified thread.
*
- * Switch directly from the current thread to a specified
- * thread. Both the current and new threads must be
- * runnable.
+ * This may cause the thread to change queues.
*
- * Assumption:
- * at splsched.
+ * Thread must be locked.
*/
-int
-thread_run(
- thread_t old_thread,
- void (*continuation)(void),
- thread_t new_thread)
+void
+set_sched_pri(
+ thread_t thread,
+ int priority)
{
- while (!thread_invoke(old_thread, new_thread, 0, continuation)) {
- register processor_t myprocessor = current_processor();
- thread_lock(old_thread);
- new_thread = thread_select(myprocessor);
- thread_unlock(old_thread);
+ boolean_t removed = thread_run_queue_remove(thread);
+
+ thread->sched_pri = priority;
+ if (removed)
+ thread_setrun(thread, SCHED_PREEMPT | SCHED_TAILQ);
+ else
+ if (thread->state & TH_RUN) {
+ processor_t processor = thread->last_processor;
+
+ if (thread == current_thread()) {
+ ast_t preempt;
+
+ processor->current_pri = priority;
+ processor->current_thmode = thread->sched_mode;
+ if ((preempt = csw_check(processor)) != AST_NONE)
+ ast_on(preempt);
+ }
+ else
+ if ( processor != PROCESSOR_NULL &&
+ processor->active_thread == thread )
+ cause_ast_check(processor);
}
- return old_thread->wait_result;
}
-/*
- * Dispatches a running thread that is not on a runq.
- * Called at splsched.
- */
-void
-thread_dispatch(
- register thread_t thread)
+#if 0
+
+static void
+run_queue_check(
+ run_queue_t rq,
+ thread_t thread)
{
- sched_policy_t *policy;
- sf_return_t sfr;
+ queue_t q;
+ queue_entry_t qe;
- /*
- * If we are discarding the thread's stack, we must do it
- * before the thread has a chance to run.
- */
- wake_lock(thread);
- thread_lock(thread);
+ if (rq != thread->runq)
+ panic("run_queue_check: thread runq");
-#ifndef i386
- /* no continuations on i386 for now */
- if (thread->continuation != (void (*)())0) {
- assert((thread->state & TH_STACK_STATE) == 0);
- thread->state |= TH_STACK_HANDOFF;
- stack_free(thread);
- if (thread->top_act) {
- act_machine_sv_free(thread->top_act);
- }
- }
-#endif
+ if (thread->sched_pri > MAXPRI || thread->sched_pri < MINPRI)
+ panic("run_queue_check: thread sched_pri");
- switch (thread->state & (TH_RUN|TH_WAIT|TH_UNINT|TH_IDLE)) {
+ q = &rq->queues[thread->sched_pri];
+ qe = queue_first(q);
+ while (!queue_end(q, qe)) {
+ if (qe == (queue_entry_t)thread)
+ return;
- case TH_RUN | TH_UNINT:
- case TH_RUN:
- /*
- * No reason to stop. Put back on a run queue.
- */
- /* Leave enqueueing thread up to scheduling policy */
- policy = &sched_policy[thread->policy];
- /*** ??? maybe use a macro ***/
- sfr = policy->sp_ops.sp_thread_dispatch(policy, thread);
- assert(sfr == SF_SUCCESS);
- break;
-
- case TH_RUN | TH_WAIT | TH_UNINT:
- case TH_RUN | TH_WAIT:
- thread->sleep_stamp = sched_tick;
- /* fallthrough */
- case TH_WAIT: /* this happens! */
-
- /*
- * Waiting
- */
- thread->state &= ~TH_RUN;
- if (thread->state & TH_TERMINATE)
- thread_reaper_enqueue(thread);
+ qe = queue_next(qe);
+ }
- if (thread->wake_active) {
- thread->wake_active = FALSE;
- thread_unlock(thread);
- wake_unlock(thread);
- thread_wakeup((event_t)&thread->wake_active);
- return;
- }
- break;
+ panic("run_queue_check: end");
+}
- case TH_RUN | TH_IDLE:
- /*
- * Drop idle thread -- it is already in
- * idle_thread_array.
- */
- break;
+#endif /* DEBUG */
- default:
- panic("State 0x%x \n",thread->state);
- }
- thread_unlock(thread);
- wake_unlock(thread);
-}
+#if defined(CONFIG_SCHED_TRADITIONAL)
-/*
- * Enqueue thread on run queue. Thread must be locked,
- * and not already be on a run queue.
- */
-int
-run_queue_enqueue(
- register run_queue_t rq,
- register thread_t thread,
- boolean_t tail)
+/* locks the runqueue itself */
+
+static boolean_t
+processor_queue_remove(
+ processor_t processor,
+ thread_t thread)
{
- register int whichq;
- int oldrqcount;
+ void * rqlock;
+ run_queue_t rq;
- whichq = thread->sched_pri;
- assert(whichq >= MINPRI && whichq <= MAXPRI);
-
- simple_lock(&rq->lock); /* lock the run queue */
- assert(thread->runq == RUN_QUEUE_NULL);
- if (tail)
- enqueue_tail(&rq->queues[whichq], (queue_entry_t)thread);
- else
- enqueue_head(&rq->queues[whichq], (queue_entry_t)thread);
+ rqlock = &processor->processor_set->sched_lock;
+ rq = runq_for_processor(processor);
- setbit(MAXPRI - whichq, rq->bitmap);
- if (whichq > rq->highq)
- rq->highq = whichq;
-
- oldrqcount = rq->count++;
- thread->runq = rq;
- thread->whichq = whichq;
-#if DEBUG
- thread_check(thread, rq);
-#endif /* DEBUG */
- simple_unlock(&rq->lock);
+ simple_lock(rqlock);
+ if (processor == thread->runq) {
+ /*
+ * Thread is on a run queue and we have a lock on
+ * that run queue.
+ */
+ runq_consider_decr_bound_count(processor, thread);
+ run_queue_remove(rq, thread);
+ }
+ else {
+ /*
+ * The thread left the run queue before we could
+ * lock the run queue.
+ */
+ assert(thread->runq == PROCESSOR_NULL);
+ processor = PROCESSOR_NULL;
+ }
+
+ simple_unlock(rqlock);
- return (oldrqcount);
+ return (processor != PROCESSOR_NULL);
}
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
/*
- * thread_setrun:
+ * thread_run_queue_remove:
+ *
+ * Remove a thread from a current run queue and
+ * return TRUE if successful.
*
- * Make thread runnable; dispatch directly onto an idle processor
- * if possible. Else put on appropriate run queue (processor
- * if bound, else processor set. Caller must have lock on thread.
- * This is always called at splsched.
- * The tail parameter, if TRUE || TAIL_Q, indicates that the
- * thread should be placed at the tail of the runq. If
- * FALSE || HEAD_Q the thread will be placed at the head of the
- * appropriate runq.
+ * Thread must be locked.
*/
-void
-thread_setrun(
- register thread_t new_thread,
- boolean_t may_preempt,
- boolean_t tail)
+boolean_t
+thread_run_queue_remove(
+ thread_t thread)
{
- register processor_t processor;
- register run_queue_t runq;
- register processor_set_t pset;
- thread_t thread;
- ast_t ast_flags = AST_BLOCK;
+ processor_t processor = thread->runq;
- mp_disable_preemption();
-
- assert(!(new_thread->state & TH_SWAPPED_OUT));
- assert(thread_runnable(new_thread));
-
/*
- * Update priority if needed.
+ * 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 (new_thread->sched_stamp != sched_tick)
- update_priority(new_thread);
+ if (processor != PROCESSOR_NULL) {
+ queue_t q;
- if (new_thread->policy & (POLICY_FIFO|POLICY_RR)) {
- if ( new_thread->sched_pri >= (MAXPRI_KERNBAND - 2) &&
- kernel_preemption_mode == KERNEL_PREEMPT )
- ast_flags |= AST_URGENT;
- }
-
- assert(new_thread->runq == RUN_QUEUE_NULL);
+ /*
+ * The processor run queues are locked by the
+ * processor set. Real-time priorities use a
+ * global queue with a dedicated lock.
+ */
+ 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);
+ }
- /*
- * Try to dispatch the thread directly onto an idle processor.
- */
- if ((processor = new_thread->bound_processor) == PROCESSOR_NULL) {
- /*
- * Not bound, any processor in the processor set is ok.
- */
- pset = new_thread->processor_set;
- if (pset->idle_count > 0) {
- simple_lock(&pset->idle_lock);
- if (pset->idle_count > 0) {
- processor = (processor_t) queue_first(&pset->idle_queue);
- queue_remove(&(pset->idle_queue), processor, processor_t,
- processor_queue);
- pset->idle_count--;
- processor->next_thread = new_thread;
- processor->state = PROCESSOR_DISPATCHING;
- simple_unlock(&pset->idle_lock);
- if(processor->slot_num != cpu_number())
- machine_signal_idle(processor);
- mp_enable_preemption();
- return;
- }
- simple_unlock(&pset->idle_lock);
- }
-
+ simple_lock(&rt_lock);
+ q = &rt_runq.queue;
- /*
- * Preempt check
- */
- runq = &pset->runq;
- thread = current_thread();
- processor = current_processor();
- if ( may_preempt &&
- pset == processor->processor_set &&
- thread->sched_pri < new_thread->sched_pri ) {
- /*
- * XXX if we have a non-empty local runq or are
- * XXX running a bound thread, ought to check for
- * XXX another cpu running lower-pri thread to preempt.
+ if (processor == thread->runq) {
+ /*
+ * Thread is on a run queue and we have a lock on
+ * that run queue.
*/
- /*
- * Turn off first_quantum to allow csw.
- */
- processor->first_quantum = FALSE;
-
- ast_on(ast_flags);
- }
+ remqueue((queue_entry_t)thread);
+ SCHED_STATS_RUNQ_CHANGE(&rt_runq.runq_stats, rt_runq.count);
+ rt_runq.count--;
- /*
- * Put us on the end of the runq, if we are not preempting
- * or the guy we are preempting.
- */
- run_queue_enqueue(runq, new_thread, tail);
- }
- else {
- /*
- * Bound, can only run on bound processor. Have to lock
- * processor here because it may not be the current one.
- */
- if (processor->state == PROCESSOR_IDLE) {
- simple_lock(&processor->lock);
- pset = processor->processor_set;
- simple_lock(&pset->idle_lock);
- if (processor->state == PROCESSOR_IDLE) {
- queue_remove(&pset->idle_queue, processor,
- processor_t, processor_queue);
- pset->idle_count--;
- processor->next_thread = new_thread;
- processor->state = PROCESSOR_DISPATCHING;
- simple_unlock(&pset->idle_lock);
- simple_unlock(&processor->lock);
- if(processor->slot_num != cpu_number())
- machine_signal_idle(processor);
- mp_enable_preemption();
- return;
- }
- simple_unlock(&pset->idle_lock);
- simple_unlock(&processor->lock);
+ thread->runq = PROCESSOR_NULL;
}
-
- /*
- * Cause ast on processor if processor is on line, and the
- * currently executing thread is not bound to that processor
- * (bound threads have implicit priority over non-bound threads).
- * We also avoid sending the AST to the idle thread (if it got
- * scheduled in the window between the 'if' above and here),
- * since the idle_thread is bound.
- */
- runq = &processor->runq;
- thread = current_thread();
- if (processor == current_processor()) {
- if ( thread->bound_processor == PROCESSOR_NULL ||
- thread->sched_pri < new_thread->sched_pri ) {
- processor->first_quantum = FALSE;
- ast_on(ast_flags);
- }
-
- run_queue_enqueue(runq, new_thread, tail);
- }
else {
- thread = cpu_data[processor->slot_num].active_thread;
- if ( run_queue_enqueue(runq, new_thread, tail) == 0 &&
- processor->state != PROCESSOR_OFF_LINE &&
- thread && thread->bound_processor != processor )
- cause_ast_check(processor);
- }
+ /*
+ * The thread left the run queue before we could
+ * lock the run queue.
+ */
+ assert(thread->runq == PROCESSOR_NULL);
+ processor = PROCESSOR_NULL;
+ }
+
+ simple_unlock(&rt_lock);
}
- mp_enable_preemption();
+ return (processor != PROCESSOR_NULL);
}
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
/*
- * set_pri:
+ * steal_processor_thread:
*
- * Set the priority of the specified thread to the specified
- * priority. This may cause the thread to change queues.
+ * Locate a thread to steal from the processor and
+ * return it.
*
- * The thread *must* be locked by the caller.
+ * Associated pset must be locked. Returns THREAD_NULL
+ * on failure.
*/
-void
-set_pri(
- thread_t thread,
- int pri,
- boolean_t resched)
+static thread_t
+steal_processor_thread(
+ processor_t processor)
{
- register struct run_queue *rq;
+ run_queue_t rq = runq_for_processor(processor);
+ queue_t queue = rq->queues + rq->highq;
+ int pri = rq->highq, count = rq->count;
+ thread_t thread;
+
+ while (count > 0) {
+ thread = (thread_t)queue_first(queue);
+ while (!queue_end(queue, (queue_entry_t)thread)) {
+ if (thread->bound_processor == PROCESSOR_NULL) {
+ remqueue((queue_entry_t)thread);
+
+ thread->runq = PROCESSOR_NULL;
+ SCHED_STATS_RUNQ_CHANGE(&rq->runq_stats, rq->count);
+ runq_consider_decr_bound_count(processor, thread);
+ rq->count--;
+ if (SCHED(priority_is_urgent)(pri)) {
+ rq->urgency--; assert(rq->urgency >= 0);
+ }
+ if (queue_empty(queue)) {
+ if (pri != IDLEPRI)
+ clrbit(MAXPRI - pri, rq->bitmap);
+ rq->highq = MAXPRI - ffsbit(rq->bitmap);
+ }
- rq = rem_runq(thread);
- assert(thread->runq == RUN_QUEUE_NULL);
- thread->sched_pri = pri;
- if (rq != RUN_QUEUE_NULL) {
- if (resched)
- thread_setrun(thread, TRUE, TAIL_Q);
- else
- run_queue_enqueue(rq, thread, TAIL_Q);
+ return (thread);
+ }
+ count--;
+
+ thread = (thread_t)queue_next((queue_entry_t)thread);
+ }
+
+ queue--; pri--;
}
+
+ return (THREAD_NULL);
}
/*
- * rem_runq:
+ * Locate and steal a thread, beginning
+ * at the pset.
+ *
+ * The pset must be locked, and is returned
+ * unlocked.
*
- * Remove a thread from its run queue.
- * The run queue that the process was on is returned
- * (or RUN_QUEUE_NULL if not on a run queue). Thread *must* be locked
- * before calling this routine. Unusual locking protocol on runq
- * field in thread structure makes this code interesting; see thread.h.
+ * Returns the stolen thread, or THREAD_NULL on
+ * failure.
*/
-run_queue_t
-rem_runq(
- thread_t thread)
+static thread_t
+steal_thread(
+ processor_set_t pset)
{
- register struct run_queue *rq;
+ processor_set_t nset, cset = pset;
+ processor_t processor;
+ thread_t thread;
- rq = thread->runq;
- /*
- * If rq is RUN_QUEUE_NULL, the thread will stay out of the
- * run_queues because the caller locked the thread. Otherwise
- * the thread is on a runq, but could leave.
- */
- if (rq != RUN_QUEUE_NULL) {
- simple_lock(&rq->lock);
- if (rq == thread->runq) {
- /*
- * Thread is in a runq and we have a lock on
- * that runq.
- */
-#if DEBUG
- thread_check(thread, rq);
-#endif /* DEBUG */
- remqueue(&rq->queues[0], (queue_entry_t)thread);
- rq->count--;
-
- if (queue_empty(rq->queues + thread->sched_pri)) {
- /* update run queue status */
- if (thread->sched_pri != IDLEPRI)
- clrbit(MAXPRI - thread->sched_pri, rq->bitmap);
- rq->highq = MAXPRI - ffsbit(rq->bitmap);
+ do {
+ processor = (processor_t)queue_first(&cset->active_queue);
+ while (!queue_end(&cset->active_queue, (queue_entry_t)processor)) {
+ if (runq_for_processor(processor)->count > 0) {
+ thread = steal_processor_thread(processor);
+ if (thread != THREAD_NULL) {
+ remqueue((queue_entry_t)processor);
+ enqueue_tail(&cset->active_queue, (queue_entry_t)processor);
+
+ pset_unlock(cset);
+
+ return (thread);
+ }
}
- thread->runq = RUN_QUEUE_NULL;
- simple_unlock(&rq->lock);
+
+ processor = (processor_t)queue_next((queue_entry_t)processor);
}
- else {
- /*
- * The thread left the runq before we could
- * lock the runq. It is not on a runq now, and
- * can't move again because this routine's
- * caller locked the thread.
- */
- assert(thread->runq == RUN_QUEUE_NULL);
- simple_unlock(&rq->lock);
- rq = RUN_QUEUE_NULL;
+
+ nset = next_pset(cset);
+
+ if (nset != pset) {
+ pset_unlock(cset);
+
+ cset = nset;
+ pset_lock(cset);
}
- }
+ } while (nset != pset);
- return (rq);
+ pset_unlock(cset);
+
+ return (THREAD_NULL);
}
+static thread_t steal_thread_disabled(
+ processor_set_t pset)
+{
+ pset_unlock(pset);
-/*
- * choose_thread:
- *
- * Choose a thread to execute. The thread chosen is removed
- * from its run queue. Note that this requires only that the runq
- * lock be held.
- *
- * Strategy:
- * Check processor runq first; if anything found, run it.
- * Else check pset runq; if nothing found, return idle thread.
- *
- * Second line of strategy is implemented by choose_pset_thread.
- * This is only called on processor startup and when thread_block
- * thinks there's something in the processor runq.
- */
-thread_t
-choose_thread(
- processor_t myprocessor)
+ return (THREAD_NULL);
+}
+
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+
+int
+thread_get_urgency(uint64_t *rt_period, uint64_t *rt_deadline)
{
- thread_t thread;
- register queue_t q;
- register run_queue_t runq;
- processor_set_t pset;
-
- runq = &myprocessor->runq;
- pset = myprocessor->processor_set;
-
- simple_lock(&runq->lock);
- if (runq->count > 0 && runq->highq >= pset->runq.highq) {
- q = runq->queues + runq->highq;
-#if MACH_ASSERT
- if (!queue_empty(q)) {
-#endif /*MACH_ASSERT*/
- thread = (thread_t)q->next;
- ((queue_entry_t)thread)->next->prev = q;
- q->next = ((queue_entry_t)thread)->next;
- thread->runq = RUN_QUEUE_NULL;
- runq->count--;
- if (queue_empty(q)) {
- if (runq->highq != IDLEPRI)
- clrbit(MAXPRI - runq->highq, runq->bitmap);
- runq->highq = MAXPRI - ffsbit(runq->bitmap);
- }
- simple_unlock(&runq->lock);
- return (thread);
-#if MACH_ASSERT
- }
- panic("choose_thread");
-#endif /*MACH_ASSERT*/
- /*NOTREACHED*/
- }
+ processor_t processor;
+ thread_t thread;
+
+ processor = current_processor();
- simple_unlock(&runq->lock);
- simple_lock(&pset->runq.lock);
- return (choose_pset_thread(myprocessor, pset));
-}
+ thread = processor->next_thread;
+ if (thread != NULL) {
+ if (thread->sched_mode == TH_MODE_REALTIME) {
-/*
- * choose_pset_thread: choose a thread from processor_set runq or
- * set processor idle and choose its idle thread.
- *
- * Caller must be at splsched and have a lock on the runq. This
- * lock is released by this routine. myprocessor is always the current
- * processor, and pset must be its processor set.
- * This routine chooses and removes a thread from the runq if there
- * is one (and returns it), else it sets the processor idle and
- * returns its idle thread.
- */
-thread_t
-choose_pset_thread(
- register processor_t myprocessor,
- processor_set_t pset)
-{
- register run_queue_t runq;
- register thread_t thread;
- register queue_t q;
+ if (rt_period != NULL)
+ *rt_period = thread->realtime.period;
+ if (rt_deadline != NULL)
+ *rt_deadline = thread->realtime.deadline;
- runq = &pset->runq;
- if (runq->count > 0) {
- q = runq->queues + runq->highq;
-#if MACH_ASSERT
- if (!queue_empty(q)) {
-#endif /*MACH_ASSERT*/
- thread = (thread_t)q->next;
- ((queue_entry_t)thread)->next->prev = q;
- q->next = ((queue_entry_t)thread)->next;
- thread->runq = RUN_QUEUE_NULL;
- runq->count--;
- if (queue_empty(q)) {
- if (runq->highq != IDLEPRI)
- clrbit(MAXPRI - runq->highq, runq->bitmap);
- runq->highq = MAXPRI - ffsbit(runq->bitmap);
- }
- simple_unlock(&runq->lock);
- return (thread);
-#if MACH_ASSERT
- }
- panic("choose_pset_thread");
-#endif /*MACH_ASSERT*/
- /*NOTREACHED*/
- }
- simple_unlock(&runq->lock);
+ 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);
- /*
- * Nothing is runnable, so set this processor idle if it
- * was running. If it was in an assignment or shutdown,
- * leave it alone. Return its idle thread.
- */
- simple_lock(&pset->idle_lock);
- if (myprocessor->state == PROCESSOR_RUNNING) {
- myprocessor->state = PROCESSOR_IDLE;
- /*
- * XXX Until it goes away, put master on end of queue, others
- * XXX on front so master gets used last.
- */
- if (myprocessor == master_processor)
- queue_enter(&(pset->idle_queue), myprocessor,
- processor_t, processor_queue);
- else
- queue_enter_first(&(pset->idle_queue), myprocessor,
- processor_t, processor_queue);
+ 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);
- pset->idle_count++;
+ return (THREAD_URGENCY_NORMAL);
}
- simple_unlock(&pset->idle_lock);
-
- return (myprocessor->idle_thread);
+ else
+ KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_SCHED, MACH_SCHED_GET_URGENCY), THREAD_URGENCY_NONE, 0, 0, 0, 0);
+ return (THREAD_URGENCY_NONE);
}
-/*
- * no_dispatch_count counts number of times processors go non-idle
- * without being dispatched. This should be very rare.
- */
-int no_dispatch_count = 0;
/*
- * This is the idle thread, which just looks for other threads
- * to execute.
+ * This is the processor idle loop, which just looks for other threads
+ * to execute. Processor idle threads invoke this without supplying a
+ * current thread to idle without an asserted wait state.
+ *
+ * Returns a the next thread to execute if dispatched directly.
*/
-void
-idle_thread_continue(void)
+
+#if 0
+#define IDLE_KERNEL_DEBUG_CONSTANT(...) KERNEL_DEBUG_CONSTANT(__VA_ARGS__)
+#else
+#define IDLE_KERNEL_DEBUG_CONSTANT(...) do { } while(0)
+#endif
+
+thread_t
+processor_idle(
+ thread_t thread,
+ processor_t processor)
{
- register processor_t myprocessor;
- register volatile thread_t *threadp;
- register volatile int *gcount;
- register volatile int *lcount;
- register thread_t new_thread;
- register int state;
- register processor_set_t pset;
- int mycpu;
+ processor_set_t pset = processor->processor_set;
+ thread_t new_thread;
+ int state;
+ (void)splsched();
- mycpu = cpu_number();
- myprocessor = current_processor();
- threadp = (volatile thread_t *) &myprocessor->next_thread;
- lcount = (volatile int *) &myprocessor->runq.count;
+ KERNEL_DEBUG_CONSTANT(
+ MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_START, (uintptr_t)thread_tid(thread), 0, 0, 0, 0);
- for (;;) {
-#ifdef MARK_CPU_IDLE
- MARK_CPU_IDLE(mycpu);
-#endif /* MARK_CPU_IDLE */
+ SCHED_STATS_CPU_IDLE_START(processor);
- gcount = (volatile int *)&myprocessor->processor_set->runq.count;
+ timer_switch(&PROCESSOR_DATA(processor, system_state),
+ 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))) {
+ 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_idle();
(void)splsched();
- while ( (*threadp == (volatile thread_t)THREAD_NULL) &&
- (*gcount == 0) && (*lcount == 0) ) {
- /* check for ASTs while we wait */
+ 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 (need_ast[mycpu] &~ (AST_SCHEDULING|AST_URGENT|AST_BSD|AST_BSD_INIT)) {
- /* don't allow scheduling ASTs */
- need_ast[mycpu] &= ~(AST_SCHEDULING|AST_URGENT|AST_BSD|AST_BSD_INIT);
- ast_taken(FALSE, AST_ALL, TRUE); /* back at spllo */
- }
- else
-#ifdef __ppc__
- machine_idle();
-#else
- (void)spllo();
-#endif
- machine_clock_assist();
+ if (processor->state == PROCESSOR_INACTIVE && !machine_processor_is_inactive(processor))
+ break;
+ }
- (void)splsched();
- }
+ timer_switch(&PROCESSOR_DATA(processor, idle_state),
+ mach_absolute_time(), &PROCESSOR_DATA(processor, system_state));
+ PROCESSOR_DATA(processor, current_state) = &PROCESSOR_DATA(processor, system_state);
-#ifdef MARK_CPU_ACTIVE
- (void)spllo();
- MARK_CPU_ACTIVE(mycpu);
- (void)splsched();
-#endif /* MARK_CPU_ACTIVE */
+ pset_lock(pset);
+ state = processor->state;
+ if (state == PROCESSOR_DISPATCHING) {
/*
- * This is not a switch statement to avoid the
- * bounds checking code in the common case.
+ * Commmon case -- cpu dispatched.
*/
- pset = myprocessor->processor_set;
- simple_lock(&pset->idle_lock);
-retry:
- state = myprocessor->state;
- if (state == PROCESSOR_DISPATCHING) {
- /*
- * Commmon case -- cpu dispatched.
- */
- new_thread = *threadp;
- *threadp = (volatile thread_t) THREAD_NULL;
- myprocessor->state = PROCESSOR_RUNNING;
- simple_unlock(&pset->idle_lock);
+ new_thread = processor->next_thread;
+ processor->next_thread = THREAD_NULL;
+ processor->state = PROCESSOR_RUNNING;
- thread_lock(new_thread);
- simple_lock(&myprocessor->runq.lock);
- simple_lock(&pset->runq.lock);
- if ( myprocessor->runq.highq > new_thread->sched_pri ||
- pset->runq.highq > new_thread->sched_pri ) {
- simple_unlock(&pset->runq.lock);
- simple_unlock(&myprocessor->runq.lock);
-
- if (new_thread->bound_processor != PROCESSOR_NULL)
- run_queue_enqueue(&myprocessor->runq, new_thread, HEAD_Q);
- else
- run_queue_enqueue(&pset->runq, new_thread, HEAD_Q);
- thread_unlock(new_thread);
+ if (SCHED(processor_queue_has_priority)(processor, new_thread->sched_pri, FALSE) ||
+ (rt_runq.count > 0 && BASEPRI_RTQUEUES >= new_thread->sched_pri) ) {
+ processor->deadline = UINT64_MAX;
- counter(c_idle_thread_block++);
- thread_block(idle_thread_continue);
- }
- else {
- simple_unlock(&pset->runq.lock);
- simple_unlock(&myprocessor->runq.lock);
+ pset_unlock(pset);
- /*
- * set up quantum for new thread.
- */
- if (new_thread->policy & (POLICY_RR|POLICY_FIFO))
- myprocessor->quantum = new_thread->unconsumed_quantum;
- else
- myprocessor->quantum = pset->set_quantum;
- thread_unlock(new_thread);
+ thread_lock(new_thread);
+ KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_SCHED, MACH_REDISPATCH), (uintptr_t)thread_tid(new_thread), new_thread->sched_pri, rt_runq.count, 0, 0);
+ thread_setrun(new_thread, SCHED_HEADQ);
+ thread_unlock(new_thread);
- myprocessor->first_quantum = TRUE;
- counter(c_idle_thread_handoff++);
- thread_run(myprocessor->idle_thread,
- idle_thread_continue, new_thread);
- }
- }
- else
- if (state == PROCESSOR_IDLE) {
- if (myprocessor->state != PROCESSOR_IDLE) {
- /*
- * Something happened, try again.
- */
- goto retry;
- }
- /*
- * Processor was not dispatched (Rare).
- * Set it running again.
- */
- no_dispatch_count++;
- pset->idle_count--;
- queue_remove(&pset->idle_queue, myprocessor,
- processor_t, processor_queue);
- myprocessor->state = PROCESSOR_RUNNING;
- simple_unlock(&pset->idle_lock);
-
- counter(c_idle_thread_block++);
- thread_block(idle_thread_continue);
- }
- else
- if ( state == PROCESSOR_ASSIGN ||
- state == PROCESSOR_SHUTDOWN ) {
- /*
- * Changing processor sets, or going off-line.
- * Release next_thread if there is one. Actual
- * thread to run is on a runq.
- */
- if ((new_thread = (thread_t)*threadp) != THREAD_NULL) {
- *threadp = (volatile thread_t) THREAD_NULL;
- simple_unlock(&pset->idle_lock);
- thread_lock(new_thread);
- thread_setrun(new_thread, FALSE, TAIL_Q);
- thread_unlock(new_thread);
- } else
- simple_unlock(&pset->idle_lock);
-
- counter(c_idle_thread_block++);
- thread_block(idle_thread_continue);
- }
- else {
- simple_unlock(&pset->idle_lock);
- printf("Bad processor state %d (Cpu %d)\n",
- cpu_state(mycpu), mycpu);
- panic("idle_thread");
+ KERNEL_DEBUG_CONSTANT(
+ MACHDBG_CODE(DBG_MACH_SCHED,MACH_IDLE) | DBG_FUNC_END, (uintptr_t)thread_tid(thread), state, 0, 0, 0);
+ return (THREAD_NULL);
}
- (void)spllo();
+ 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);
+
+ return (new_thread);
+ }
+ else
+ if (state == 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;
+ enqueue_tail(&pset->active_queue, (queue_entry_t)processor);
+ }
+ else
+ if (state == PROCESSOR_SHUTDOWN) {
+ /*
+ * Going off-line. Force a
+ * reschedule.
+ */
+ if ((new_thread = processor->next_thread) != THREAD_NULL) {
+ processor->next_thread = THREAD_NULL;
+ processor->deadline = UINT64_MAX;
+
+ pset_unlock(pset);
+
+ thread_lock(new_thread);
+ 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);
+
+ 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, 0, 0, 0);
+
+ return (THREAD_NULL);
}
+/*
+ * Each processor has a dedicated thread which
+ * executes the idle loop when there is no suitable
+ * previous context.
+ */
void
idle_thread(void)
{
- thread_t self = current_thread();
- spl_t s;
+ processor_t processor = current_processor();
+ thread_t new_thread;
- stack_privilege(self);
- thread_swappable(current_act(), FALSE);
+ new_thread = processor_idle(THREAD_NULL, processor);
+ if (new_thread != THREAD_NULL) {
+ thread_run(processor->idle_thread, (thread_continue_t)idle_thread, NULL, new_thread);
+ /*NOTREACHED*/
+ }
- s = splsched();
- thread_lock(self);
+ thread_block((thread_continue_t)idle_thread);
+ /*NOTREACHED*/
+}
+
+kern_return_t
+idle_thread_create(
+ processor_t processor)
+{
+ kern_return_t result;
+ thread_t thread;
+ spl_t s;
- self->priority = IDLEPRI;
- self->sched_pri = self->priority;
+ result = kernel_thread_create((thread_continue_t)idle_thread, NULL, MAXPRI_KERNEL, &thread);
+ if (result != KERN_SUCCESS)
+ return (result);
- thread_unlock(self);
+ s = splsched();
+ thread_lock(thread);
+ thread->bound_processor = processor;
+ processor->idle_thread = thread;
+ thread->sched_pri = thread->priority = IDLEPRI;
+ thread->state = (TH_RUN | TH_IDLE);
+ thread_unlock(thread);
splx(s);
- counter(c_idle_thread_block++);
- thread_block((void(*)(void))0);
- idle_thread_continue();
- /*NOTREACHED*/
-}
+ thread_deallocate(thread);
-static AbsoluteTime sched_tick_interval, sched_tick_deadline;
+ return (KERN_SUCCESS);
+}
/*
- * sched_tick_thread
+ * sched_startup:
*
- * Update the priorities of all threads periodically.
+ * Kicks off scheduler services.
+ *
+ * Called at splsched.
*/
void
-sched_tick_thread_continue(void)
+sched_startup(void)
{
- AbsoluteTime abstime;
-#if SIMPLE_CLOCK
- int new_usec;
-#endif /* SIMPLE_CLOCK */
+ kern_return_t result;
+ thread_t thread;
+
+ result = kernel_thread_start_priority((thread_continue_t)sched_init_thread,
+ (void *)SCHED(maintenance_continuation),
+ MAXPRI_KERNEL, &thread);
+ if (result != KERN_SUCCESS)
+ panic("sched_startup");
- clock_get_uptime(&abstime);
+ thread_deallocate(thread);
- sched_tick++; /* age usage one more time */
-#if SIMPLE_CLOCK
/*
- * Compensate for clock drift. sched_usec is an
- * exponential average of the number of microseconds in
- * a second. It decays in the same fashion as cpu_usage.
+ * Yield to the sched_init_thread while it times
+ * a series of context switches back. It stores
+ * the baseline value in sched_cswtime.
+ *
+ * The current thread is the only other thread
+ * active at this point.
*/
- new_usec = sched_usec_elapsed();
- sched_usec = (5*sched_usec + 3*new_usec)/8;
-#endif /* SIMPLE_CLOCK */
+ while (sched_cswtime == 0)
+ thread_block(THREAD_CONTINUE_NULL);
+}
+
+#if defined(CONFIG_SCHED_TRADITIONAL)
+
+static uint64_t sched_tick_deadline = 0;
+
+/*
+ * sched_init_thread:
+ *
+ * Perform periodic bookkeeping functions about ten
+ * times per second.
+ */
+static void
+sched_traditional_tick_continue(void)
+{
+ uint64_t abstime = mach_absolute_time();
+
+ sched_tick++;
/*
- * Compute the scheduler load factors.
+ * Compute various averages.
*/
- compute_mach_factor();
+ compute_averages();
/*
- * Scan the run queues for runnable threads that need to
- * have their priorities recalculated.
+ * Scan the run queues for threads which
+ * may need to be updated.
*/
- do_thread_scan();
+ thread_update_scan();
+ if (sched_tick_deadline == 0)
+ sched_tick_deadline = abstime;
+
clock_deadline_for_periodic_event(sched_tick_interval, abstime,
&sched_tick_deadline);
- assert_wait((event_t)sched_tick_thread_continue, THREAD_INTERRUPTIBLE);
- thread_set_timer_deadline(sched_tick_deadline);
- thread_block(sched_tick_thread_continue);
+ assert_wait_deadline((event_t)sched_traditional_tick_continue, THREAD_UNINT, sched_tick_deadline);
+ thread_block((thread_continue_t)sched_traditional_tick_continue);
/*NOTREACHED*/
}
-void
-sched_tick_thread(void)
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+static uint32_t
+time_individual_cswitch(void)
{
- thread_t self = current_thread();
- natural_t rate;
- spl_t s;
+ uint32_t switches = 0;
+ uint64_t newtime, starttime;
+
+ /* Wait for absolute time to increase. */
+ starttime = mach_absolute_time();
+ do {
+ newtime = mach_absolute_time();
+ } while (newtime == starttime);
- stack_privilege(self);
- thread_swappable(self->top_act, FALSE);
+ /* 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);
+}
- s = splsched();
- thread_lock(self);
+/*
+ * 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;
- self->priority = MAXPRI_STANDARD;
- self->sched_pri = self->priority;
+ accum = hi = low = 0;
+ for (i = 0; i < tries; ++i) {
+ new = time_individual_cswitch();
- thread_unlock(self);
- splx(s);
+ if (i == 0)
+ accum = hi = low = new;
+ else {
+ if (new < low)
+ low = new;
+ else
+ if (new > hi)
+ hi = new;
+ accum += new;
+ }
+ }
+ /* Round up. */
+ denom = 2 * (tries - 2);
+ return (accum - hi - low + denom - 1) / denom;
+}
+
+void
+sched_init_thread(void (*continuation)(void))
+{
+ sched_cswtime = time_cswitch();
+ assert(sched_cswtime > 0);
- rate = (1000 >> SCHED_TICK_SHIFT);
- clock_interval_to_absolutetime_interval(rate, USEC_PER_SEC,
- &sched_tick_interval);
- clock_get_uptime(&sched_tick_deadline);
+ continuation();
- thread_block(sched_tick_thread_continue);
/*NOTREACHED*/
}
-#define MAX_STUCK_THREADS 128
+#if defined(CONFIG_SCHED_TRADITIONAL)
/*
- * do_thread_scan: scan for stuck threads. A thread is stuck if
- * it is runnable but its priority is so low that it has not
- * run for several seconds. Its priority should be higher, but
- * won't be until it runs and calls update_priority. The scanner
- * finds these threads and does the updates.
+ * thread_update_scan / runq_scan:
+ *
+ * Scan the run queues to account for timesharing threads
+ * which need to be updated.
*
* Scanner runs in two passes. Pass one squirrels likely
- * thread ids away in an array (takes out references for them).
- * Pass two does the priority updates. This is necessary because
- * the run queue lock is required for the candidate scan, but
- * cannot be held during updates [set_pri will deadlock].
+ * threads away in an array, pass two does the update.
*
- * Array length should be enough so that restart isn't necessary,
- * but restart logic is included. Does not scan processor runqs.
+ * This is necessary because the run queue is locked for
+ * the candidate scan, but the thread is locked for the update.
*
+ * Array should be sized to make forward progress, without
+ * disabling preemption for long periods.
*/
-thread_t stuck_threads[MAX_STUCK_THREADS];
-int stuck_count = 0;
+
+#define THREAD_UPDATE_SIZE 128
+
+static thread_t thread_update_array[THREAD_UPDATE_SIZE];
+static int thread_update_count = 0;
/*
- * do_runq_scan is the guts of pass 1. It scans a runq for
- * stuck threads. A boolean is returned indicating whether
- * a retry is needed.
+ * Scan a runq for candidate threads.
+ *
+ * Returns TRUE if retry is needed.
*/
-boolean_t
-do_runq_scan(
+static boolean_t
+runq_scan(
run_queue_t runq)
{
+ register int count;
register queue_t q;
register thread_t thread;
- register int count;
- spl_t s;
- boolean_t result = FALSE;
- s = splsched();
- simple_lock(&runq->lock);
if ((count = runq->count) > 0) {
q = runq->queues + runq->highq;
while (count > 0) {
queue_iterate(q, thread, thread_t, links) {
- if ( !(thread->state & (TH_WAIT|TH_SUSP)) &&
- thread->policy == POLICY_TIMESHARE ) {
- if (thread->sched_stamp != sched_tick) {
- /*
- * Stuck, save its id for later.
- */
- if (stuck_count == MAX_STUCK_THREADS) {
- /*
- * !@#$% No more room.
- */
- simple_unlock(&runq->lock);
- splx(s);
-
- return (TRUE);
- }
-
- /*
- * Inline version of thread_reference
- * XXX - lock ordering problem here:
- * thread locks should be taken before runq
- * locks: just try and get the thread's locks
- * and ignore this thread if we fail, we might
- * have better luck next time.
- */
- if (simple_lock_try(&thread->lock)) {
- thread->ref_count++;
- thread_unlock(thread);
- stuck_threads[stuck_count++] = thread;
- }
- else
- result = TRUE;
- }
+ if ( thread->sched_stamp != sched_tick &&
+ (thread->sched_mode == TH_MODE_TIMESHARE) ) {
+ if (thread_update_count == THREAD_UPDATE_SIZE)
+ return (TRUE);
+
+ thread_update_array[thread_update_count++] = thread;
+ thread_reference_internal(thread);
}
count--;
q--;
}
}
- simple_unlock(&runq->lock);
- splx(s);
- return (result);
+ return (FALSE);
}
-boolean_t thread_scan_enabled = TRUE;
-
-void
-do_thread_scan(void)
+static void
+thread_update_scan(void)
{
- register boolean_t restart_needed = FALSE;
- register thread_t thread;
- register processor_set_t pset = &default_pset;
- register processor_t processor;
- spl_t s;
-
- if (!thread_scan_enabled)
- return;
+ boolean_t restart_needed = FALSE;
+ processor_t processor = processor_list;
+ processor_set_t pset;
+ thread_t thread;
+ spl_t s;
do {
- restart_needed = do_runq_scan(&pset->runq);
- if (!restart_needed) {
- simple_lock(&pset->processors_lock);
- processor = (processor_t)queue_first(&pset->processors);
- while (!queue_end(&pset->processors, (queue_entry_t)processor)) {
- if (restart_needed = do_runq_scan(&processor->runq))
+ do {
+ pset = processor->processor_set;
+
+ s = splsched();
+ pset_lock(pset);
+
+ restart_needed = runq_scan(runq_for_processor(processor));
+
+ pset_unlock(pset);
+ splx(s);
+
+ if (restart_needed)
+ break;
+
+ thread = processor->idle_thread;
+ if (thread != THREAD_NULL && thread->sched_stamp != sched_tick) {
+ if (thread_update_count == THREAD_UPDATE_SIZE) {
+ restart_needed = TRUE;
break;
+ }
- processor = (processor_t)queue_next(&processor->processors);
+ thread_update_array[thread_update_count++] = thread;
+ thread_reference_internal(thread);
}
- simple_unlock(&pset->processors_lock);
- }
+ } while ((processor = processor->processor_list) != NULL);
/*
* Ok, we now have a collection of candidates -- fix them.
*/
- while (stuck_count > 0) {
- thread = stuck_threads[--stuck_count];
- stuck_threads[stuck_count] = THREAD_NULL;
+ 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->policy == POLICY_TIMESHARE) {
- if ( !(thread->state & (TH_WAIT|TH_SUSP)) &&
- thread->sched_stamp != sched_tick )
- update_priority(thread);
+ if ( !(thread->state & (TH_WAIT)) ) {
+ if (SCHED(can_update_priority)(thread))
+ SCHED(update_priority)(thread);
}
thread_unlock(thread);
splx(s);
+
thread_deallocate(thread);
}
-
} while (restart_needed);
}
-
-/*
- * Just in case someone doesn't use the macro
- */
-#undef thread_wakeup
-void
-thread_wakeup(
- event_t x);
-void
-thread_wakeup(
- event_t x)
+#endif /* CONFIG_SCHED_TRADITIONAL */
+
+boolean_t
+thread_eager_preemption(thread_t thread)
{
- thread_wakeup_with_result(x, THREAD_AWAKENED);
+ return ((thread->sched_flags & TH_SFLAG_EAGERPREEMPT) != 0);
}
-boolean_t
-thread_runnable(
- thread_t thread)
+void
+thread_set_eager_preempt(thread_t thread)
{
- sched_policy_t *policy;
+ spl_t x;
+ processor_t p;
+ ast_t ast = AST_NONE;
- /* Ask sched policy if thread is runnable */
- policy = policy_id_to_sched_policy(thread->policy);
+ x = splsched();
+ p = current_processor();
- return ((policy != SCHED_POLICY_NULL)?
- policy->sp_ops.sp_thread_runnable(policy, thread) : FALSE);
-}
+ thread_lock(thread);
+ thread->sched_flags |= TH_SFLAG_EAGERPREEMPT;
-#if DEBUG
+ if (thread == current_thread()) {
+ thread_unlock(thread);
-void
-dump_processor_set(
- processor_set_t ps)
-{
- printf("processor_set: %08x\n",ps);
- printf("idle_queue: %08x %08x, idle_count: 0x%x\n",
- ps->idle_queue.next,ps->idle_queue.prev,ps->idle_count);
- printf("processors: %08x %08x, processor_count: 0x%x\n",
- ps->processors.next,ps->processors.prev,ps->processor_count);
- printf("tasks: %08x %08x, task_count: 0x%x\n",
- ps->tasks.next,ps->tasks.prev,ps->task_count);
- printf("threads: %08x %08x, thread_count: 0x%x\n",
- ps->threads.next,ps->threads.prev,ps->thread_count);
- printf("ref_count: 0x%x, active: %x\n",
- ps->ref_count,ps->active);
- printf("pset_self: %08x, pset_name_self: %08x\n",ps->pset_self, ps->pset_name_self);
- printf("max_priority: 0x%x, policies: 0x%x, set_quantum: 0x%x\n",
- ps->max_priority, ps->policies, ps->set_quantum);
-}
-
-#define processor_state(s) (((s)>PROCESSOR_SHUTDOWN)?"*unknown*":states[s])
+ ast = csw_check(p);
+ if (ast != AST_NONE) {
+ (void) thread_block_reason(THREAD_CONTINUE_NULL, NULL, ast);
+ }
+ } else {
+ p = thread->last_processor;
-void
-dump_processor(
- processor_t p)
-{
- char *states[]={"OFF_LINE","RUNNING","IDLE","DISPATCHING",
- "ASSIGN","SHUTDOWN"};
+ if (p != PROCESSOR_NULL && p->state == PROCESSOR_RUNNING &&
+ p->active_thread == thread) {
+ cause_ast_check(p);
+ }
+
+ thread_unlock(thread);
+ }
- printf("processor: %08x\n",p);
- printf("processor_queue: %08x %08x\n",
- p->processor_queue.next,p->processor_queue.prev);
- printf("state: %8s, next_thread: %08x, idle_thread: %08x\n",
- processor_state(p->state), p->next_thread, p->idle_thread);
- printf("quantum: %u, first_quantum: %x, last_quantum: %u\n",
- p->quantum, p->first_quantum, p->last_quantum);
- printf("processor_set: %08x, processor_set_next: %08x\n",
- p->processor_set, p->processor_set_next);
- printf("processors: %08x %08x\n", p->processors.next,p->processors.prev);
- printf("processor_self: %08x, slot_num: 0x%x\n", p->processor_self, p->slot_num);
+ splx(x);
}
void
-dump_run_queue_struct(
- run_queue_t rq)
+thread_clear_eager_preempt(thread_t thread)
{
- char dump_buf[80];
- int i;
-
- for( i=0; i < NRQS; ) {
- int j;
-
- printf("%6s",(i==0)?"runq:":"");
- for( j=0; (j<8) && (i < NRQS); j++,i++ ) {
- if( rq->queues[i].next == &rq->queues[i] )
- printf( " --------");
- else
- printf(" %08x",rq->queues[i].next);
- }
- printf("\n");
- }
- for( i=0; i < NRQBM; ) {
- register unsigned int mask;
- char *d=dump_buf;
+ spl_t x;
- mask = ~0;
- mask ^= (mask>>1);
+ x = splsched();
+ thread_lock(thread);
- do {
- *d++ = ((rq->bitmap[i]&mask)?'r':'e');
- mask >>=1;
- } while( mask );
- *d = '\0';
- printf("%8s%s\n",((i==0)?"bitmap:":""),dump_buf);
- i++;
- }
- printf("highq: 0x%x, count: %u\n", rq->highq, rq->count);
+ thread->sched_flags &= ~TH_SFLAG_EAGERPREEMPT;
+
+ thread_unlock(thread);
+ splx(x);
}
-
+/*
+ * Scheduling statistics
+ */
void
-dump_run_queues(
- run_queue_t runq)
-{
- register queue_t q1;
- register int i;
- register queue_entry_t e;
-
- q1 = runq->queues;
- for (i = 0; i < NRQS; i++) {
- if (q1->next != q1) {
- int t_cnt;
-
- printf("[%u]",i);
- for (t_cnt=0, e = q1->next; e != q1; e = e->next) {
- printf("\t0x%08x",e);
- if( (t_cnt = ++t_cnt%4) == 0 )
- printf("\n");
- }
- if( t_cnt )
- printf("\n");
- }
- /* else
- printf("[%u]\t<empty>\n",i);
- */
- q1++;
+sched_stats_handle_csw(processor_t processor, int reasons, int selfpri, int otherpri)
+{
+ struct processor_sched_statistics *stats;
+ boolean_t to_realtime = FALSE;
+
+ stats = &processor->processor_data.sched_stats;
+ stats->csw_count++;
+
+ if (otherpri >= BASEPRI_REALTIME) {
+ stats->rt_sched_count++;
+ to_realtime = TRUE;
}
-}
-void
-checkrq(
- run_queue_t rq,
- char *msg)
-{
- register queue_t q1;
- register int i, j;
- register queue_entry_t e;
- register int highq;
-
- highq = NRQS;
- j = 0;
- q1 = rq->queues;
- for (i = MAXPRI; i >= 0; i--) {
- if (q1->next == q1) {
- if (q1->prev != q1) {
- panic("checkrq: empty at %s", msg);
- }
- }
- else {
- if (highq == -1)
- highq = i;
-
- for (e = q1->next; e != q1; e = e->next) {
- j++;
- if (e->next->prev != e)
- panic("checkrq-2 at %s", msg);
- if (e->prev->next != e)
- panic("checkrq-3 at %s", msg);
+ if ((reasons & AST_PREEMPT) != 0) {
+ stats->preempt_count++;
+
+ if (selfpri >= BASEPRI_REALTIME) {
+ stats->preempted_rt_count++;
+ }
+
+ if (to_realtime) {
+ stats->preempted_by_rt_count++;
}
- }
- q1++;
+
}
- if (j != rq->count)
- panic("checkrq: count wrong at %s", msg);
- if (rq->count != 0 && highq > rq->highq)
- panic("checkrq: highq wrong at %s", msg);
}
void
-thread_check(
- register thread_t thread,
- register run_queue_t rq)
+sched_stats_handle_runq_change(struct runq_stats *stats, int old_count)
{
- register int whichq = thread->sched_pri;
- register queue_entry_t queue, entry;
+ uint64_t timestamp = mach_absolute_time();
- if (whichq < MINPRI || whichq > MAXPRI)
- panic("thread_check: bad pri");
-
- if (whichq != thread->whichq)
- panic("thread_check: whichq");
+ stats->count_sum += (timestamp - stats->last_change_timestamp) * old_count;
+ stats->last_change_timestamp = timestamp;
+}
- queue = &rq->queues[whichq];
- entry = queue_first(queue);
- while (!queue_end(queue, entry)) {
- if (entry == (queue_entry_t)thread)
- return;
+/*
+ * For calls from assembly code
+ */
+#undef thread_wakeup
+void
+thread_wakeup(
+ event_t x);
- entry = queue_next(entry);
- }
+void
+thread_wakeup(
+ event_t x)
+{
+ thread_wakeup_with_result(x, THREAD_AWAKENED);
+}
- panic("thread_check: not found");
+boolean_t
+preemption_enabled(void)
+{
+ return (get_preemption_level() == 0 && ml_get_interrupts_enabled());
}
+#if DEBUG
+static boolean_t
+thread_runnable(
+ thread_t thread)
+{
+ return ((thread->state & (TH_RUN|TH_WAIT)) == TH_RUN);
+}
#endif /* DEBUG */
#if MACH_KDB
#include <ddb/db_output.h>
#define printf kdbprintf
-extern int db_indent;
void db_sched(void);
void
#if MACH_COUNTERS
iprintf("Thread block: calls %d\n",
c_thread_block_calls);
- iprintf("Idle thread:\n\thandoff %d block %d no_dispatch %d\n",
+ iprintf("Idle thread:\n\thandoff %d block %d\n",
c_idle_thread_handoff,
- c_idle_thread_block, no_dispatch_count);
+ c_idle_thread_block);
iprintf("Sched thread blocks: %d\n", c_sched_thread_block);
#endif /* MACH_COUNTERS */
db_indent -= 2;
}
+
+#include <ddb/db_output.h>
+void db_show_thread_log(void);
+
+void
+db_show_thread_log(void)
+{
+}
#endif /* MACH_KDB */
projects / apple / xnu.git / blobdiff