HAMMER 40B/Many: Inode/link-count sequencer cleanup pass.
[dragonfly.git] / sys / kern / usched_bsd4.c
blobb934e3df1bf2a46d6822c777e07966ec16955ad0
1 /*
2 * Copyright (c) 1999 Peter Wemm <peter@FreeBSD.org>
3 * All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
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
24 * SUCH DAMAGE.
26 * $DragonFly: src/sys/kern/usched_bsd4.c,v 1.23 2008/04/21 15:24:46 dillon Exp $
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/kernel.h>
32 #include <sys/lock.h>
33 #include <sys/queue.h>
34 #include <sys/proc.h>
35 #include <sys/rtprio.h>
36 #include <sys/uio.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.
51 #define MAXPRI 128
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
70 * 100% cpu.
72 #define NICEPPQ 2
73 #define ESTCPURAMP 4
74 #define ESTCPUPPQ 512
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)
81 TAILQ_HEAD(rq, lwp);
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,
94 sysclock_t cpstamp);
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);
101 #ifdef SMP
102 static void need_user_resched_remote(void *dummy);
103 #endif
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 = {
109 { NULL },
110 "bsd4", "Original DragonFly Scheduler",
111 NULL, /* default registration */
112 NULL, /* default deregistration */
113 bsd4_acquire_curproc,
114 bsd4_release_curproc,
115 bsd4_setrunqueue,
116 bsd4_schedulerclock,
117 bsd4_recalculate_estcpu,
118 bsd4_resetpriority,
119 bsd4_forking,
120 bsd4_exiting,
121 NULL, /* setcpumask not supported */
122 bsd4_yield
125 struct usched_bsd4_pcpu {
126 struct thread helper_thread;
127 short rrcount;
128 short upri;
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
144 * queue.
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;
155 #ifdef SMP
156 static volatile int bsd4_scancpu;
157 #endif
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, "");
162 #ifdef INVARIANTS
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");
169 #endif
170 static int usched_debug = -1;
171 SYSCTL_INT(_debug, OID_AUTO, scdebug, CTLFLAG_RW, &usched_debug, 0, "");
172 #ifdef SMP
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");
182 #endif
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.
194 static void
195 rqinit(void *dummy)
197 int i;
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 * We are expected to handle userland reschedule requests here too.
218 * WARNING! THIS FUNCTION IS ALLOWED TO CAUSE THE CURRENT THREAD TO MIGRATE
219 * TO ANOTHER CPU! Because most of the kernel assumes that no migration will
220 * occur, this function is called only under very controlled circumstances.
222 * Basically we recalculate our estcpu to hopefully give us a more
223 * favorable disposition, setrunqueue, then wait for the curlwp
224 * designation to be handed to us (if the setrunqueue didn't do it).
226 * MPSAFE
228 static void
229 bsd4_acquire_curproc(struct lwp *lp)
231 globaldata_t gd = mycpu;
232 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
235 * Possibly select another thread, or keep the current thread.
237 if (user_resched_wanted())
238 bsd4_select_curproc(gd);
241 * If uschedcp is still pointing to us, we're done
243 if (dd->uschedcp == lp)
244 return;
247 * If this cpu has no current thread, and the run queue is
248 * empty, we can safely select ourself.
250 if (dd->uschedcp == NULL && bsd4_runqcount == 0) {
251 atomic_set_int(&bsd4_curprocmask, gd->gd_cpumask);
252 dd->uschedcp = lp;
253 dd->upri = lp->lwp_priority;
254 return;
258 * Adjust estcpu and recalculate our priority, then put us back on
259 * the user process scheduler's runq. Only increment the involuntary
260 * context switch count if the setrunqueue call did not immediately
261 * schedule us.
263 * Loop until we become the currently scheduled process. Note that
264 * calling setrunqueue can cause us to be migrated to another cpu
265 * after we switch away.
267 do {
268 crit_enter();
269 bsd4_recalculate_estcpu(lp);
270 lwkt_deschedule_self(gd->gd_curthread);
271 bsd4_setrunqueue(lp);
272 if ((gd->gd_curthread->td_flags & TDF_RUNQ) == 0)
273 ++lp->lwp_ru.ru_nivcsw;
274 lwkt_switch();
275 crit_exit();
276 gd = mycpu;
277 dd = &bsd4_pcpu[gd->gd_cpuid];
278 } while (dd->uschedcp != lp);
279 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
283 * BSD4_RELEASE_CURPROC
285 * This routine detaches the current thread from the userland scheduler,
286 * usually because the thread needs to run in the kernel (at kernel priority)
287 * for a while.
289 * This routine is also responsible for selecting a new thread to
290 * make the current thread.
292 * NOTE: This implementation differs from the dummy example in that
293 * bsd4_select_curproc() is able to select the current process, whereas
294 * dummy_select_curproc() is not able to select the current process.
295 * This means we have to NULL out uschedcp.
297 * Additionally, note that we may already be on a run queue if releasing
298 * via the lwkt_switch() in bsd4_setrunqueue().
300 * WARNING! The MP lock may be in an unsynchronized state due to the
301 * way get_mplock() works and the fact that this function may be called
302 * from a passive release during a lwkt_switch(). try_mplock() will deal
303 * with this for us but you should be aware that td_mpcount may not be
304 * useable.
306 * MPSAFE
308 static void
309 bsd4_release_curproc(struct lwp *lp)
311 globaldata_t gd = mycpu;
312 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
314 if (dd->uschedcp == lp) {
316 * Note: we leave ou curprocmask bit set to prevent
317 * unnecessary scheduler helper wakeups.
318 * bsd4_select_curproc() will clean it up.
320 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
321 dd->uschedcp = NULL; /* don't let lp be selected */
322 bsd4_select_curproc(gd);
327 * BSD4_SELECT_CURPROC
329 * Select a new current process for this cpu. This satisfies a user
330 * scheduler reschedule request so clear that too.
332 * This routine is also responsible for equal-priority round-robining,
333 * typically triggered from bsd4_schedulerclock(). In our dummy example
334 * all the 'user' threads are LWKT scheduled all at once and we just
335 * call lwkt_switch().
337 * MPSAFE
339 static
340 void
341 bsd4_select_curproc(globaldata_t gd)
343 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
344 struct lwp *nlp;
345 int cpuid = gd->gd_cpuid;
347 crit_enter_gd(gd);
348 clear_user_resched(); /* This satisfied the reschedule request */
349 dd->rrcount = 0; /* Reset the round-robin counter */
351 spin_lock_wr(&bsd4_spin);
352 if ((nlp = chooseproc_locked(dd->uschedcp)) != NULL) {
353 atomic_set_int(&bsd4_curprocmask, 1 << cpuid);
354 dd->upri = nlp->lwp_priority;
355 dd->uschedcp = nlp;
356 spin_unlock_wr(&bsd4_spin);
357 #ifdef SMP
358 lwkt_acquire(nlp->lwp_thread);
359 #endif
360 lwkt_schedule(nlp->lwp_thread);
361 } else if (dd->uschedcp) {
362 dd->upri = dd->uschedcp->lwp_priority;
363 spin_unlock_wr(&bsd4_spin);
364 KKASSERT(bsd4_curprocmask & (1 << cpuid));
365 } else if (bsd4_runqcount && (bsd4_rdyprocmask & (1 << cpuid))) {
366 atomic_clear_int(&bsd4_curprocmask, 1 << cpuid);
367 atomic_clear_int(&bsd4_rdyprocmask, 1 << cpuid);
368 dd->uschedcp = NULL;
369 dd->upri = PRIBASE_NULL;
370 spin_unlock_wr(&bsd4_spin);
371 lwkt_schedule(&dd->helper_thread);
372 } else {
373 dd->uschedcp = NULL;
374 dd->upri = PRIBASE_NULL;
375 atomic_clear_int(&bsd4_curprocmask, 1 << cpuid);
376 spin_unlock_wr(&bsd4_spin);
378 crit_exit_gd(gd);
382 * BSD4_SETRUNQUEUE
384 * This routine is called to schedule a new user process after a fork.
386 * The caller may set P_PASSIVE_ACQ in p_flag to indicate that we should
387 * attempt to leave the thread on the current cpu.
389 * If P_PASSIVE_ACQ is set setrunqueue() will not wakeup potential target
390 * cpus in an attempt to keep the process on the current cpu at least for
391 * a little while to take advantage of locality of reference (e.g. fork/exec
392 * or short fork/exit, and uio_yield()).
394 * CPU AFFINITY: cpu affinity is handled by attempting to either schedule
395 * or (user level) preempt on the same cpu that a process was previously
396 * scheduled to. If we cannot do this but we are at enough of a higher
397 * priority then the processes running on other cpus, we will allow the
398 * process to be stolen by another cpu.
400 * WARNING! This routine cannot block. bsd4_acquire_curproc() does
401 * a deschedule/switch interlock and we can be moved to another cpu
402 * the moment we are switched out. Our LWKT run state is the only
403 * thing preventing the transfer.
405 * The associated thread must NOT currently be scheduled (but can be the
406 * current process after it has been LWKT descheduled). It must NOT be on
407 * a bsd4 scheduler queue either. The purpose of this routine is to put
408 * it on a scheduler queue or make it the current user process and LWKT
409 * schedule it. It is possible that the thread is in the middle of a LWKT
410 * switchout on another cpu, lwkt_acquire() deals with that case.
412 * The process must be runnable.
414 * MPSAFE
416 static void
417 bsd4_setrunqueue(struct lwp *lp)
419 globaldata_t gd;
420 bsd4_pcpu_t dd;
421 int cpuid;
422 #ifdef SMP
423 cpumask_t mask;
424 cpumask_t tmpmask;
425 #endif
428 * First validate the process state relative to the current cpu.
429 * We don't need the spinlock for this, just a critical section.
430 * We are in control of the process.
432 crit_enter();
433 KASSERT(lp->lwp_stat == LSRUN, ("setrunqueue: lwp not LSRUN"));
434 KASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0,
435 ("lwp %d/%d already on runq! flag %08x/%08x", lp->lwp_proc->p_pid,
436 lp->lwp_tid, lp->lwp_proc->p_flag, lp->lwp_flag));
437 KKASSERT((lp->lwp_thread->td_flags & TDF_RUNQ) == 0);
440 * Note: gd and dd are relative to the target thread's last cpu,
441 * NOT our current cpu.
443 gd = lp->lwp_thread->td_gd;
444 dd = &bsd4_pcpu[gd->gd_cpuid];
447 * This process is not supposed to be scheduled anywhere or assigned
448 * as the current process anywhere. Assert the condition.
450 KKASSERT(dd->uschedcp != lp);
453 * Check local cpu affinity. The associated thread is stable at
454 * the moment. Note that we may be checking another cpu here so we
455 * have to be careful. We can only assign uschedcp on OUR cpu.
457 * This allows us to avoid actually queueing the process.
458 * acquire_curproc() will handle any threads we mistakenly schedule.
460 cpuid = gd->gd_cpuid;
461 if (gd == mycpu && (bsd4_curprocmask & (1 << cpuid)) == 0) {
462 atomic_set_int(&bsd4_curprocmask, 1 << cpuid);
463 dd->uschedcp = lp;
464 dd->upri = lp->lwp_priority;
465 lwkt_schedule(lp->lwp_thread);
466 crit_exit();
467 return;
471 * gd and cpuid may still 'hint' at another cpu. Even so we have
472 * to place this process on the userland scheduler's run queue for
473 * action by the target cpu.
475 #ifdef SMP
477 * XXX fixme. Could be part of a remrunqueue/setrunqueue
478 * operation when the priority is recalculated, so TDF_MIGRATING
479 * may already be set.
481 if ((lp->lwp_thread->td_flags & TDF_MIGRATING) == 0)
482 lwkt_giveaway(lp->lwp_thread);
483 #endif
486 * We lose control of lp the moment we release the spinlock after
487 * having placed lp on the queue. i.e. another cpu could pick it
488 * up and it could exit, or its priority could be further adjusted,
489 * or something like that.
491 spin_lock_wr(&bsd4_spin);
492 bsd4_setrunqueue_locked(lp);
495 * gd, dd, and cpuid are still our target cpu 'hint', not our current
496 * cpu info.
498 * We always try to schedule a LWP to its original cpu first. It
499 * is possible for the scheduler helper or setrunqueue to assign
500 * the LWP to a different cpu before the one we asked for wakes
501 * up.
503 * If the LWP has higher priority (lower lwp_priority value) on
504 * its target cpu, reschedule on that cpu.
506 if ((lp->lwp_thread->td_flags & TDF_NORESCHED) == 0) {
507 if ((dd->upri & ~PRIMASK) > (lp->lwp_priority & ~PRIMASK)) {
508 dd->upri = lp->lwp_priority;
509 spin_unlock_wr(&bsd4_spin);
510 #ifdef SMP
511 if (gd == mycpu) {
512 need_user_resched();
513 } else {
514 lwkt_send_ipiq(gd, need_user_resched_remote,
515 NULL);
517 #else
518 need_user_resched();
519 #endif
520 crit_exit();
521 return;
524 spin_unlock_wr(&bsd4_spin);
526 #ifdef SMP
528 * Otherwise the LWP has a lower priority or we were asked not
529 * to reschedule. Look for an idle cpu whos scheduler helper
530 * is ready to accept more work.
532 * Look for an idle cpu starting at our rotator (bsd4_scancpu).
534 * If no cpus are ready to accept work, just return.
536 * XXX P_PASSIVE_ACQ
538 mask = ~bsd4_curprocmask & bsd4_rdyprocmask & mycpu->gd_other_cpus &
539 lp->lwp_cpumask;
540 if (mask) {
541 cpuid = bsd4_scancpu;
542 if (++cpuid == ncpus)
543 cpuid = 0;
544 tmpmask = ~((1 << cpuid) - 1);
545 if (mask & tmpmask)
546 cpuid = bsfl(mask & tmpmask);
547 else
548 cpuid = bsfl(mask);
549 atomic_clear_int(&bsd4_rdyprocmask, 1 << cpuid);
550 bsd4_scancpu = cpuid;
551 lwkt_schedule(&bsd4_pcpu[cpuid].helper_thread);
553 #endif
554 crit_exit();
558 * This routine is called from a systimer IPI. It MUST be MP-safe and
559 * the BGL IS NOT HELD ON ENTRY. This routine is called at ESTCPUFREQ on
560 * each cpu.
562 * Because this is effectively a 'fast' interrupt, we cannot safely
563 * use spinlocks unless gd_spinlock_rd is NULL and gd_spinlocks_wr is 0,
564 * even if the spinlocks are 'non conflicting'. This is due to the way
565 * spinlock conflicts against cached read locks are handled.
567 * MPSAFE
569 static
570 void
571 bsd4_schedulerclock(struct lwp *lp, sysclock_t period, sysclock_t cpstamp)
573 globaldata_t gd = mycpu;
574 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid];
577 * Do we need to round-robin? We round-robin 10 times a second.
578 * This should only occur for cpu-bound batch processes.
580 if (++dd->rrcount >= usched_bsd4_rrinterval) {
581 dd->rrcount = 0;
582 need_user_resched();
586 * As the process accumulates cpu time p_estcpu is bumped and may
587 * push the process into another scheduling queue. It typically
588 * takes 4 ticks to bump the queue.
590 lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR);
593 * Reducing p_origcpu over time causes more of our estcpu to be
594 * returned to the parent when we exit. This is a small tweak
595 * for the batch detection heuristic.
597 if (lp->lwp_origcpu)
598 --lp->lwp_origcpu;
601 * We can only safely call bsd4_resetpriority(), which uses spinlocks,
602 * if we aren't interrupting a thread that is using spinlocks.
603 * Otherwise we can deadlock with another cpu waiting for our read
604 * spinlocks to clear.
606 if (gd->gd_spinlock_rd == NULL && gd->gd_spinlocks_wr == 0)
607 bsd4_resetpriority(lp);
608 else
609 need_user_resched();
613 * Called from acquire and from kern_synch's one-second timer (one of the
614 * callout helper threads) with a critical section held.
616 * Decay p_estcpu based on the number of ticks we haven't been running
617 * and our p_nice. As the load increases each process observes a larger
618 * number of idle ticks (because other processes are running in them).
619 * This observation leads to a larger correction which tends to make the
620 * system more 'batchy'.
622 * Note that no recalculation occurs for a process which sleeps and wakes
623 * up in the same tick. That is, a system doing thousands of context
624 * switches per second will still only do serious estcpu calculations
625 * ESTCPUFREQ times per second.
627 * MPSAFE
629 static
630 void
631 bsd4_recalculate_estcpu(struct lwp *lp)
633 globaldata_t gd = mycpu;
634 sysclock_t cpbase;
635 int loadfac;
636 int ndecay;
637 int nticks;
638 int nleft;
641 * We have to subtract periodic to get the last schedclock
642 * timeout time, otherwise we would get the upcoming timeout.
643 * Keep in mind that a process can migrate between cpus and
644 * while the scheduler clock should be very close, boundary
645 * conditions could lead to a small negative delta.
647 cpbase = gd->gd_schedclock.time - gd->gd_schedclock.periodic;
649 if (lp->lwp_slptime > 1) {
651 * Too much time has passed, do a coarse correction.
653 lp->lwp_estcpu = lp->lwp_estcpu >> 1;
654 bsd4_resetpriority(lp);
655 lp->lwp_cpbase = cpbase;
656 lp->lwp_cpticks = 0;
657 } else if (lp->lwp_cpbase != cpbase) {
659 * Adjust estcpu if we are in a different tick. Don't waste
660 * time if we are in the same tick.
662 * First calculate the number of ticks in the measurement
663 * interval. The nticks calculation can wind up 0 due to
664 * a bug in the handling of lwp_slptime (as yet not found),
665 * so make sure we do not get a divide by 0 panic.
667 nticks = (cpbase - lp->lwp_cpbase) / gd->gd_schedclock.periodic;
668 if (nticks <= 0)
669 nticks = 1;
670 updatepcpu(lp, lp->lwp_cpticks, nticks);
672 if ((nleft = nticks - lp->lwp_cpticks) < 0)
673 nleft = 0;
674 if (usched_debug == lp->lwp_proc->p_pid) {
675 kprintf("pid %d tid %d estcpu %d cpticks %d nticks %d nleft %d",
676 lp->lwp_proc->p_pid, lp->lwp_tid, lp->lwp_estcpu,
677 lp->lwp_cpticks, nticks, nleft);
681 * Calculate a decay value based on ticks remaining scaled
682 * down by the instantanious load and p_nice.
684 if ((loadfac = bsd4_runqcount) < 2)
685 loadfac = 2;
686 ndecay = nleft * usched_bsd4_decay * 2 *
687 (PRIO_MAX * 2 - lp->lwp_proc->p_nice) / (loadfac * PRIO_MAX * 2);
690 * Adjust p_estcpu. Handle a border case where batch jobs
691 * can get stalled long enough to decay to zero when they
692 * shouldn't.
694 if (lp->lwp_estcpu > ndecay * 2)
695 lp->lwp_estcpu -= ndecay;
696 else
697 lp->lwp_estcpu >>= 1;
699 if (usched_debug == lp->lwp_proc->p_pid)
700 kprintf(" ndecay %d estcpu %d\n", ndecay, lp->lwp_estcpu);
701 bsd4_resetpriority(lp);
702 lp->lwp_cpbase = cpbase;
703 lp->lwp_cpticks = 0;
708 * Compute the priority of a process when running in user mode.
709 * Arrange to reschedule if the resulting priority is better
710 * than that of the current process.
712 * This routine may be called with any process.
714 * This routine is called by fork1() for initial setup with the process
715 * of the run queue, and also may be called normally with the process on or
716 * off the run queue.
718 * MPSAFE
720 static void
721 bsd4_resetpriority(struct lwp *lp)
723 bsd4_pcpu_t dd;
724 int newpriority;
725 u_short newrqtype;
726 int reschedcpu;
729 * Calculate the new priority and queue type
731 crit_enter();
732 spin_lock_wr(&bsd4_spin);
734 newrqtype = lp->lwp_rtprio.type;
736 switch(newrqtype) {
737 case RTP_PRIO_REALTIME:
738 case RTP_PRIO_FIFO:
739 newpriority = PRIBASE_REALTIME +
740 (lp->lwp_rtprio.prio & PRIMASK);
741 break;
742 case RTP_PRIO_NORMAL:
743 newpriority = (lp->lwp_proc->p_nice - PRIO_MIN) * PPQ / NICEPPQ;
744 newpriority += lp->lwp_estcpu * PPQ / ESTCPUPPQ;
745 newpriority = newpriority * MAXPRI / (PRIO_RANGE * PPQ /
746 NICEPPQ + ESTCPUMAX * PPQ / ESTCPUPPQ);
747 newpriority = PRIBASE_NORMAL + (newpriority & PRIMASK);
748 break;
749 case RTP_PRIO_IDLE:
750 newpriority = PRIBASE_IDLE + (lp->lwp_rtprio.prio & PRIMASK);
751 break;
752 case RTP_PRIO_THREAD:
753 newpriority = PRIBASE_THREAD + (lp->lwp_rtprio.prio & PRIMASK);
754 break;
755 default:
756 panic("Bad RTP_PRIO %d", newrqtype);
757 /* NOT REACHED */
761 * The newpriority incorporates the queue type so do a simple masked
762 * check to determine if the process has moved to another queue. If
763 * it has, and it is currently on a run queue, then move it.
765 if ((lp->lwp_priority ^ newpriority) & ~PPQMASK) {
766 lp->lwp_priority = newpriority;
767 if (lp->lwp_flag & LWP_ONRUNQ) {
768 bsd4_remrunqueue_locked(lp);
769 lp->lwp_rqtype = newrqtype;
770 lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ;
771 bsd4_setrunqueue_locked(lp);
772 reschedcpu = lp->lwp_thread->td_gd->gd_cpuid;
773 } else {
774 lp->lwp_rqtype = newrqtype;
775 lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ;
776 reschedcpu = -1;
778 } else {
779 lp->lwp_priority = newpriority;
780 reschedcpu = -1;
782 spin_unlock_wr(&bsd4_spin);
785 * Determine if we need to reschedule the target cpu. This only
786 * occurs if the LWP is already on a scheduler queue, which means
787 * that idle cpu notification has already occured. At most we
788 * need only issue a need_user_resched() on the appropriate cpu.
790 if (reschedcpu >= 0) {
791 dd = &bsd4_pcpu[reschedcpu];
792 KKASSERT(dd->uschedcp != lp);
793 if ((dd->upri & ~PRIMASK) > (lp->lwp_priority & ~PRIMASK)) {
794 dd->upri = lp->lwp_priority;
795 #ifdef SMP
796 if (reschedcpu == mycpu->gd_cpuid) {
797 need_user_resched();
798 } else {
799 lwkt_send_ipiq(lp->lwp_thread->td_gd,
800 need_user_resched_remote, NULL);
802 #else
803 need_user_resched();
804 #endif
807 crit_exit();
810 static
811 void
812 bsd4_yield(struct lwp *lp)
814 #if 0
815 /* FUTURE (or something similar) */
816 switch(lp->lwp_rqtype) {
817 case RTP_PRIO_NORMAL:
818 lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR);
819 kprintf("Y");
820 break;
821 default:
822 break;
824 #endif
825 need_user_resched();
829 * Called from fork1() when a new child process is being created.
831 * Give the child process an initial estcpu that is more batch then
832 * its parent and dock the parent for the fork (but do not
833 * reschedule the parent). This comprises the main part of our batch
834 * detection heuristic for both parallel forking and sequential execs.
836 * Interactive processes will decay the boosted estcpu quickly while batch
837 * processes will tend to compound it.
838 * XXX lwp should be "spawning" instead of "forking"
840 * MPSAFE
842 static void
843 bsd4_forking(struct lwp *plp, struct lwp *lp)
845 lp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
846 lp->lwp_origcpu = lp->lwp_estcpu;
847 plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ);
851 * Called when the parent reaps a child. Propogate cpu use by the child
852 * back to the parent.
854 * MPSAFE
856 static void
857 bsd4_exiting(struct lwp *plp, struct lwp *lp)
859 int delta;
861 if (plp->lwp_proc->p_pid != 1) {
862 delta = lp->lwp_estcpu - lp->lwp_origcpu;
863 if (delta > 0)
864 plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + delta);
870 * chooseproc() is called when a cpu needs a user process to LWKT schedule,
871 * it selects a user process and returns it. If chklp is non-NULL and chklp
872 * has a better or equal priority then the process that would otherwise be
873 * chosen, NULL is returned.
875 * Until we fix the RUNQ code the chklp test has to be strict or we may
876 * bounce between processes trying to acquire the current process designation.
878 * MPSAFE - must be called with bsd4_spin exclusive held. The spinlock is
879 * left intact through the entire routine.
881 static
882 struct lwp *
883 chooseproc_locked(struct lwp *chklp)
885 struct lwp *lp;
886 struct rq *q;
887 u_int32_t *which, *which2;
888 u_int32_t pri;
889 u_int32_t rtqbits;
890 u_int32_t tsqbits;
891 u_int32_t idqbits;
892 cpumask_t cpumask;
894 rtqbits = bsd4_rtqueuebits;
895 tsqbits = bsd4_queuebits;
896 idqbits = bsd4_idqueuebits;
897 cpumask = mycpu->gd_cpumask;
899 #ifdef SMP
900 again:
901 #endif
902 if (rtqbits) {
903 pri = bsfl(rtqbits);
904 q = &bsd4_rtqueues[pri];
905 which = &bsd4_rtqueuebits;
906 which2 = &rtqbits;
907 } else if (tsqbits) {
908 pri = bsfl(tsqbits);
909 q = &bsd4_queues[pri];
910 which = &bsd4_queuebits;
911 which2 = &tsqbits;
912 } else if (idqbits) {
913 pri = bsfl(idqbits);
914 q = &bsd4_idqueues[pri];
915 which = &bsd4_idqueuebits;
916 which2 = &idqbits;
917 } else {
918 return NULL;
920 lp = TAILQ_FIRST(q);
921 KASSERT(lp, ("chooseproc: no lwp on busy queue"));
923 #ifdef SMP
924 while ((lp->lwp_cpumask & cpumask) == 0) {
925 lp = TAILQ_NEXT(lp, lwp_procq);
926 if (lp == NULL) {
927 *which2 &= ~(1 << pri);
928 goto again;
931 #endif
934 * If the passed lwp <chklp> is reasonably close to the selected
935 * lwp <lp>, return NULL (indicating that <chklp> should be kept).
937 * Note that we must error on the side of <chklp> to avoid bouncing
938 * between threads in the acquire code.
940 if (chklp) {
941 if (chklp->lwp_priority < lp->lwp_priority + PPQ)
942 return(NULL);
945 #ifdef SMP
947 * If the chosen lwp does not reside on this cpu spend a few
948 * cycles looking for a better candidate at the same priority level.
949 * This is a fallback check, setrunqueue() tries to wakeup the
950 * correct cpu and is our front-line affinity.
952 if (lp->lwp_thread->td_gd != mycpu &&
953 (chklp = TAILQ_NEXT(lp, lwp_procq)) != NULL
955 if (chklp->lwp_thread->td_gd == mycpu) {
956 ++choose_affinity;
957 lp = chklp;
960 #endif
962 TAILQ_REMOVE(q, lp, lwp_procq);
963 --bsd4_runqcount;
964 if (TAILQ_EMPTY(q))
965 *which &= ~(1 << pri);
966 KASSERT((lp->lwp_flag & LWP_ONRUNQ) != 0, ("not on runq6!"));
967 lp->lwp_flag &= ~LWP_ONRUNQ;
968 return lp;
971 #ifdef SMP
973 * Called via an ipi message to reschedule on another cpu.
975 * MPSAFE
977 static
978 void
979 need_user_resched_remote(void *dummy)
981 need_user_resched();
984 #endif
988 * bsd4_remrunqueue_locked() removes a given process from the run queue
989 * that it is on, clearing the queue busy bit if it becomes empty.
991 * Note that user process scheduler is different from the LWKT schedule.
992 * The user process scheduler only manages user processes but it uses LWKT
993 * underneath, and a user process operating in the kernel will often be
994 * 'released' from our management.
996 * MPSAFE - bsd4_spin must be held exclusively on call
998 static void
999 bsd4_remrunqueue_locked(struct lwp *lp)
1001 struct rq *q;
1002 u_int32_t *which;
1003 u_int8_t pri;
1005 KKASSERT(lp->lwp_flag & LWP_ONRUNQ);
1006 lp->lwp_flag &= ~LWP_ONRUNQ;
1007 --bsd4_runqcount;
1008 KKASSERT(bsd4_runqcount >= 0);
1010 pri = lp->lwp_rqindex;
1011 switch(lp->lwp_rqtype) {
1012 case RTP_PRIO_NORMAL:
1013 q = &bsd4_queues[pri];
1014 which = &bsd4_queuebits;
1015 break;
1016 case RTP_PRIO_REALTIME:
1017 case RTP_PRIO_FIFO:
1018 q = &bsd4_rtqueues[pri];
1019 which = &bsd4_rtqueuebits;
1020 break;
1021 case RTP_PRIO_IDLE:
1022 q = &bsd4_idqueues[pri];
1023 which = &bsd4_idqueuebits;
1024 break;
1025 default:
1026 panic("remrunqueue: invalid rtprio type");
1027 /* NOT REACHED */
1029 TAILQ_REMOVE(q, lp, lwp_procq);
1030 if (TAILQ_EMPTY(q)) {
1031 KASSERT((*which & (1 << pri)) != 0,
1032 ("remrunqueue: remove from empty queue"));
1033 *which &= ~(1 << pri);
1038 * bsd4_setrunqueue_locked()
1040 * Add a process whos rqtype and rqindex had previously been calculated
1041 * onto the appropriate run queue. Determine if the addition requires
1042 * a reschedule on a cpu and return the cpuid or -1.
1044 * NOTE: Lower priorities are better priorities.
1046 * MPSAFE - bsd4_spin must be held exclusively on call
1048 static void
1049 bsd4_setrunqueue_locked(struct lwp *lp)
1051 struct rq *q;
1052 u_int32_t *which;
1053 int pri;
1055 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0);
1056 lp->lwp_flag |= LWP_ONRUNQ;
1057 ++bsd4_runqcount;
1059 pri = lp->lwp_rqindex;
1061 switch(lp->lwp_rqtype) {
1062 case RTP_PRIO_NORMAL:
1063 q = &bsd4_queues[pri];
1064 which = &bsd4_queuebits;
1065 break;
1066 case RTP_PRIO_REALTIME:
1067 case RTP_PRIO_FIFO:
1068 q = &bsd4_rtqueues[pri];
1069 which = &bsd4_rtqueuebits;
1070 break;
1071 case RTP_PRIO_IDLE:
1072 q = &bsd4_idqueues[pri];
1073 which = &bsd4_idqueuebits;
1074 break;
1075 default:
1076 panic("remrunqueue: invalid rtprio type");
1077 /* NOT REACHED */
1081 * Add to the correct queue and set the appropriate bit. If no
1082 * lower priority (i.e. better) processes are in the queue then
1083 * we want a reschedule, calculate the best cpu for the job.
1085 * Always run reschedules on the LWPs original cpu.
1087 TAILQ_INSERT_TAIL(q, lp, lwp_procq);
1088 *which |= 1 << pri;
1091 #ifdef SMP
1094 * For SMP systems a user scheduler helper thread is created for each
1095 * cpu and is used to allow one cpu to wakeup another for the purposes of
1096 * scheduling userland threads from setrunqueue(). UP systems do not
1097 * need the helper since there is only one cpu. We can't use the idle
1098 * thread for this because we need to hold the MP lock. Additionally,
1099 * doing things this way allows us to HLT idle cpus on MP systems.
1101 * MPSAFE
1103 static void
1104 sched_thread(void *dummy)
1106 globaldata_t gd;
1107 bsd4_pcpu_t dd;
1108 struct lwp *nlp;
1109 cpumask_t cpumask;
1110 cpumask_t tmpmask;
1111 int cpuid;
1112 int tmpid;
1114 gd = mycpu;
1115 cpuid = gd->gd_cpuid; /* doesn't change */
1116 cpumask = 1 << cpuid; /* doesn't change */
1117 dd = &bsd4_pcpu[cpuid];
1120 * The scheduler thread does not need to hold the MP lock. Since we
1121 * are woken up only when no user processes are scheduled on a cpu, we
1122 * can run at an ultra low priority.
1124 rel_mplock();
1125 lwkt_setpri_self(TDPRI_USER_SCHEDULER);
1127 for (;;) {
1129 * We use the LWKT deschedule-interlock trick to avoid racing
1130 * bsd4_rdyprocmask. This means we cannot block through to the
1131 * manual lwkt_switch() call we make below.
1133 crit_enter_gd(gd);
1134 lwkt_deschedule_self(gd->gd_curthread);
1135 spin_lock_wr(&bsd4_spin);
1136 atomic_set_int(&bsd4_rdyprocmask, cpumask);
1137 if ((bsd4_curprocmask & cpumask) == 0) {
1138 if ((nlp = chooseproc_locked(NULL)) != NULL) {
1139 atomic_set_int(&bsd4_curprocmask, cpumask);
1140 dd->upri = nlp->lwp_priority;
1141 dd->uschedcp = nlp;
1142 spin_unlock_wr(&bsd4_spin);
1143 lwkt_acquire(nlp->lwp_thread);
1144 lwkt_schedule(nlp->lwp_thread);
1145 } else {
1146 spin_unlock_wr(&bsd4_spin);
1148 } else {
1150 * Someone scheduled us but raced. In order to not lose
1151 * track of the fact that there may be a LWP ready to go,
1152 * forward the request to another cpu if available.
1154 * Rotate through cpus starting with cpuid + 1. Since cpuid
1155 * is already masked out by gd_other_cpus, just use ~cpumask.
1157 tmpmask = ~bsd4_curprocmask & bsd4_rdyprocmask &
1158 mycpu->gd_other_cpus;
1159 if (tmpmask) {
1160 if (tmpmask & ~(cpumask - 1))
1161 tmpid = bsfl(tmpmask & ~(cpumask - 1));
1162 else
1163 tmpid = bsfl(tmpmask);
1164 bsd4_scancpu = tmpid;
1165 atomic_clear_int(&bsd4_rdyprocmask, 1 << tmpid);
1166 spin_unlock_wr(&bsd4_spin);
1167 lwkt_schedule(&bsd4_pcpu[tmpid].helper_thread);
1168 } else {
1169 spin_unlock_wr(&bsd4_spin);
1172 crit_exit_gd(gd);
1173 lwkt_switch();
1178 * Setup our scheduler helpers. Note that curprocmask bit 0 has already
1179 * been cleared by rqinit() and we should not mess with it further.
1181 static void
1182 sched_thread_cpu_init(void)
1184 int i;
1186 if (bootverbose)
1187 kprintf("start scheduler helpers on cpus:");
1189 for (i = 0; i < ncpus; ++i) {
1190 bsd4_pcpu_t dd = &bsd4_pcpu[i];
1191 cpumask_t mask = 1 << i;
1193 if ((mask & smp_active_mask) == 0)
1194 continue;
1196 if (bootverbose)
1197 kprintf(" %d", i);
1199 lwkt_create(sched_thread, NULL, NULL, &dd->helper_thread,
1200 TDF_STOPREQ, i, "usched %d", i);
1203 * Allow user scheduling on the target cpu. cpu #0 has already
1204 * been enabled in rqinit().
1206 if (i)
1207 atomic_clear_int(&bsd4_curprocmask, mask);
1208 atomic_set_int(&bsd4_rdyprocmask, mask);
1210 if (bootverbose)
1211 kprintf("\n");
1213 SYSINIT(uschedtd, SI_BOOT2_USCHED, SI_ORDER_SECOND,
1214 sched_thread_cpu_init, NULL)
1216 #endif