2 * Copyright (c) 1999 Peter Wemm <peter@FreeBSD.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * $DragonFly: src/sys/kern/usched_bsd4.c,v 1.26 2008/11/01 23:31:19 dillon Exp $
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/kernel.h>
33 #include <sys/queue.h>
35 #include <sys/rtprio.h>
37 #include <sys/sysctl.h>
38 #include <sys/resourcevar.h>
39 #include <sys/spinlock.h>
40 #include <machine/cpu.h>
41 #include <machine/smp.h>
43 #include <sys/thread2.h>
44 #include <sys/spinlock2.h>
47 * Priorities. Note that with 32 run queues per scheduler each queue
48 * represents four priority levels.
52 #define PRIMASK (MAXPRI - 1)
53 #define PRIBASE_REALTIME 0
54 #define PRIBASE_NORMAL MAXPRI
55 #define PRIBASE_IDLE (MAXPRI * 2)
56 #define PRIBASE_THREAD (MAXPRI * 3)
57 #define PRIBASE_NULL (MAXPRI * 4)
59 #define NQS 32 /* 32 run queues. */
60 #define PPQ (MAXPRI / NQS) /* priorities per queue */
61 #define PPQMASK (PPQ - 1)
64 * NICEPPQ - number of nice units per priority queue
65 * ESTCPURAMP - number of scheduler ticks for estcpu to switch queues
67 * ESTCPUPPQ - number of estcpu units per priority queue
68 * ESTCPUMAX - number of estcpu units
69 * ESTCPUINCR - amount we have to increment p_estcpu per scheduling tick at
75 #define ESTCPUMAX (ESTCPUPPQ * NQS)
76 #define ESTCPUINCR (ESTCPUPPQ / ESTCPURAMP)
77 #define PRIO_RANGE (PRIO_MAX - PRIO_MIN + 1)
79 #define ESTCPULIM(v) min((v), ESTCPUMAX)
83 #define lwp_priority lwp_usdata.bsd4.priority
84 #define lwp_rqindex lwp_usdata.bsd4.rqindex
85 #define lwp_origcpu lwp_usdata.bsd4.origcpu
86 #define lwp_estcpu lwp_usdata.bsd4.estcpu
87 #define lwp_rqtype lwp_usdata.bsd4.rqtype
89 static void bsd4_acquire_curproc(struct lwp *lp);
90 static void bsd4_release_curproc(struct lwp *lp);
91 static void bsd4_select_curproc(globaldata_t gd);
92 static void bsd4_setrunqueue(struct lwp *lp);
93 static void bsd4_schedulerclock(struct lwp *lp, sysclock_t period,
95 static void bsd4_recalculate_estcpu(struct lwp *lp);
96 static void bsd4_resetpriority(struct lwp *lp);
97 static void bsd4_forking(struct lwp *plp, struct lwp *lp);
98 static void bsd4_exiting(struct lwp *plp, struct lwp *lp);
99 static void bsd4_yield(struct lwp *lp);
102 static void need_user_resched_remote(void *dummy);
104 static struct lwp *chooseproc_locked(struct lwp *chklp);
105 static void bsd4_remrunqueue_locked(struct lwp *lp);
106 static void bsd4_setrunqueue_locked(struct lwp *lp);
108 struct usched usched_bsd4 = {
110 "bsd4", "Original DragonFly Scheduler",
111 NULL, /* default registration */
112 NULL, /* default deregistration */
113 bsd4_acquire_curproc,
114 bsd4_release_curproc,
117 bsd4_recalculate_estcpu,
121 NULL, /* setcpumask not supported */
125 struct usched_bsd4_pcpu {
126 struct thread helper_thread;
129 struct lwp *uschedcp;
132 typedef struct usched_bsd4_pcpu *bsd4_pcpu_t;
135 * We have NQS (32) run queues per scheduling class. For the normal
136 * class, there are 128 priorities scaled onto these 32 queues. New
137 * processes are added to the last entry in each queue, and processes
138 * are selected for running by taking them from the head and maintaining
139 * a simple FIFO arrangement. Realtime and Idle priority processes have
140 * and explicit 0-31 priority which maps directly onto their class queue
141 * index. When a queue has something in it, the corresponding bit is
142 * set in the queuebits variable, allowing a single read to determine
143 * the state of all 32 queues and then a ffs() to find the first busy
146 static struct rq bsd4_queues[NQS];
147 static struct rq bsd4_rtqueues[NQS];
148 static struct rq bsd4_idqueues[NQS];
149 static u_int32_t bsd4_queuebits;
150 static u_int32_t bsd4_rtqueuebits;
151 static u_int32_t bsd4_idqueuebits;
152 static cpumask_t bsd4_curprocmask = -1; /* currently running a user process */
153 static cpumask_t bsd4_rdyprocmask; /* ready to accept a user process */
154 static int bsd4_runqcount;
156 static volatile int bsd4_scancpu;
158 static struct spinlock bsd4_spin;
159 static struct usched_bsd4_pcpu bsd4_pcpu[MAXCPU];
161 SYSCTL_INT(_debug, OID_AUTO, bsd4_runqcount, CTLFLAG_RD, &bsd4_runqcount, 0, "");
163 static int usched_nonoptimal;
164 SYSCTL_INT(_debug, OID_AUTO, usched_nonoptimal, CTLFLAG_RW,
165 &usched_nonoptimal, 0, "acquire_curproc() was not optimal");
166 static int usched_optimal;
167 SYSCTL_INT(_debug, OID_AUTO, usched_optimal, CTLFLAG_RW,
168 &usched_optimal, 0, "acquire_curproc() was optimal");
170 static int usched_debug = -1;
171 SYSCTL_INT(_debug, OID_AUTO, scdebug, CTLFLAG_RW, &usched_debug, 0, "");
173 static int remote_resched_nonaffinity;
174 static int remote_resched_affinity;
175 static int choose_affinity;
176 SYSCTL_INT(_debug, OID_AUTO, remote_resched_nonaffinity, CTLFLAG_RD,
177 &remote_resched_nonaffinity, 0, "Number of remote rescheds");
178 SYSCTL_INT(_debug, OID_AUTO, remote_resched_affinity, CTLFLAG_RD,
179 &remote_resched_affinity, 0, "Number of remote rescheds");
180 SYSCTL_INT(_debug, OID_AUTO, choose_affinity, CTLFLAG_RD,
181 &choose_affinity, 0, "chooseproc() was smart");
184 static int usched_bsd4_rrinterval = (ESTCPUFREQ + 9) / 10;
185 SYSCTL_INT(_kern, OID_AUTO, usched_bsd4_rrinterval, CTLFLAG_RW,
186 &usched_bsd4_rrinterval, 0, "");
187 static int usched_bsd4_decay = ESTCPUINCR / 2;
188 SYSCTL_INT(_kern, OID_AUTO, usched_bsd4_decay, CTLFLAG_RW,
189 &usched_bsd4_decay, 0, "");
192 * Initialize the run queues at boot time.
199 spin_init(&bsd4_spin);
200 for (i = 0; i < NQS; i++) {
201 TAILQ_INIT(&bsd4_queues[i]);
202 TAILQ_INIT(&bsd4_rtqueues[i]);
203 TAILQ_INIT(&bsd4_idqueues[i]);
205 atomic_clear_int(&bsd4_curprocmask, 1);
207 SYSINIT(runqueue, SI_BOOT2_USCHED, SI_ORDER_FIRST, rqinit, NULL)
210 * BSD4_ACQUIRE_CURPROC
212 * This function is called when the kernel intends to return to userland.
213 * It is responsible for making the thread the current designated userland
214 * thread for this cpu, blocking if necessary.
216 * The kernel has already depressed our LWKT priority so we must not switch
217 * until we have either assigned or disposed of the thread.
219 * WARNING! THIS FUNCTION IS ALLOWED TO CAUSE THE CURRENT THREAD TO MIGRATE
220 * TO ANOTHER CPU! Because most of the kernel assumes that no migration will
221 * occur, this function is called only under very controlled circumstances.
226 bsd4_acquire_curproc(struct lwp *lp)
233 bsd4_recalculate_estcpu(lp);
236 * If a reschedule was requested give another thread the
239 if (user_resched_wanted()) {
240 clear_user_resched();
241 bsd4_release_curproc(lp);
245 * Loop until we are the current user thread
249 * Reload after a switch or setrunqueue/switch possibly
250 * moved us to another cpu.
252 clear_lwkt_resched();
254 dd = &bsd4_pcpu[gd->gd_cpuid];
257 * Become the currently scheduled user thread for this cpu
258 * if we can do so trivially.
260 * We can steal another thread's current thread designation
261 * on this cpu since if we are running that other thread
262 * must not be, so we can safely deschedule it.
264 if (dd->uschedcp == lp) {
265 dd->upri = lp->lwp_priority;
266 } else if (dd->uschedcp == NULL) {
267 atomic_set_int(&bsd4_curprocmask, gd->gd_cpumask);
269 dd->upri = lp->lwp_priority;
270 } else if (dd->upri > lp->lwp_priority) {
273 dd->upri = lp->lwp_priority;
274 lwkt_deschedule(olp->lwp_thread);
275 bsd4_setrunqueue(olp);
277 lwkt_deschedule(lp->lwp_thread);
278 bsd4_setrunqueue(lp);
283 * Other threads at our current user priority have already
284 * put in their bids, but we must run any kernel threads
285 * at higher priorities, and we could lose our bid to
286 * another thread trying to return to user mode in the
289 * If we lose our bid we will be descheduled and put on
290 * the run queue. When we are reactivated we will have
293 if (lwkt_check_resched(lp->lwp_thread) > 1) {
297 } while (dd->uschedcp != lp);
300 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
304 * BSD4_RELEASE_CURPROC
306 * This routine detaches the current thread from the userland scheduler,
307 * usually because the thread needs to run or block in the kernel (at
308 * kernel priority) for a while.
310 * This routine is also responsible for selecting a new thread to
311 * make the current thread.
313 * NOTE: This implementation differs from the dummy example in that
314 * bsd4_select_curproc() is able to select the current process, whereas
315 * dummy_select_curproc() is not able to select the current process.
316 * This means we have to NULL out uschedcp.
318 * Additionally, note that we may already be on a run queue if releasing
319 * via the lwkt_switch() in bsd4_setrunqueue().
321 * WARNING! The MP lock may be in an unsynchronized state due to the
322 * way get_mplock() works and the fact that this function may be called
323 * from a passive release during a lwkt_switch(). try_mplock() will deal
324 * with this for us but you should be aware that td_mpcount may not be
330 bsd4_release_curproc(struct lwp *lp)
332 globaldata_t gd = mycpu;
333 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
335 if (dd->uschedcp == lp) {
337 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
338 dd->uschedcp = NULL; /* don't let lp be selected */
339 dd->upri = PRIBASE_NULL;
340 atomic_clear_int(&bsd4_curprocmask, gd->gd_cpumask);
341 bsd4_select_curproc(gd);
347 * BSD4_SELECT_CURPROC
349 * Select a new current process for this cpu and clear any pending user
350 * reschedule request. The cpu currently has no current process.
352 * This routine is also responsible for equal-priority round-robining,
353 * typically triggered from bsd4_schedulerclock(). In our dummy example
354 * all the 'user' threads are LWKT scheduled all at once and we just
355 * call lwkt_switch().
357 * The calling process is not on the queue and cannot be selected.
363 bsd4_select_curproc(globaldata_t gd)
365 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
367 int cpuid = gd->gd_cpuid;
371 spin_lock_wr(&bsd4_spin);
372 if ((nlp = chooseproc_locked(dd->uschedcp)) != NULL) {
373 atomic_set_int(&bsd4_curprocmask, 1 << cpuid);
374 dd->upri = nlp->lwp_priority;
376 spin_unlock_wr(&bsd4_spin);
378 lwkt_acquire(nlp->lwp_thread);
380 lwkt_schedule(nlp->lwp_thread);
381 } else if (bsd4_runqcount && (bsd4_rdyprocmask & (1 << cpuid))) {
382 atomic_clear_int(&bsd4_rdyprocmask, 1 << cpuid);
383 spin_unlock_wr(&bsd4_spin);
384 lwkt_schedule(&dd->helper_thread);
386 spin_unlock_wr(&bsd4_spin);
394 * Place the specified lwp on the user scheduler's run queue. This routine
395 * must be called with the thread descheduled. The lwp must be runnable.
397 * The thread may be the current thread as a special case.
402 bsd4_setrunqueue(struct lwp *lp)
413 * First validate the process state relative to the current cpu.
414 * We don't need the spinlock for this, just a critical section.
415 * We are in control of the process.
418 KASSERT(lp->lwp_stat == LSRUN, ("setrunqueue: lwp not LSRUN"));
419 KASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0,
420 ("lwp %d/%d already on runq! flag %08x/%08x", lp->lwp_proc->p_pid,
421 lp->lwp_tid, lp->lwp_proc->p_flag, lp->lwp_flag));
422 KKASSERT((lp->lwp_thread->td_flags & TDF_RUNQ) == 0);
425 * Note: gd and dd are relative to the target thread's last cpu,
426 * NOT our current cpu.
428 gd = lp->lwp_thread->td_gd;
429 dd = &bsd4_pcpu[gd->gd_cpuid];
432 * This process is not supposed to be scheduled anywhere or assigned
433 * as the current process anywhere. Assert the condition.
435 KKASSERT(dd->uschedcp != lp);
439 * If we are not SMP we do not have a scheduler helper to kick
440 * and must directly activate the process if none are scheduled.
442 * This is really only an issue when bootstrapping init since
443 * the caller in all other cases will be a user process, and
444 * even if released (dd->uschedcp == NULL), that process will
445 * kickstart the scheduler when it returns to user mode from
448 if (dd->uschedcp == NULL) {
449 atomic_set_int(&bsd4_curprocmask, gd->gd_cpumask);
451 dd->upri = lp->lwp_priority;
452 lwkt_schedule(lp->lwp_thread);
460 * XXX fixme. Could be part of a remrunqueue/setrunqueue
461 * operation when the priority is recalculated, so TDF_MIGRATING
462 * may already be set.
464 if ((lp->lwp_thread->td_flags & TDF_MIGRATING) == 0)
465 lwkt_giveaway(lp->lwp_thread);
469 * We lose control of lp the moment we release the spinlock after
470 * having placed lp on the queue. i.e. another cpu could pick it
471 * up and it could exit, or its priority could be further adjusted,
472 * or something like that.
474 spin_lock_wr(&bsd4_spin);
475 bsd4_setrunqueue_locked(lp);
479 * Kick the scheduler helper on one of the other cpu's
480 * and request a reschedule if appropriate.
482 cpuid = (bsd4_scancpu & 0xFFFF) % ncpus;
484 mask = ~bsd4_curprocmask & bsd4_rdyprocmask &
485 lp->lwp_cpumask & smp_active_mask;
486 spin_unlock_wr(&bsd4_spin);
489 tmpmask = ~((1 << cpuid) - 1);
491 cpuid = bsfl(mask & tmpmask);
494 gd = globaldata_find(cpuid);
495 dd = &bsd4_pcpu[cpuid];
497 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK)) {
499 need_user_resched_remote(NULL);
501 lwkt_send_ipiq(gd, need_user_resched_remote, NULL);
504 mask &= ~(1 << cpuid);
508 * Request a reschedule if appropriate.
510 spin_unlock_wr(&bsd4_spin);
511 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK)) {
519 * This routine is called from a systimer IPI. It MUST be MP-safe and
520 * the BGL IS NOT HELD ON ENTRY. This routine is called at ESTCPUFREQ on
523 * Because this is effectively a 'fast' interrupt, we cannot safely
524 * use spinlocks unless gd_spinlock_rd is NULL and gd_spinlocks_wr is 0,
525 * even if the spinlocks are 'non conflicting'. This is due to the way
526 * spinlock conflicts against cached read locks are handled.
532 bsd4_schedulerclock(struct lwp *lp, sysclock_t period, sysclock_t cpstamp)
534 globaldata_t gd = mycpu;
535 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
538 * Do we need to round-robin? We round-robin 10 times a second.
539 * This should only occur for cpu-bound batch processes.
541 if (++dd->rrcount >= usched_bsd4_rrinterval) {
547 * As the process accumulates cpu time p_estcpu is bumped and may
548 * push the process into another scheduling queue. It typically
549 * takes 4 ticks to bump the queue.
551 lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR);
554 * Reducing p_origcpu over time causes more of our estcpu to be
555 * returned to the parent when we exit. This is a small tweak
556 * for the batch detection heuristic.
562 * We can only safely call bsd4_resetpriority(), which uses spinlocks,
563 * if we aren't interrupting a thread that is using spinlocks.
564 * Otherwise we can deadlock with another cpu waiting for our read
565 * spinlocks to clear.
567 if (gd->gd_spinlock_rd == NULL && gd->gd_spinlocks_wr == 0)
568 bsd4_resetpriority(lp);
574 * Called from acquire and from kern_synch's one-second timer (one of the
575 * callout helper threads) with a critical section held.
577 * Decay p_estcpu based on the number of ticks we haven't been running
578 * and our p_nice. As the load increases each process observes a larger
579 * number of idle ticks (because other processes are running in them).
580 * This observation leads to a larger correction which tends to make the
581 * system more 'batchy'.
583 * Note that no recalculation occurs for a process which sleeps and wakes
584 * up in the same tick. That is, a system doing thousands of context
585 * switches per second will still only do serious estcpu calculations
586 * ESTCPUFREQ times per second.
592 bsd4_recalculate_estcpu(struct lwp *lp)
594 globaldata_t gd = mycpu;
602 * We have to subtract periodic to get the last schedclock
603 * timeout time, otherwise we would get the upcoming timeout.
604 * Keep in mind that a process can migrate between cpus and
605 * while the scheduler clock should be very close, boundary
606 * conditions could lead to a small negative delta.
608 cpbase = gd->gd_schedclock.time - gd->gd_schedclock.periodic;
610 if (lp->lwp_slptime > 1) {
612 * Too much time has passed, do a coarse correction.
614 lp->lwp_estcpu = lp->lwp_estcpu >> 1;
615 bsd4_resetpriority(lp);
616 lp->lwp_cpbase = cpbase;
618 } else if (lp->lwp_cpbase != cpbase) {
620 * Adjust estcpu if we are in a different tick. Don't waste
621 * time if we are in the same tick.
623 * First calculate the number of ticks in the measurement
624 * interval. The nticks calculation can wind up 0 due to
625 * a bug in the handling of lwp_slptime (as yet not found),
626 * so make sure we do not get a divide by 0 panic.
628 nticks = (cpbase - lp->lwp_cpbase) / gd->gd_schedclock.periodic;
631 updatepcpu(lp, lp->lwp_cpticks, nticks);
633 if ((nleft = nticks - lp->lwp_cpticks) < 0)
635 if (usched_debug == lp->lwp_proc->p_pid) {
636 kprintf("pid %d tid %d estcpu %d cpticks %d nticks %d nleft %d",
637 lp->lwp_proc->p_pid, lp->lwp_tid, lp->lwp_estcpu,
638 lp->lwp_cpticks, nticks, nleft);
642 * Calculate a decay value based on ticks remaining scaled
643 * down by the instantanious load and p_nice.
645 if ((loadfac = bsd4_runqcount) < 2)
647 ndecay = nleft * usched_bsd4_decay * 2 *
648 (PRIO_MAX * 2 - lp->lwp_proc->p_nice) / (loadfac * PRIO_MAX * 2);
651 * Adjust p_estcpu. Handle a border case where batch jobs
652 * can get stalled long enough to decay to zero when they
655 if (lp->lwp_estcpu > ndecay * 2)
656 lp->lwp_estcpu -= ndecay;
658 lp->lwp_estcpu >>= 1;
660 if (usched_debug == lp->lwp_proc->p_pid)
661 kprintf(" ndecay %d estcpu %d\n", ndecay, lp->lwp_estcpu);
662 bsd4_resetpriority(lp);
663 lp->lwp_cpbase = cpbase;
669 * Compute the priority of a process when running in user mode.
670 * Arrange to reschedule if the resulting priority is better
671 * than that of the current process.
673 * This routine may be called with any process.
675 * This routine is called by fork1() for initial setup with the process
676 * of the run queue, and also may be called normally with the process on or
682 bsd4_resetpriority(struct lwp *lp)
690 * Calculate the new priority and queue type
693 spin_lock_wr(&bsd4_spin);
695 newrqtype = lp->lwp_rtprio.type;
698 case RTP_PRIO_REALTIME:
700 newpriority = PRIBASE_REALTIME +
701 (lp->lwp_rtprio.prio & PRIMASK);
703 case RTP_PRIO_NORMAL:
704 newpriority = (lp->lwp_proc->p_nice - PRIO_MIN) * PPQ / NICEPPQ;
705 newpriority += lp->lwp_estcpu * PPQ / ESTCPUPPQ;
706 newpriority = newpriority * MAXPRI / (PRIO_RANGE * PPQ /
707 NICEPPQ + ESTCPUMAX * PPQ / ESTCPUPPQ);
708 newpriority = PRIBASE_NORMAL + (newpriority & PRIMASK);
711 newpriority = PRIBASE_IDLE + (lp->lwp_rtprio.prio & PRIMASK);
713 case RTP_PRIO_THREAD:
714 newpriority = PRIBASE_THREAD + (lp->lwp_rtprio.prio & PRIMASK);
717 panic("Bad RTP_PRIO %d", newrqtype);
722 * The newpriority incorporates the queue type so do a simple masked
723 * check to determine if the process has moved to another queue. If
724 * it has, and it is currently on a run queue, then move it.
726 if ((lp->lwp_priority ^ newpriority) & ~PPQMASK) {
727 lp->lwp_priority = newpriority;
728 if (lp->lwp_flag & LWP_ONRUNQ) {
729 bsd4_remrunqueue_locked(lp);
730 lp->lwp_rqtype = newrqtype;
731 lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ;
732 bsd4_setrunqueue_locked(lp);
733 reschedcpu = lp->lwp_thread->td_gd->gd_cpuid;
735 lp->lwp_rqtype = newrqtype;
736 lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ;
740 lp->lwp_priority = newpriority;
743 spin_unlock_wr(&bsd4_spin);
746 * Determine if we need to reschedule the target cpu. This only
747 * occurs if the LWP is already on a scheduler queue, which means
748 * that idle cpu notification has already occured. At most we
749 * need only issue a need_user_resched() on the appropriate cpu.
751 * The LWP may be owned by a CPU different from the current one,
752 * in which case dd->uschedcp may be modified without an MP lock
753 * or a spinlock held. The worst that happens is that the code
754 * below causes a spurious need_user_resched() on the target CPU
755 * and dd->pri to be wrong for a short period of time, both of
756 * which are harmless.
758 if (reschedcpu >= 0) {
759 dd = &bsd4_pcpu[reschedcpu];
760 if ((dd->upri & ~PRIMASK) > (lp->lwp_priority & ~PRIMASK)) {
761 dd->upri = lp->lwp_priority;
763 if (reschedcpu == mycpu->gd_cpuid) {
766 lwkt_send_ipiq(lp->lwp_thread->td_gd,
767 need_user_resched_remote, NULL);
779 bsd4_yield(struct lwp *lp)
782 /* FUTURE (or something similar) */
783 switch(lp->lwp_rqtype) {
784 case RTP_PRIO_NORMAL:
785 lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR);
795 * Called from fork1() when a new child process is being created.
797 * Give the child process an initial estcpu that is more batch then
798 * its parent and dock the parent for the fork (but do not
799 * reschedule the parent). This comprises the main part of our batch
800 * detection heuristic for both parallel forking and sequential execs.
802 * Interactive processes will decay the boosted estcpu quickly while batch
803 * processes will tend to compound it.
804 * XXX lwp should be "spawning" instead of "forking"
809 bsd4_forking(struct lwp *plp, struct lwp *lp)
811 lp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
812 lp->lwp_origcpu = lp->lwp_estcpu;
813 plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
817 * Called when the parent reaps a child. Propogate cpu use by the child
818 * back to the parent.
823 bsd4_exiting(struct lwp *plp, struct lwp *lp)
827 if (plp->lwp_proc->p_pid != 1) {
828 delta = lp->lwp_estcpu - lp->lwp_origcpu;
830 plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + delta);
836 * chooseproc() is called when a cpu needs a user process to LWKT schedule,
837 * it selects a user process and returns it. If chklp is non-NULL and chklp
838 * has a better or equal priority then the process that would otherwise be
839 * chosen, NULL is returned.
841 * Until we fix the RUNQ code the chklp test has to be strict or we may
842 * bounce between processes trying to acquire the current process designation.
844 * MPSAFE - must be called with bsd4_spin exclusive held. The spinlock is
845 * left intact through the entire routine.
849 chooseproc_locked(struct lwp *chklp)
853 u_int32_t *which, *which2;
860 rtqbits = bsd4_rtqueuebits;
861 tsqbits = bsd4_queuebits;
862 idqbits = bsd4_idqueuebits;
863 cpumask = mycpu->gd_cpumask;
870 q = &bsd4_rtqueues[pri];
871 which = &bsd4_rtqueuebits;
873 } else if (tsqbits) {
875 q = &bsd4_queues[pri];
876 which = &bsd4_queuebits;
878 } else if (idqbits) {
880 q = &bsd4_idqueues[pri];
881 which = &bsd4_idqueuebits;
887 KASSERT(lp, ("chooseproc: no lwp on busy queue"));
890 while ((lp->lwp_cpumask & cpumask) == 0) {
891 lp = TAILQ_NEXT(lp, lwp_procq);
893 *which2 &= ~(1 << pri);
900 * If the passed lwp <chklp> is reasonably close to the selected
901 * lwp <lp>, return NULL (indicating that <chklp> should be kept).
903 * Note that we must error on the side of <chklp> to avoid bouncing
904 * between threads in the acquire code.
907 if (chklp->lwp_priority < lp->lwp_priority + PPQ)
913 * If the chosen lwp does not reside on this cpu spend a few
914 * cycles looking for a better candidate at the same priority level.
915 * This is a fallback check, setrunqueue() tries to wakeup the
916 * correct cpu and is our front-line affinity.
918 if (lp->lwp_thread->td_gd != mycpu &&
919 (chklp = TAILQ_NEXT(lp, lwp_procq)) != NULL
921 if (chklp->lwp_thread->td_gd == mycpu) {
928 TAILQ_REMOVE(q, lp, lwp_procq);
931 *which &= ~(1 << pri);
932 KASSERT((lp->lwp_flag & LWP_ONRUNQ) != 0, ("not on runq6!"));
933 lp->lwp_flag &= ~LWP_ONRUNQ;
940 * Called via an ipi message to reschedule on another cpu. If no
941 * user thread is active on the target cpu we wake the scheduler
942 * helper thread up to help schedule one.
948 need_user_resched_remote(void *dummy)
950 globaldata_t gd = mycpu;
951 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
953 if (dd->uschedcp == NULL && (bsd4_rdyprocmask & gd->gd_cpumask)) {
954 atomic_clear_int(&bsd4_rdyprocmask, gd->gd_cpumask);
955 lwkt_schedule(&dd->helper_thread);
964 * bsd4_remrunqueue_locked() removes a given process from the run queue
965 * that it is on, clearing the queue busy bit if it becomes empty.
967 * Note that user process scheduler is different from the LWKT schedule.
968 * The user process scheduler only manages user processes but it uses LWKT
969 * underneath, and a user process operating in the kernel will often be
970 * 'released' from our management.
972 * MPSAFE - bsd4_spin must be held exclusively on call
975 bsd4_remrunqueue_locked(struct lwp *lp)
981 KKASSERT(lp->lwp_flag & LWP_ONRUNQ);
982 lp->lwp_flag &= ~LWP_ONRUNQ;
984 KKASSERT(bsd4_runqcount >= 0);
986 pri = lp->lwp_rqindex;
987 switch(lp->lwp_rqtype) {
988 case RTP_PRIO_NORMAL:
989 q = &bsd4_queues[pri];
990 which = &bsd4_queuebits;
992 case RTP_PRIO_REALTIME:
994 q = &bsd4_rtqueues[pri];
995 which = &bsd4_rtqueuebits;
998 q = &bsd4_idqueues[pri];
999 which = &bsd4_idqueuebits;
1002 panic("remrunqueue: invalid rtprio type");
1005 TAILQ_REMOVE(q, lp, lwp_procq);
1006 if (TAILQ_EMPTY(q)) {
1007 KASSERT((*which & (1 << pri)) != 0,
1008 ("remrunqueue: remove from empty queue"));
1009 *which &= ~(1 << pri);
1014 * bsd4_setrunqueue_locked()
1016 * Add a process whos rqtype and rqindex had previously been calculated
1017 * onto the appropriate run queue. Determine if the addition requires
1018 * a reschedule on a cpu and return the cpuid or -1.
1020 * NOTE: Lower priorities are better priorities.
1022 * MPSAFE - bsd4_spin must be held exclusively on call
1025 bsd4_setrunqueue_locked(struct lwp *lp)
1031 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
1032 lp->lwp_flag |= LWP_ONRUNQ;
1035 pri = lp->lwp_rqindex;
1037 switch(lp->lwp_rqtype) {
1038 case RTP_PRIO_NORMAL:
1039 q = &bsd4_queues[pri];
1040 which = &bsd4_queuebits;
1042 case RTP_PRIO_REALTIME:
1044 q = &bsd4_rtqueues[pri];
1045 which = &bsd4_rtqueuebits;
1048 q = &bsd4_idqueues[pri];
1049 which = &bsd4_idqueuebits;
1052 panic("remrunqueue: invalid rtprio type");
1057 * Add to the correct queue and set the appropriate bit. If no
1058 * lower priority (i.e. better) processes are in the queue then
1059 * we want a reschedule, calculate the best cpu for the job.
1061 * Always run reschedules on the LWPs original cpu.
1063 TAILQ_INSERT_TAIL(q, lp, lwp_procq);
1070 * For SMP systems a user scheduler helper thread is created for each
1071 * cpu and is used to allow one cpu to wakeup another for the purposes of
1072 * scheduling userland threads from setrunqueue(). UP systems do not
1073 * need the helper since there is only one cpu. We can't use the idle
1074 * thread for this because we need to hold the MP lock. Additionally,
1075 * doing things this way allows us to HLT idle cpus on MP systems.
1080 sched_thread(void *dummy)
1093 cpuid = gd->gd_cpuid; /* doesn't change */
1094 cpumask = gd->gd_cpumask; /* doesn't change */
1095 dd = &bsd4_pcpu[cpuid];
1098 * The scheduler thread does not need to hold the MP lock. Since we
1099 * are woken up only when no user processes are scheduled on a cpu, we
1100 * can run at an ultra low priority.
1103 lwkt_setpri_self(TDPRI_USER_SCHEDULER);
1107 * We use the LWKT deschedule-interlock trick to avoid racing
1108 * bsd4_rdyprocmask. This means we cannot block through to the
1109 * manual lwkt_switch() call we make below.
1112 lwkt_deschedule_self(gd->gd_curthread);
1113 spin_lock_wr(&bsd4_spin);
1114 atomic_set_int(&bsd4_rdyprocmask, cpumask);
1116 clear_user_resched(); /* This satisfied the reschedule request */
1117 dd->rrcount = 0; /* Reset the round-robin counter */
1119 if ((bsd4_curprocmask & cpumask) == 0) {
1121 * No thread is currently scheduled.
1123 KKASSERT(dd->uschedcp == NULL);
1124 if ((nlp = chooseproc_locked(NULL)) != NULL) {
1125 atomic_set_int(&bsd4_curprocmask, cpumask);
1126 dd->upri = nlp->lwp_priority;
1128 spin_unlock_wr(&bsd4_spin);
1129 lwkt_acquire(nlp->lwp_thread);
1130 lwkt_schedule(nlp->lwp_thread);
1132 spin_unlock_wr(&bsd4_spin);
1136 * Disabled for now, this can create an infinite loop.
1138 } else if (bsd4_runqcount) {
1140 * Someone scheduled us but raced. In order to not lose
1141 * track of the fact that there may be a LWP ready to go,
1142 * forward the request to another cpu if available.
1144 * Rotate through cpus starting with cpuid + 1. Since cpuid
1145 * is already masked out by gd_other_cpus, just use ~cpumask.
1147 tmpmask = bsd4_rdyprocmask & mycpu->gd_other_cpus &
1150 if (tmpmask & ~(cpumask - 1))
1151 tmpid = bsfl(tmpmask & ~(cpumask - 1));
1153 tmpid = bsfl(tmpmask);
1154 bsd4_scancpu = tmpid;
1155 atomic_clear_int(&bsd4_rdyprocmask, 1 << tmpid);
1156 spin_unlock_wr(&bsd4_spin);
1157 lwkt_schedule(&bsd4_pcpu[tmpid].helper_thread);
1159 spin_unlock_wr(&bsd4_spin);
1164 * The runq is empty.
1166 spin_unlock_wr(&bsd4_spin);
1174 * Setup our scheduler helpers. Note that curprocmask bit 0 has already
1175 * been cleared by rqinit() and we should not mess with it further.
1178 sched_thread_cpu_init(void)
1183 kprintf("start scheduler helpers on cpus:");
1185 for (i = 0; i < ncpus; ++i) {
1186 bsd4_pcpu_t dd = &bsd4_pcpu[i];
1187 cpumask_t mask = 1 << i;
1189 if ((mask & smp_active_mask) == 0)
1195 lwkt_create(sched_thread, NULL, NULL, &dd->helper_thread,
1196 TDF_STOPREQ, i, "usched %d", i);
1199 * Allow user scheduling on the target cpu. cpu #0 has already
1200 * been enabled in rqinit().
1203 atomic_clear_int(&bsd4_curprocmask, mask);
1204 atomic_set_int(&bsd4_rdyprocmask, mask);
1205 dd->upri = PRIBASE_NULL;
1210 SYSINIT(uschedtd, SI_BOOT2_USCHED, SI_ORDER_SECOND,
1211 sched_thread_cpu_init, NULL)