Lines Matching defs:processor

90 #include <kern/processor.h>
177 static inline run_queue_t runq_for_processor(processor_t processor)
180 return &processor->processor_set->pset_runq;
182 return &processor->runq;
186 static inline void runq_consider_incr_bound_count(processor_t processor, thread_t thread)
191 assert(thread->bound_processor == processor);
194 processor->processor_set->pset_runq_bound_count++;
196 processor->runq_bound_count++;
200 static inline void runq_consider_decr_bound_count(processor_t processor, thread_t thread)
205 assert(thread->bound_processor == processor);
208 processor->processor_set->pset_runq_bound_count--;
210 processor->runq_bound_count--;
231 processor_t processor);
236 processor_t processor);
241 processor_t processor);
253 processor_t processor);
258 processor_t processor,
264 processor_t processor,
270 processor_t processor,
273 static boolean_t processor_queue_empty(processor_t processor);
277 static ast_t processor_csw_check(processor_t processor);
279 static boolean_t processor_queue_has_priority(processor_t processor,
283 static boolean_t should_current_thread_rechoose_processor(processor_t processor);
285 static int sched_traditional_processor_runq_count(processor_t processor);
287 static boolean_t sched_traditional_with_pset_runqueue_processor_queue_empty(processor_t processor);
289 static uint64_t sched_traditional_processor_runq_stats_count_sum(processor_t processor);
291 static uint64_t sched_traditional_with_pset_runqueue_processor_runq_stats_count_sum(processor_t processor);
304 sched_traditional_processor_init(processor_t processor);
338 processor_t processor,
670 sched_traditional_processor_init(processor_t processor)
673 run_queue_init(&processor->runq);
675 processor->runq_bound_count = 0;
909 * Signal if idling on another processor.
913 processor_t processor = thread->last_processor;
915 if (processor != current_processor())
916 machine_signal_idle(processor);
1332 processor_t processor = thread->last_processor;
1334 if (processor != PROCESSOR_NULL && processor->active_thread == thread)
1335 cause_ast_check(processor);
1414 processor_t processor = thread->last_processor;
1416 return ((processor != PROCESSOR_NULL) && (processor->active_thread == thread));
1431 processor_t processor;
1449 processor = thread->last_processor;
1450 cause_ast_check(processor);
1593 * Force the current thread to execute on the specified processor.
1602 processor_t processor)
1612 self->bound_processor = processor;
1623 * Select a new thread for the current processor to execute.
1630 processor_t processor)
1632 processor_set_t pset = processor->processor_set;
1636 assert(processor == current_processor());
1645 processor->current_pri = thread->sched_pri;
1646 processor->current_thmode = thread->sched_mode;
1653 inactive_state = processor->state != PROCESSOR_SHUTDOWN && machine_processor_is_inactive(processor);
1659 * to run on this processor. Must be runnable, and not
1660 * bound to a different processor, nor be in the wrong
1661 * processor set.
1665 processor->processor_meta == PROCESSOR_META_NULL ||
1666 processor->processor_meta->primary == processor) &&
1668 thread->bound_processor == processor) &&
1672 first_timeslice(processor) ) {
1678 processor->deadline) {
1688 processor->deadline = thread->realtime.deadline;
1696 (new_thread = SCHED(choose_thread)(processor, thread->sched_mode == TH_MODE_FAIRSHARE ? MINPRI : thread->sched_pri)) == THREAD_NULL) {
1702 pset_pri_hint(pset, processor, processor->current_pri);
1704 pset_count_hint(pset, processor, SCHED(processor_runq_count)(processor));
1706 processor->deadline = UINT64_MAX;
1715 (SCHED(processor_queue_has_priority)(processor, rt_runq.count == 0 ? IDLEPRI : BASEPRI_RTQUEUES, TRUE) &&
1716 (new_thread = SCHED(choose_thread)(processor, MINPRI)) != THREAD_NULL)) {
1720 pset_pri_hint(pset, processor, new_thread->sched_pri);
1722 pset_count_hint(pset, processor, SCHED(processor_runq_count)(processor));
1725 processor->deadline = UINT64_MAX;
1740 processor->deadline = thread->realtime.deadline;
1748 /* No realtime threads and no normal threads on the per-processor
1753 processor->deadline = UINT64_MAX;
1759 processor->deadline = UINT64_MAX;
1762 * Set processor inactive based on
1766 if (processor->state == PROCESSOR_RUNNING)
1767 remqueue((queue_entry_t)processor);
1769 if (processor->state == PROCESSOR_IDLE)
1770 remqueue((queue_entry_t)processor);
1772 processor->state = PROCESSOR_INACTIVE;
1776 return (processor->idle_thread);
1792 if (!SCHED(processor_queue_empty)(processor) || rt_runq.count > 0 || SCHED(fairshare_runq_count)() > 0)
1798 * Nothing is runnable, so set this processor idle if it
1801 if (processor->state == PROCESSOR_RUNNING) {
1802 remqueue((queue_entry_t)processor);
1803 processor->state = PROCESSOR_IDLE;
1805 if (processor->processor_meta == PROCESSOR_META_NULL || processor->processor_meta->primary == processor) {
1806 enqueue_head(&pset->idle_queue, (queue_entry_t)processor);
1807 pset_pri_init_hint(pset, processor);
1808 pset_count_init_hint(pset, processor);
1811 enqueue_head(&processor->processor_meta->idle_queue, (queue_entry_t)processor);
1813 return (processor->idle_thread);
1824 return (processor->idle_thread);
1831 new_thread = thread_select_idle(thread, processor);
1837 * thread can start running on another processor without
1838 * waiting for the fast-idled processor to wake up.
1840 return (processor->idle_thread);
1853 * Idle the processor using the current thread context.
1860 processor_t processor)
1869 processor->current_pri = IDLEPRI;
1870 processor->current_thmode = TH_MODE_NONE;
1878 * Switch execution timing to processor idle thread.
1880 processor->last_dispatch = mach_absolute_time();
1881 thread->last_run_time = processor->last_dispatch;
1882 thread_timer_event(processor->last_dispatch, &processor->idle_thread->system_timer);
1883 PROCESSOR_DATA(processor, kernel_timer) = &processor->idle_thread->system_timer;
1888 timer_call_cancel(&processor->quantum_timer);
1889 processor->timeslice = 0;
1899 spllo(); new_thread = processor_idle(thread, processor);
1930 processor->last_dispatch = mach_absolute_time();
1931 thread_timer_event(processor->last_dispatch, &thread->system_timer);
1932 PROCESSOR_DATA(processor, kernel_timer) = &thread->system_timer;
1935 thread->last_quantum_refill_time = processor->last_dispatch;
1937 processor->quantum_end = processor->last_dispatch + thread->current_quantum;
1938 timer_call_enter1(&processor->quantum_timer, thread, processor->quantum_end, TIMER_CALL_CRITICAL);
1939 processor->timeslice = 1;
1941 thread->computation_epoch = processor->last_dispatch;
1957 processor_t processor,
1962 thread = choose_thread(processor, runq_for_processor(processor), priority);
1964 runq_consider_decr_bound_count(processor, thread);
1977 * Locate a thread to execute from the processor run queue
1986 processor_t processor,
1998 thread->bound_processor == processor) {
2070 processor_t processor;
2117 processor = current_processor();
2118 processor->active_thread = thread;
2119 processor->current_pri = thread->sched_pri;
2120 processor->current_thmode = thread->sched_mode;
2121 if (thread->last_processor != processor && thread->last_processor != NULL) {
2122 if (thread->last_processor->processor_set != processor->processor_set)
2126 thread->last_processor = processor;
2133 processor->last_dispatch = mach_absolute_time();
2134 self->last_run_time = processor->last_dispatch;
2135 thread_timer_event(processor->last_dispatch, &thread->system_timer);
2136 PROCESSOR_DATA(processor, kernel_timer) = &thread->system_timer;
2143 timer_switch(PROCESSOR_DATA(processor, current_state),
2144 processor->last_dispatch,
2145 PROCESSOR_DATA(processor, current_state));
2152 if ((thread->chosen_processor != processor) && (thread->chosen_processor != NULL)) {
2159 SCHED_STATS_CSW(processor, self->reason, self->sched_pri, thread->sched_pri);
2227 processor = current_processor();
2228 processor->active_thread = thread;
2229 processor->current_pri = thread->sched_pri;
2230 processor->current_thmode = thread->sched_mode;
2231 if (thread->last_processor != processor && thread->last_processor != NULL) {
2232 if (thread->last_processor->processor_set != processor->processor_set)
2236 thread->last_processor = processor;
2246 processor->last_dispatch = mach_absolute_time();
2247 self->last_run_time = processor->last_dispatch;
2248 thread_timer_event(processor->last_dispatch, &thread->system_timer);
2249 PROCESSOR_DATA(processor, kernel_timer) = &thread->system_timer;
2256 timer_switch(PROCESSOR_DATA(processor, current_state),
2257 processor->last_dispatch,
2258 PROCESSOR_DATA(processor, current_state));
2266 if ((thread->chosen_processor != processor) && (thread->chosen_processor != NULL)) {
2273 SCHED_STATS_CSW(processor, self->reason, self->sched_pri, thread->sched_pri);
2320 processor_t processor = self->last_processor;
2334 if (processor->quantum_end > processor->last_dispatch)
2335 remainder = processor->quantum_end -
2336 processor->last_dispatch;
2356 if (first_timeslice(processor) &&
2357 processor->quantum_end > processor->last_dispatch)
2395 thread->computation_metered += (processor->last_dispatch - thread->computation_epoch);
2479 self->last_quantum_refill_time = processor->last_dispatch;
2485 processor->quantum_end = (processor->last_dispatch + self->current_quantum);
2486 timer_call_enter1(&processor->quantum_timer, self, processor->quantum_end, TIMER_CALL_CRITICAL);
2488 processor->timeslice = 1;
2490 self->computation_epoch = processor->last_dispatch;
2493 timer_call_cancel(&processor->quantum_timer);
2494 processor->timeslice = 0;
2525 register processor_t processor;
2536 processor = current_processor();
2540 processor->timeslice = 0;
2556 new_thread = thread_select(self, processor);
2611 processor_t processor = current_processor();
2614 new_thread = thread_select(self, processor);
2915 processor_t processor,
2918 processor_set_t pset = processor->processor_set;
2920 thread->chosen_processor = processor;
2924 if (processor != current_processor())
2925 machine_signal_idle(processor);
2988 processor_t processor,
2991 processor_set_t pset = processor->processor_set;
2993 thread->chosen_processor = processor;
2996 * Dispatch directly onto idle processor.
2998 if ( (thread->bound_processor == processor)
2999 && processor->state == PROCESSOR_IDLE) {
3000 remqueue((queue_entry_t)processor);
3001 enqueue_tail(&pset->active_queue, (queue_entry_t)processor);
3003 processor->next_thread = thread;
3004 processor->deadline = thread->realtime.deadline;
3005 processor->state = PROCESSOR_DISPATCHING;
3008 if (processor != current_processor())
3009 machine_signal_idle(processor);
3014 int prstate = processor->state;
3015 if (processor == current_processor())
3018 machine_signal_idle(processor);
3020 cause_ast_check(processor);
3037 * Enqueue thread on a processor run queue. Thread must be locked,
3048 processor_t processor,
3052 run_queue_t rq = runq_for_processor(processor);
3056 thread->runq = processor;
3057 runq_consider_incr_bound_count(processor, thread);
3068 * processor.
3075 processor_t processor,
3079 processor_set_t pset = processor->processor_set;
3082 thread->chosen_processor = processor;
3085 * Dispatch directly onto idle processor.
3088 thread->bound_processor == processor)
3089 && processor->state == PROCESSOR_IDLE) {
3090 remqueue((queue_entry_t)processor);
3091 enqueue_tail(&pset->active_queue, (queue_entry_t)processor);
3093 processor->next_thread = thread;
3094 processor->deadline = UINT64_MAX;
3095 processor->state = PROCESSOR_DISPATCHING;
3098 if (processor != current_processor())
3099 machine_signal_idle(processor);
3106 if (SCHED(priority_is_urgent)(thread->sched_pri) && thread->sched_pri > processor->current_pri)
3108 else if(processor->active_thread && thread_eager_preemption(processor->active_thread))
3116 if (!SCHED(processor_enqueue)(processor, thread, options))
3120 if (processor == current_processor()) {
3121 if (csw_check(processor) != AST_NONE)
3125 if ( processor->state == PROCESSOR_IDLE || processor->state == PROCESSOR_DISPATCHING) {
3126 machine_signal_idle(processor);
3129 if ( (processor->state == PROCESSOR_RUNNING ||
3130 processor->state == PROCESSOR_SHUTDOWN) &&
3131 (thread->sched_pri >= processor->current_pri ||
3132 processor->current_thmode == TH_MODE_FAIRSHARE)) {
3133 cause_ast_check(processor);
3137 if ( processor->state == PROCESSOR_SHUTDOWN &&
3138 thread->sched_pri >= processor->current_pri ) {
3139 cause_ast_check(processor);
3142 if ( processor->state == PROCESSOR_IDLE &&
3143 processor != current_processor() ) {
3144 machine_signal_idle(processor);
3153 processor_queue_empty(processor_t processor)
3155 return runq_for_processor(processor)->count == 0;
3160 sched_traditional_with_pset_runqueue_processor_queue_empty(processor_t processor)
3162 processor_set_t pset = processor->processor_set;
3163 int count = runq_for_processor(processor)->count;
3168 * are bound to another processor, the current "processor"
3171 * "processor". This allows the processor to idle when the
3173 * a runnable thread bound to a different processor in the
3178 count += processor->runq_bound_count;
3184 processor_csw_check(processor_t processor)
3189 assert(processor->active_thread != NULL);
3191 runq = runq_for_processor(processor);
3192 if (first_timeslice(processor)) {
3193 has_higher = (runq->highq > processor->current_pri);
3195 has_higher = (runq->highq >= processor->current_pri);
3201 if (processor->active_thread && thread_eager_preemption(processor->active_thread))
3211 processor_queue_has_priority(processor_t processor,
3216 return runq_for_processor(processor)->highq >= priority;
3218 return runq_for_processor(processor)->highq > priority;
3222 should_current_thread_rechoose_processor(processor_t processor)
3224 return (processor->current_pri < BASEPRI_RTQUEUES
3225 && processor->processor_meta != PROCESSOR_META_NULL
3226 && processor->processor_meta->primary != processor);
3230 sched_traditional_processor_runq_count(processor_t processor)
3232 return runq_for_processor(processor)->count;
3237 sched_traditional_processor_runq_stats_count_sum(processor_t processor)
3239 return runq_for_processor(processor)->runq_stats.count_sum;
3243 sched_traditional_with_pset_runqueue_processor_runq_stats_count_sum(processor_t processor)
3245 if (processor->cpu_id == processor->processor_set->cpu_set_low)
3246 return runq_for_processor(processor)->runq_stats.count_sum;
3280 * Choose a processor for the thread, beginning at
3281 * the pset. Accepts an optional processor hint in
3284 * Returns a processor, possibly from a different pset.
3292 processor_t processor,
3300 * Prefer the hinted processor, when appropriate.
3303 if (processor != PROCESSOR_NULL) {
3304 if (processor->processor_meta != PROCESSOR_META_NULL)
3305 processor = processor->processor_meta->primary;
3308 mprocessor = machine_choose_processor(pset, processor);
3310 processor = mprocessor;
3312 if (processor != PROCESSOR_NULL) {
3313 if (processor->processor_set != pset ||
3314 processor->state == PROCESSOR_INACTIVE ||
3315 processor->state == PROCESSOR_SHUTDOWN ||
3316 processor->state == PROCESSOR_OFF_LINE)
3317 processor = PROCESSOR_NULL;
3319 if (processor->state == PROCESSOR_IDLE ||
3321 (processor->current_pri < BASEPRI_RTQUEUES)))
3322 return (processor);
3326 * Iterate through the processor sets to locate
3327 * an appropriate processor.
3331 * Choose an idle processor.
3345 /* Consider hinted processor */
3356 processor = (processor_t)queue_first(&cset->active_queue);
3357 while (!queue_end(&cset->active_queue, (queue_entry_t)processor)) {
3358 /* Discover the processor executing the
3363 integer_t cpri = processor->current_pri;
3366 lp_processor = processor;
3369 if ((cpri >= BASEPRI_RTQUEUES) && (processor->deadline > furthest_deadline)) {
3370 furthest_deadline = processor->deadline;
3371 fd_processor = processor;
3375 if (processor->processor_meta != PROCESSOR_META_NULL &&
3376 !queue_empty(&processor->processor_meta->idle_queue)) {
3379 lp_unpaired = processor;
3380 pmeta = processor->processor_meta;
3384 pmeta = processor->processor_meta;
3386 processor = (processor_t)queue_next((queue_entry_t)processor);
3399 processor = PROCESSOR_NULL;
3403 * Check any hinted processors in the processor set if available.
3407 (processor == PROCESSOR_NULL ||
3409 processor = cset->low_pri;
3414 (processor == PROCESSOR_NULL || (thread->sched_pri <= BASEPRI_DEFAULT &&
3415 SCHED(processor_runq_count)(cset->low_count) < SCHED(processor_runq_count)(processor)))) {
3416 processor = cset->low_count;
3420 * Otherwise, choose an available processor in the set.
3422 if (processor == PROCESSOR_NULL) {
3423 processor = (processor_t)dequeue_head(&cset->active_queue);
3424 if (processor != PROCESSOR_NULL)
3425 enqueue_tail(&cset->active_queue, (queue_entry_t)processor);
3428 if (processor != PROCESSOR_NULL && pmeta == PROCESSOR_META_NULL) {
3429 if (processor->processor_meta != PROCESSOR_META_NULL &&
3430 !queue_empty(&processor->processor_meta->idle_queue))
3431 pmeta = processor->processor_meta;
3436 * Move onto the next processor set.
3449 * Make sure that we pick a running processor,
3450 * and that the correct processor set is locked.
3468 * If we haven't been able to choose a processor,
3469 * pick the boot processor and return it.
3471 if (processor == PROCESSOR_NULL) {
3472 processor = master_processor;
3475 * Check that the correct processor set is
3478 if (cset != processor->processor_set) {
3481 cset = processor->processor_set;
3485 return (processor);
3489 * Check that the processor set for the chosen
3490 * processor is locked.
3492 if (cset != processor->processor_set) {
3495 cset = processor->processor_set;
3500 * We must verify that the chosen processor is still available.
3502 if (processor->state == PROCESSOR_INACTIVE ||
3503 processor->state == PROCESSOR_SHUTDOWN || processor->state == PROCESSOR_OFF_LINE)
3504 processor = PROCESSOR_NULL;
3505 } while (processor == PROCESSOR_NULL);
3507 return (processor);
3514 * processor or run queue, and signal a preemption
3524 processor_t processor;
3550 processor = SCHED(choose_processor)(pset, PROCESSOR_NULL, thread);
3555 * Simple (last processor) affinity case.
3557 processor = thread->last_processor;
3558 pset = processor->processor_set;
3560 processor = SCHED(choose_processor)(pset, processor, thread);
3562 if ((thread->last_processor != processor) && (thread->last_processor != PROCESSOR_NULL)) {
3564 (uintptr_t)thread_tid(thread), (uintptr_t)thread->last_processor->cpu_id, (uintptr_t)processor->cpu_id, thread->last_processor->state, 0);
3573 * among the available processor sets.
3584 processor = SCHED(choose_processor)(pset, PROCESSOR_NULL, thread);
3585 task->pset_hint = processor->processor_set;
3592 * Unconditionally dispatch on the processor.
3594 processor = thread->bound_processor;
3595 pset = processor->processor_set;
3600 * Dispatch the thread on the choosen processor.
3603 realtime_setrun(processor, thread);
3605 fairshare_setrun(processor, thread);
3607 processor_setrun(processor, thread, options);
3627 * Shutdown a processor run queue by
3635 processor_t processor)
3637 processor_set_t pset = processor->processor_set;
3638 run_queue_t rq = runq_for_processor(processor);
3656 runq_consider_decr_bound_count(processor, thread);
3698 processor_t processor)
3703 thread_t thread = processor->active_thread;
3705 if (first_timeslice(processor)) {
3710 if (rt_runq.count > 0 && BASEPRI_RTQUEUES >= processor->current_pri)
3714 result = SCHED(processor_csw_check)(processor);
3718 if (SCHED(should_current_thread_rechoose_processor)(processor))
3721 if (machine_processor_is_inactive(processor))
3751 processor_t processor = thread->last_processor;
3756 processor->current_pri = priority;
3757 processor->current_thmode = thread->sched_mode;
3758 if ((preempt = csw_check(processor)) != AST_NONE)
3762 if ( processor != PROCESSOR_NULL &&
3763 processor->active_thread == thread )
3764 cause_ast_check(processor);
3804 processor_t processor,
3810 rqlock = &processor->processor_set->sched_lock;
3811 rq = runq_for_processor(processor);
3814 if (processor == thread->runq) {
3819 runq_consider_decr_bound_count(processor, thread);
3828 processor = PROCESSOR_NULL;
3833 return (processor != PROCESSOR_NULL);
3850 processor_t processor = thread->runq;
3853 * If processor is PROCESSOR_NULL, the thread will stay out of the
3858 if (processor != PROCESSOR_NULL) {
3862 * The processor run queues are locked by the
3863 * processor set. Real-time priorities use a
3871 return SCHED(processor_queue_remove)(processor, thread);
3877 if (processor == thread->runq) {
3894 processor = PROCESSOR_NULL;
3900 return (processor != PROCESSOR_NULL);
3908 * Locate a thread to steal from the processor and
3916 processor_t processor)
3918 run_queue_t rq = runq_for_processor(processor);
3931 runq_consider_decr_bound_count(processor, thread);
3970 processor_t processor;
3974 processor = (processor_t)queue_first(&cset->active_queue);
3975 while (!queue_end(&cset->active_queue, (queue_entry_t)processor)) {
3976 if (runq_for_processor(processor)->count > 0) {
3977 thread = steal_processor_thread(processor);
3979 remqueue((queue_entry_t)processor);
3980 enqueue_tail(&cset->active_queue, (queue_entry_t)processor);
3988 processor = (processor_t)queue_next((queue_entry_t)processor);
4020 processor_t processor;
4023 processor = current_processor();
4025 thread = processor->next_thread;
4056 * This is the processor idle loop, which just looks for other threads
4072 processor_t processor)
4074 processor_set_t pset = processor->processor_set;
4083 SCHED_STATS_CPU_IDLE_START(processor);
4085 timer_switch(&PROCESSOR_DATA(processor, system_state),
4086 mach_absolute_time(), &PROCESSOR_DATA(processor, idle_state));
4087 PROCESSOR_DATA(processor, current_state) = &PROCESSOR_DATA(processor, idle_state);
4089 while (processor->next_thread == THREAD_NULL && SCHED(processor_queue_empty)(processor) && rt_runq.count == 0 && SCHED(fairshare_runq_count)() == 0 &&
4092 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);
4103 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);
4105 if (processor->state == PROCESSOR_INACTIVE && !machine_processor_is_inactive(processor))
4109 timer_switch(&PROCESSOR_DATA(processor, idle_state),
4110 mach_absolute_time(), &PROCESSOR_DATA(processor, system_state));
4111 PROCESSOR_DATA(processor, current_state) = &PROCESSOR_DATA(processor, system_state);
4115 state = processor->state;
4120 new_thread = processor->next_thread;
4121 processor->next_thread = THREAD_NULL;
4122 processor->state = PROCESSOR_RUNNING;
4124 if (SCHED(processor_queue_has_priority)(processor, new_thread->sched_pri, FALSE) ||
4126 processor->deadline = UINT64_MAX;
4152 remqueue((queue_entry_t)processor);
4154 processor->state = PROCESSOR_RUNNING;
4155 enqueue_tail(&pset->active_queue, (queue_entry_t)processor);
4159 processor->state = PROCESSOR_RUNNING;
4160 enqueue_tail(&pset->active_queue, (queue_entry_t)processor);
4168 if ((new_thread = processor->next_thread) != THREAD_NULL) {
4169 processor->next_thread = THREAD_NULL;
4170 processor->deadline = UINT64_MAX;
4196 * Each processor has a dedicated thread which
4203 processor_t processor = current_processor();
4206 new_thread = processor_idle(THREAD_NULL, processor);
4208 thread_run(processor->idle_thread, (thread_continue_t)idle_thread, NULL, new_thread);
4218 processor_t processor)
4230 thread->bound_processor = processor;
4231 processor->idle_thread = thread;
4388 processor_t processor = processor_list;
4395 pset = processor->processor_set;
4400 restart_needed = runq_scan(runq_for_processor(processor));
4408 thread = processor->idle_thread;
4418 } while ((processor = processor->processor_list) != NULL);
4500 sched_stats_handle_csw(processor_t processor, int reasons, int selfpri, int otherpri)
4505 stats = &processor->processor_data.sched_stats;