1 /* 2 * Copyright (c) 1999 Peter Wemm <peter@FreeBSD.org> 3 * All rights reserved. 4 * 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. 13 * 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. 25 * 26 * $DragonFly: src/sys/kern/usched_bsd4.c,v 1.26 2008/11/01 23:31:19 dillon Exp $ 27 */ 28 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> 42 43 #include <sys/thread2.h> 44 #include <sys/spinlock2.h> 45 #include <sys/mplock2.h> 46 47 /* 48 * Priorities. Note that with 32 run queues per scheduler each queue 49 * represents four priority levels. 50 */ 51 52 #define MAXPRI 128 53 #define PRIMASK (MAXPRI - 1) 54 #define PRIBASE_REALTIME 0 55 #define PRIBASE_NORMAL MAXPRI 56 #define PRIBASE_IDLE (MAXPRI * 2) 57 #define PRIBASE_THREAD (MAXPRI * 3) 58 #define PRIBASE_NULL (MAXPRI * 4) 59 60 #define NQS 32 /* 32 run queues. */ 61 #define PPQ (MAXPRI / NQS) /* priorities per queue */ 62 #define PPQMASK (PPQ - 1) 63 64 /* 65 * NICEPPQ - number of nice units per priority queue 66 * ESTCPURAMP - number of scheduler ticks for estcpu to switch queues 67 * 68 * ESTCPUPPQ - number of estcpu units per priority queue 69 * ESTCPUMAX - number of estcpu units 70 * ESTCPUINCR - amount we have to increment p_estcpu per scheduling tick at 71 * 100% cpu. 72 */ 73 #define NICEPPQ 2 74 #define ESTCPURAMP 4 75 #define ESTCPUPPQ 512 76 #define ESTCPUMAX (ESTCPUPPQ * NQS) 77 #define ESTCPUINCR (ESTCPUPPQ / ESTCPURAMP) 78 #define PRIO_RANGE (PRIO_MAX - PRIO_MIN + 1) 79 80 #define ESTCPULIM(v) min((v), ESTCPUMAX) 81 82 TAILQ_HEAD(rq, lwp); 83 84 #define lwp_priority lwp_usdata.bsd4.priority 85 #define lwp_rqindex lwp_usdata.bsd4.rqindex 86 #define lwp_origcpu lwp_usdata.bsd4.origcpu 87 #define lwp_estcpu lwp_usdata.bsd4.estcpu 88 #define lwp_rqtype lwp_usdata.bsd4.rqtype 89 90 static void bsd4_acquire_curproc(struct lwp *lp); 91 static void bsd4_release_curproc(struct lwp *lp); 92 static void bsd4_select_curproc(globaldata_t gd); 93 static void bsd4_setrunqueue(struct lwp *lp); 94 static void bsd4_schedulerclock(struct lwp *lp, sysclock_t period, 95 sysclock_t cpstamp); 96 static void bsd4_recalculate_estcpu(struct lwp *lp); 97 static void bsd4_resetpriority(struct lwp *lp); 98 static void bsd4_forking(struct lwp *plp, struct lwp *lp); 99 static void bsd4_exiting(struct lwp *plp, struct lwp *lp); 100 static void bsd4_yield(struct lwp *lp); 101 102 #ifdef SMP 103 static void need_user_resched_remote(void *dummy); 104 #endif 105 static struct lwp *chooseproc_locked(struct lwp *chklp); 106 static void bsd4_remrunqueue_locked(struct lwp *lp); 107 static void bsd4_setrunqueue_locked(struct lwp *lp); 108 109 struct usched usched_bsd4 = { 110 { NULL }, 111 "bsd4", "Original DragonFly Scheduler", 112 NULL, /* default registration */ 113 NULL, /* default deregistration */ 114 bsd4_acquire_curproc, 115 bsd4_release_curproc, 116 bsd4_setrunqueue, 117 bsd4_schedulerclock, 118 bsd4_recalculate_estcpu, 119 bsd4_resetpriority, 120 bsd4_forking, 121 bsd4_exiting, 122 NULL, /* setcpumask not supported */ 123 bsd4_yield 124 }; 125 126 struct usched_bsd4_pcpu { 127 struct thread helper_thread; 128 short rrcount; 129 short upri; 130 struct lwp *uschedcp; 131 }; 132 133 typedef struct usched_bsd4_pcpu *bsd4_pcpu_t; 134 135 /* 136 * We have NQS (32) run queues per scheduling class. For the normal 137 * class, there are 128 priorities scaled onto these 32 queues. New 138 * processes are added to the last entry in each queue, and processes 139 * are selected for running by taking them from the head and maintaining 140 * a simple FIFO arrangement. Realtime and Idle priority processes have 141 * and explicit 0-31 priority which maps directly onto their class queue 142 * index. When a queue has something in it, the corresponding bit is 143 * set in the queuebits variable, allowing a single read to determine 144 * the state of all 32 queues and then a ffs() to find the first busy 145 * queue. 146 */ 147 static struct rq bsd4_queues[NQS]; 148 static struct rq bsd4_rtqueues[NQS]; 149 static struct rq bsd4_idqueues[NQS]; 150 static u_int32_t bsd4_queuebits; 151 static u_int32_t bsd4_rtqueuebits; 152 static u_int32_t bsd4_idqueuebits; 153 static cpumask_t bsd4_curprocmask = -1; /* currently running a user process */ 154 static cpumask_t bsd4_rdyprocmask; /* ready to accept a user process */ 155 static int bsd4_runqcount; 156 #ifdef SMP 157 static volatile int bsd4_scancpu; 158 #endif 159 static struct spinlock bsd4_spin; 160 static struct usched_bsd4_pcpu bsd4_pcpu[MAXCPU]; 161 162 SYSCTL_INT(_debug, OID_AUTO, bsd4_runqcount, CTLFLAG_RD, &bsd4_runqcount, 0, 163 "Number of run queues"); 164 #ifdef INVARIANTS 165 static int usched_nonoptimal; 166 SYSCTL_INT(_debug, OID_AUTO, usched_nonoptimal, CTLFLAG_RW, 167 &usched_nonoptimal, 0, "acquire_curproc() was not optimal"); 168 static int usched_optimal; 169 SYSCTL_INT(_debug, OID_AUTO, usched_optimal, CTLFLAG_RW, 170 &usched_optimal, 0, "acquire_curproc() was optimal"); 171 #endif 172 static int usched_debug = -1; 173 SYSCTL_INT(_debug, OID_AUTO, scdebug, CTLFLAG_RW, &usched_debug, 0, 174 "Print debug information for this pid"); 175 #ifdef SMP 176 static int remote_resched_nonaffinity; 177 static int remote_resched_affinity; 178 static int choose_affinity; 179 SYSCTL_INT(_debug, OID_AUTO, remote_resched_nonaffinity, CTLFLAG_RD, 180 &remote_resched_nonaffinity, 0, "Number of remote rescheds"); 181 SYSCTL_INT(_debug, OID_AUTO, remote_resched_affinity, CTLFLAG_RD, 182 &remote_resched_affinity, 0, "Number of remote rescheds"); 183 SYSCTL_INT(_debug, OID_AUTO, choose_affinity, CTLFLAG_RD, 184 &choose_affinity, 0, "chooseproc() was smart"); 185 #endif 186 187 static int usched_bsd4_rrinterval = (ESTCPUFREQ + 9) / 10; 188 SYSCTL_INT(_kern, OID_AUTO, usched_bsd4_rrinterval, CTLFLAG_RW, 189 &usched_bsd4_rrinterval, 0, ""); 190 static int usched_bsd4_decay = ESTCPUINCR / 2; 191 SYSCTL_INT(_kern, OID_AUTO, usched_bsd4_decay, CTLFLAG_RW, 192 &usched_bsd4_decay, 0, ""); 193 194 /* 195 * Initialize the run queues at boot time. 196 */ 197 static void 198 rqinit(void *dummy) 199 { 200 int i; 201 202 spin_init(&bsd4_spin); 203 for (i = 0; i < NQS; i++) { 204 TAILQ_INIT(&bsd4_queues[i]); 205 TAILQ_INIT(&bsd4_rtqueues[i]); 206 TAILQ_INIT(&bsd4_idqueues[i]); 207 } 208 atomic_clear_cpumask(&bsd4_curprocmask, 1); 209 } 210 SYSINIT(runqueue, SI_BOOT2_USCHED, SI_ORDER_FIRST, rqinit, NULL) 211 212 /* 213 * BSD4_ACQUIRE_CURPROC 214 * 215 * This function is called when the kernel intends to return to userland. 216 * It is responsible for making the thread the current designated userland 217 * thread for this cpu, blocking if necessary. 218 * 219 * The kernel has already depressed our LWKT priority so we must not switch 220 * until we have either assigned or disposed of the thread. 221 * 222 * WARNING! THIS FUNCTION IS ALLOWED TO CAUSE THE CURRENT THREAD TO MIGRATE 223 * TO ANOTHER CPU! Because most of the kernel assumes that no migration will 224 * occur, this function is called only under very controlled circumstances. 225 * 226 * MPSAFE 227 */ 228 static void 229 bsd4_acquire_curproc(struct lwp *lp) 230 { 231 globaldata_t gd; 232 bsd4_pcpu_t dd; 233 struct lwp *olp; 234 235 crit_enter(); 236 bsd4_recalculate_estcpu(lp); 237 238 /* 239 * If a reschedule was requested give another thread the 240 * driver's seat. 241 */ 242 if (user_resched_wanted()) { 243 clear_user_resched(); 244 bsd4_release_curproc(lp); 245 } 246 247 /* 248 * Loop until we are the current user thread 249 */ 250 do { 251 /* 252 * Reload after a switch or setrunqueue/switch possibly 253 * moved us to another cpu. 254 */ 255 /*clear_lwkt_resched();*/ 256 gd = mycpu; 257 dd = &bsd4_pcpu[gd->gd_cpuid]; 258 259 /* 260 * Become the currently scheduled user thread for this cpu 261 * if we can do so trivially. 262 * 263 * We can steal another thread's current thread designation 264 * on this cpu since if we are running that other thread 265 * must not be, so we can safely deschedule it. 266 */ 267 if (dd->uschedcp == lp) { 268 /* 269 * We are already the current lwp (hot path). 270 */ 271 dd->upri = lp->lwp_priority; 272 } else if (dd->uschedcp == NULL) { 273 /* 274 * We can trivially become the current lwp. 275 */ 276 atomic_set_cpumask(&bsd4_curprocmask, gd->gd_cpumask); 277 dd->uschedcp = lp; 278 dd->upri = lp->lwp_priority; 279 } else if (dd->upri > lp->lwp_priority) { 280 /* 281 * We can steal the current lwp designation from the 282 * olp that was previously assigned to this cpu. 283 */ 284 olp = dd->uschedcp; 285 dd->uschedcp = lp; 286 dd->upri = lp->lwp_priority; 287 lwkt_deschedule(olp->lwp_thread); 288 bsd4_setrunqueue(olp); 289 } else { 290 /* 291 * We cannot become the current lwp, place the lp 292 * on the bsd4 run-queue and deschedule ourselves. 293 */ 294 lwkt_deschedule(lp->lwp_thread); 295 bsd4_setrunqueue(lp); 296 lwkt_switch(); 297 } 298 299 /* 300 * Other threads at our current user priority have already 301 * put in their bids, but we must run any kernel threads 302 * at higher priorities, and we could lose our bid to 303 * another thread trying to return to user mode in the 304 * process. 305 * 306 * If we lose our bid we will be descheduled and put on 307 * the run queue. When we are reactivated we will have 308 * another chance. 309 */ 310 if (lwkt_resched_wanted() || 311 lp->lwp_thread->td_fairq_accum < 0) { 312 lwkt_switch(); 313 } 314 } while (dd->uschedcp != lp); 315 316 crit_exit(); 317 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0); 318 } 319 320 /* 321 * BSD4_RELEASE_CURPROC 322 * 323 * This routine detaches the current thread from the userland scheduler, 324 * usually because the thread needs to run or block in the kernel (at 325 * kernel priority) for a while. 326 * 327 * This routine is also responsible for selecting a new thread to 328 * make the current thread. 329 * 330 * NOTE: This implementation differs from the dummy example in that 331 * bsd4_select_curproc() is able to select the current process, whereas 332 * dummy_select_curproc() is not able to select the current process. 333 * This means we have to NULL out uschedcp. 334 * 335 * Additionally, note that we may already be on a run queue if releasing 336 * via the lwkt_switch() in bsd4_setrunqueue(). 337 * 338 * MPSAFE 339 */ 340 static void 341 bsd4_release_curproc(struct lwp *lp) 342 { 343 globaldata_t gd = mycpu; 344 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid]; 345 346 if (dd->uschedcp == lp) { 347 crit_enter(); 348 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0); 349 dd->uschedcp = NULL; /* don't let lp be selected */ 350 dd->upri = PRIBASE_NULL; 351 atomic_clear_cpumask(&bsd4_curprocmask, gd->gd_cpumask); 352 bsd4_select_curproc(gd); 353 crit_exit(); 354 } 355 } 356 357 /* 358 * BSD4_SELECT_CURPROC 359 * 360 * Select a new current process for this cpu and clear any pending user 361 * reschedule request. The cpu currently has no current process. 362 * 363 * This routine is also responsible for equal-priority round-robining, 364 * typically triggered from bsd4_schedulerclock(). In our dummy example 365 * all the 'user' threads are LWKT scheduled all at once and we just 366 * call lwkt_switch(). 367 * 368 * The calling process is not on the queue and cannot be selected. 369 * 370 * MPSAFE 371 */ 372 static 373 void 374 bsd4_select_curproc(globaldata_t gd) 375 { 376 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid]; 377 struct lwp *nlp; 378 int cpuid = gd->gd_cpuid; 379 380 crit_enter_gd(gd); 381 382 spin_lock(&bsd4_spin); 383 if ((nlp = chooseproc_locked(dd->uschedcp)) != NULL) { 384 atomic_set_cpumask(&bsd4_curprocmask, CPUMASK(cpuid)); 385 dd->upri = nlp->lwp_priority; 386 dd->uschedcp = nlp; 387 spin_unlock(&bsd4_spin); 388 #ifdef SMP 389 lwkt_acquire(nlp->lwp_thread); 390 #endif 391 lwkt_schedule(nlp->lwp_thread); 392 } else { 393 spin_unlock(&bsd4_spin); 394 } 395 #if 0 396 } else if (bsd4_runqcount && (bsd4_rdyprocmask & CPUMASK(cpuid))) { 397 atomic_clear_cpumask(&bsd4_rdyprocmask, CPUMASK(cpuid)); 398 spin_unlock(&bsd4_spin); 399 lwkt_schedule(&dd->helper_thread); 400 } else { 401 spin_unlock(&bsd4_spin); 402 } 403 #endif 404 crit_exit_gd(gd); 405 } 406 407 /* 408 * BSD4_SETRUNQUEUE 409 * 410 * Place the specified lwp on the user scheduler's run queue. This routine 411 * must be called with the thread descheduled. The lwp must be runnable. 412 * 413 * The thread may be the current thread as a special case. 414 * 415 * MPSAFE 416 */ 417 static void 418 bsd4_setrunqueue(struct lwp *lp) 419 { 420 globaldata_t gd; 421 bsd4_pcpu_t dd; 422 #ifdef SMP 423 int cpuid; 424 cpumask_t mask; 425 cpumask_t tmpmask; 426 #endif 427 428 /* 429 * First validate the process state relative to the current cpu. 430 * We don't need the spinlock for this, just a critical section. 431 * We are in control of the process. 432 */ 433 crit_enter(); 434 KASSERT(lp->lwp_stat == LSRUN, ("setrunqueue: lwp not LSRUN")); 435 KASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0, 436 ("lwp %d/%d already on runq! flag %08x/%08x", lp->lwp_proc->p_pid, 437 lp->lwp_tid, lp->lwp_proc->p_flag, lp->lwp_flag)); 438 KKASSERT((lp->lwp_thread->td_flags & TDF_RUNQ) == 0); 439 440 /* 441 * Note: gd and dd are relative to the target thread's last cpu, 442 * NOT our current cpu. 443 */ 444 gd = lp->lwp_thread->td_gd; 445 dd = &bsd4_pcpu[gd->gd_cpuid]; 446 447 /* 448 * This process is not supposed to be scheduled anywhere or assigned 449 * as the current process anywhere. Assert the condition. 450 */ 451 KKASSERT(dd->uschedcp != lp); 452 453 #ifndef SMP 454 /* 455 * If we are not SMP we do not have a scheduler helper to kick 456 * and must directly activate the process if none are scheduled. 457 * 458 * This is really only an issue when bootstrapping init since 459 * the caller in all other cases will be a user process, and 460 * even if released (dd->uschedcp == NULL), that process will 461 * kickstart the scheduler when it returns to user mode from 462 * the kernel. 463 */ 464 if (dd->uschedcp == NULL) { 465 atomic_set_cpumask(&bsd4_curprocmask, gd->gd_cpumask); 466 dd->uschedcp = lp; 467 dd->upri = lp->lwp_priority; 468 lwkt_schedule(lp->lwp_thread); 469 crit_exit(); 470 return; 471 } 472 #endif 473 474 #ifdef SMP 475 /* 476 * XXX fixme. Could be part of a remrunqueue/setrunqueue 477 * operation when the priority is recalculated, so TDF_MIGRATING 478 * may already be set. 479 */ 480 if ((lp->lwp_thread->td_flags & TDF_MIGRATING) == 0) 481 lwkt_giveaway(lp->lwp_thread); 482 #endif 483 484 /* 485 * We lose control of lp the moment we release the spinlock after 486 * having placed lp on the queue. i.e. another cpu could pick it 487 * up and it could exit, or its priority could be further adjusted, 488 * or something like that. 489 */ 490 spin_lock(&bsd4_spin); 491 bsd4_setrunqueue_locked(lp); 492 493 #ifdef SMP 494 /* 495 * Kick the scheduler helper on one of the other cpu's 496 * and request a reschedule if appropriate. 497 * 498 * NOTE: We check all cpus whos rdyprocmask is set. First we 499 * look for cpus without designated lps, then we look for 500 * cpus with designated lps with a worse priority than our 501 * process. 502 */ 503 ++bsd4_scancpu; 504 cpuid = (bsd4_scancpu & 0xFFFF) % ncpus; 505 mask = ~bsd4_curprocmask & bsd4_rdyprocmask & lp->lwp_cpumask & 506 smp_active_mask; 507 508 while (mask) { 509 tmpmask = ~(CPUMASK(cpuid) - 1); 510 if (mask & tmpmask) 511 cpuid = BSFCPUMASK(mask & tmpmask); 512 else 513 cpuid = BSFCPUMASK(mask); 514 gd = globaldata_find(cpuid); 515 dd = &bsd4_pcpu[cpuid]; 516 517 if ((dd->upri & ~PPQMASK) >= (lp->lwp_priority & ~PPQMASK)) 518 goto found; 519 mask &= ~CPUMASK(cpuid); 520 } 521 522 /* 523 * Then cpus which might have a currently running lp 524 */ 525 mask = bsd4_curprocmask & bsd4_rdyprocmask & 526 lp->lwp_cpumask & smp_active_mask; 527 528 while (mask) { 529 tmpmask = ~(CPUMASK(cpuid) - 1); 530 if (mask & tmpmask) 531 cpuid = BSFCPUMASK(mask & tmpmask); 532 else 533 cpuid = BSFCPUMASK(mask); 534 gd = globaldata_find(cpuid); 535 dd = &bsd4_pcpu[cpuid]; 536 537 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK)) 538 goto found; 539 mask &= ~CPUMASK(cpuid); 540 } 541 542 /* 543 * If we cannot find a suitable cpu we reload from bsd4_scancpu 544 * and round-robin. Other cpus will pickup as they release their 545 * current lwps or become ready. 546 * 547 * We only kick the target helper thread in this case, we do not 548 * set the user resched flag because 549 */ 550 cpuid = (bsd4_scancpu & 0xFFFF) % ncpus; 551 gd = globaldata_find(cpuid); 552 dd = &bsd4_pcpu[cpuid]; 553 found: 554 if (gd == mycpu) { 555 spin_unlock(&bsd4_spin); 556 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK)) 557 need_user_resched(); 558 } else { 559 atomic_clear_cpumask(&bsd4_rdyprocmask, CPUMASK(cpuid)); 560 spin_unlock(&bsd4_spin); 561 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK)) 562 lwkt_send_ipiq(gd, need_user_resched_remote, NULL); 563 else 564 lwkt_schedule(&dd->helper_thread); 565 } 566 #else 567 /* 568 * Request a reschedule if appropriate. 569 */ 570 spin_unlock(&bsd4_spin); 571 if ((dd->upri & ~PPQMASK) > (lp->lwp_priority & ~PPQMASK)) { 572 need_user_resched(); 573 } 574 #endif 575 crit_exit(); 576 } 577 578 /* 579 * This routine is called from a systimer IPI. It MUST be MP-safe and 580 * the BGL IS NOT HELD ON ENTRY. This routine is called at ESTCPUFREQ on 581 * each cpu. 582 * 583 * MPSAFE 584 */ 585 static 586 void 587 bsd4_schedulerclock(struct lwp *lp, sysclock_t period, sysclock_t cpstamp) 588 { 589 globaldata_t gd = mycpu; 590 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid]; 591 592 /* 593 * Do we need to round-robin? We round-robin 10 times a second. 594 * This should only occur for cpu-bound batch processes. 595 */ 596 if (++dd->rrcount >= usched_bsd4_rrinterval) { 597 dd->rrcount = 0; 598 need_user_resched(); 599 } 600 601 /* 602 * As the process accumulates cpu time p_estcpu is bumped and may 603 * push the process into another scheduling queue. It typically 604 * takes 4 ticks to bump the queue. 605 */ 606 lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR); 607 608 /* 609 * Reducing p_origcpu over time causes more of our estcpu to be 610 * returned to the parent when we exit. This is a small tweak 611 * for the batch detection heuristic. 612 */ 613 if (lp->lwp_origcpu) 614 --lp->lwp_origcpu; 615 616 /* 617 * Spinlocks also hold a critical section so there should not be 618 * any active. 619 */ 620 KKASSERT(gd->gd_spinlocks_wr == 0); 621 622 bsd4_resetpriority(lp); 623 #if 0 624 /* 625 * if we can't call bsd4_resetpriority for some reason we must call 626 * need user_resched(). 627 */ 628 need_user_resched(); 629 #endif 630 } 631 632 /* 633 * Called from acquire and from kern_synch's one-second timer (one of the 634 * callout helper threads) with a critical section held. 635 * 636 * Decay p_estcpu based on the number of ticks we haven't been running 637 * and our p_nice. As the load increases each process observes a larger 638 * number of idle ticks (because other processes are running in them). 639 * This observation leads to a larger correction which tends to make the 640 * system more 'batchy'. 641 * 642 * Note that no recalculation occurs for a process which sleeps and wakes 643 * up in the same tick. That is, a system doing thousands of context 644 * switches per second will still only do serious estcpu calculations 645 * ESTCPUFREQ times per second. 646 * 647 * MPSAFE 648 */ 649 static 650 void 651 bsd4_recalculate_estcpu(struct lwp *lp) 652 { 653 globaldata_t gd = mycpu; 654 sysclock_t cpbase; 655 int loadfac; 656 int ndecay; 657 int nticks; 658 int nleft; 659 660 /* 661 * We have to subtract periodic to get the last schedclock 662 * timeout time, otherwise we would get the upcoming timeout. 663 * Keep in mind that a process can migrate between cpus and 664 * while the scheduler clock should be very close, boundary 665 * conditions could lead to a small negative delta. 666 */ 667 cpbase = gd->gd_schedclock.time - gd->gd_schedclock.periodic; 668 669 if (lp->lwp_slptime > 1) { 670 /* 671 * Too much time has passed, do a coarse correction. 672 */ 673 lp->lwp_estcpu = lp->lwp_estcpu >> 1; 674 bsd4_resetpriority(lp); 675 lp->lwp_cpbase = cpbase; 676 lp->lwp_cpticks = 0; 677 } else if (lp->lwp_cpbase != cpbase) { 678 /* 679 * Adjust estcpu if we are in a different tick. Don't waste 680 * time if we are in the same tick. 681 * 682 * First calculate the number of ticks in the measurement 683 * interval. The nticks calculation can wind up 0 due to 684 * a bug in the handling of lwp_slptime (as yet not found), 685 * so make sure we do not get a divide by 0 panic. 686 */ 687 nticks = (cpbase - lp->lwp_cpbase) / gd->gd_schedclock.periodic; 688 if (nticks <= 0) 689 nticks = 1; 690 updatepcpu(lp, lp->lwp_cpticks, nticks); 691 692 if ((nleft = nticks - lp->lwp_cpticks) < 0) 693 nleft = 0; 694 if (usched_debug == lp->lwp_proc->p_pid) { 695 kprintf("pid %d tid %d estcpu %d cpticks %d nticks %d nleft %d", 696 lp->lwp_proc->p_pid, lp->lwp_tid, lp->lwp_estcpu, 697 lp->lwp_cpticks, nticks, nleft); 698 } 699 700 /* 701 * Calculate a decay value based on ticks remaining scaled 702 * down by the instantanious load and p_nice. 703 */ 704 if ((loadfac = bsd4_runqcount) < 2) 705 loadfac = 2; 706 ndecay = nleft * usched_bsd4_decay * 2 * 707 (PRIO_MAX * 2 - lp->lwp_proc->p_nice) / (loadfac * PRIO_MAX * 2); 708 709 /* 710 * Adjust p_estcpu. Handle a border case where batch jobs 711 * can get stalled long enough to decay to zero when they 712 * shouldn't. 713 */ 714 if (lp->lwp_estcpu > ndecay * 2) 715 lp->lwp_estcpu -= ndecay; 716 else 717 lp->lwp_estcpu >>= 1; 718 719 if (usched_debug == lp->lwp_proc->p_pid) 720 kprintf(" ndecay %d estcpu %d\n", ndecay, lp->lwp_estcpu); 721 bsd4_resetpriority(lp); 722 lp->lwp_cpbase = cpbase; 723 lp->lwp_cpticks = 0; 724 } 725 } 726 727 /* 728 * Compute the priority of a process when running in user mode. 729 * Arrange to reschedule if the resulting priority is better 730 * than that of the current process. 731 * 732 * This routine may be called with any process. 733 * 734 * This routine is called by fork1() for initial setup with the process 735 * of the run queue, and also may be called normally with the process on or 736 * off the run queue. 737 * 738 * MPSAFE 739 */ 740 static void 741 bsd4_resetpriority(struct lwp *lp) 742 { 743 bsd4_pcpu_t dd; 744 int newpriority; 745 u_short newrqtype; 746 int reschedcpu; 747 748 /* 749 * Calculate the new priority and queue type 750 */ 751 crit_enter(); 752 spin_lock(&bsd4_spin); 753 754 newrqtype = lp->lwp_rtprio.type; 755 756 switch(newrqtype) { 757 case RTP_PRIO_REALTIME: 758 case RTP_PRIO_FIFO: 759 newpriority = PRIBASE_REALTIME + 760 (lp->lwp_rtprio.prio & PRIMASK); 761 break; 762 case RTP_PRIO_NORMAL: 763 newpriority = (lp->lwp_proc->p_nice - PRIO_MIN) * PPQ / NICEPPQ; 764 newpriority += lp->lwp_estcpu * PPQ / ESTCPUPPQ; 765 newpriority = newpriority * MAXPRI / (PRIO_RANGE * PPQ / 766 NICEPPQ + ESTCPUMAX * PPQ / ESTCPUPPQ); 767 newpriority = PRIBASE_NORMAL + (newpriority & PRIMASK); 768 break; 769 case RTP_PRIO_IDLE: 770 newpriority = PRIBASE_IDLE + (lp->lwp_rtprio.prio & PRIMASK); 771 break; 772 case RTP_PRIO_THREAD: 773 newpriority = PRIBASE_THREAD + (lp->lwp_rtprio.prio & PRIMASK); 774 break; 775 default: 776 panic("Bad RTP_PRIO %d", newrqtype); 777 /* NOT REACHED */ 778 } 779 780 /* 781 * The newpriority incorporates the queue type so do a simple masked 782 * check to determine if the process has moved to another queue. If 783 * it has, and it is currently on a run queue, then move it. 784 */ 785 if ((lp->lwp_priority ^ newpriority) & ~PPQMASK) { 786 lp->lwp_priority = newpriority; 787 if (lp->lwp_flag & LWP_ONRUNQ) { 788 bsd4_remrunqueue_locked(lp); 789 lp->lwp_rqtype = newrqtype; 790 lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ; 791 bsd4_setrunqueue_locked(lp); 792 reschedcpu = lp->lwp_thread->td_gd->gd_cpuid; 793 } else { 794 lp->lwp_rqtype = newrqtype; 795 lp->lwp_rqindex = (newpriority & PRIMASK) / PPQ; 796 reschedcpu = -1; 797 } 798 } else { 799 lp->lwp_priority = newpriority; 800 reschedcpu = -1; 801 } 802 803 /* 804 * Determine if we need to reschedule the target cpu. This only 805 * occurs if the LWP is already on a scheduler queue, which means 806 * that idle cpu notification has already occured. At most we 807 * need only issue a need_user_resched() on the appropriate cpu. 808 * 809 * The LWP may be owned by a CPU different from the current one, 810 * in which case dd->uschedcp may be modified without an MP lock 811 * or a spinlock held. The worst that happens is that the code 812 * below causes a spurious need_user_resched() on the target CPU 813 * and dd->pri to be wrong for a short period of time, both of 814 * which are harmless. 815 */ 816 if (reschedcpu >= 0) { 817 dd = &bsd4_pcpu[reschedcpu]; 818 if ((bsd4_rdyprocmask & CPUMASK(reschedcpu)) && 819 (dd->upri & ~PRIMASK) > (lp->lwp_priority & ~PRIMASK)) { 820 #ifdef SMP 821 if (reschedcpu == mycpu->gd_cpuid) { 822 spin_unlock(&bsd4_spin); 823 need_user_resched(); 824 } else { 825 spin_unlock(&bsd4_spin); 826 atomic_clear_cpumask(&bsd4_rdyprocmask, 827 CPUMASK(reschedcpu)); 828 lwkt_send_ipiq(lp->lwp_thread->td_gd, 829 need_user_resched_remote, NULL); 830 } 831 #else 832 spin_unlock(&bsd4_spin); 833 need_user_resched(); 834 #endif 835 } else { 836 spin_unlock(&bsd4_spin); 837 } 838 } else { 839 spin_unlock(&bsd4_spin); 840 } 841 crit_exit(); 842 } 843 844 /* 845 * MPSAFE 846 */ 847 static 848 void 849 bsd4_yield(struct lwp *lp) 850 { 851 #if 0 852 /* FUTURE (or something similar) */ 853 switch(lp->lwp_rqtype) { 854 case RTP_PRIO_NORMAL: 855 lp->lwp_estcpu = ESTCPULIM(lp->lwp_estcpu + ESTCPUINCR); 856 break; 857 default: 858 break; 859 } 860 #endif 861 need_user_resched(); 862 } 863 864 /* 865 * Called from fork1() when a new child process is being created. 866 * 867 * Give the child process an initial estcpu that is more batch then 868 * its parent and dock the parent for the fork (but do not 869 * reschedule the parent). This comprises the main part of our batch 870 * detection heuristic for both parallel forking and sequential execs. 871 * 872 * Interactive processes will decay the boosted estcpu quickly while batch 873 * processes will tend to compound it. 874 * XXX lwp should be "spawning" instead of "forking" 875 * 876 * MPSAFE 877 */ 878 static void 879 bsd4_forking(struct lwp *plp, struct lwp *lp) 880 { 881 lp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ); 882 lp->lwp_origcpu = lp->lwp_estcpu; 883 plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + ESTCPUPPQ); 884 } 885 886 /* 887 * Called when the parent reaps a child. Propogate cpu use by the child 888 * back to the parent. 889 * 890 * MPSAFE 891 */ 892 static void 893 bsd4_exiting(struct lwp *plp, struct lwp *lp) 894 { 895 int delta; 896 897 if (plp->lwp_proc->p_pid != 1) { 898 delta = lp->lwp_estcpu - lp->lwp_origcpu; 899 if (delta > 0) 900 plp->lwp_estcpu = ESTCPULIM(plp->lwp_estcpu + delta); 901 } 902 } 903 904 905 /* 906 * chooseproc() is called when a cpu needs a user process to LWKT schedule, 907 * it selects a user process and returns it. If chklp is non-NULL and chklp 908 * has a better or equal priority then the process that would otherwise be 909 * chosen, NULL is returned. 910 * 911 * Until we fix the RUNQ code the chklp test has to be strict or we may 912 * bounce between processes trying to acquire the current process designation. 913 * 914 * MPSAFE - must be called with bsd4_spin exclusive held. The spinlock is 915 * left intact through the entire routine. 916 */ 917 static 918 struct lwp * 919 chooseproc_locked(struct lwp *chklp) 920 { 921 struct lwp *lp; 922 struct rq *q; 923 u_int32_t *which, *which2; 924 u_int32_t pri; 925 u_int32_t rtqbits; 926 u_int32_t tsqbits; 927 u_int32_t idqbits; 928 cpumask_t cpumask; 929 930 rtqbits = bsd4_rtqueuebits; 931 tsqbits = bsd4_queuebits; 932 idqbits = bsd4_idqueuebits; 933 cpumask = mycpu->gd_cpumask; 934 935 #ifdef SMP 936 again: 937 #endif 938 if (rtqbits) { 939 pri = bsfl(rtqbits); 940 q = &bsd4_rtqueues[pri]; 941 which = &bsd4_rtqueuebits; 942 which2 = &rtqbits; 943 } else if (tsqbits) { 944 pri = bsfl(tsqbits); 945 q = &bsd4_queues[pri]; 946 which = &bsd4_queuebits; 947 which2 = &tsqbits; 948 } else if (idqbits) { 949 pri = bsfl(idqbits); 950 q = &bsd4_idqueues[pri]; 951 which = &bsd4_idqueuebits; 952 which2 = &idqbits; 953 } else { 954 return NULL; 955 } 956 lp = TAILQ_FIRST(q); 957 KASSERT(lp, ("chooseproc: no lwp on busy queue")); 958 959 #ifdef SMP 960 while ((lp->lwp_cpumask & cpumask) == 0) { 961 lp = TAILQ_NEXT(lp, lwp_procq); 962 if (lp == NULL) { 963 *which2 &= ~(1 << pri); 964 goto again; 965 } 966 } 967 #endif 968 969 /* 970 * If the passed lwp <chklp> is reasonably close to the selected 971 * lwp <lp>, return NULL (indicating that <chklp> should be kept). 972 * 973 * Note that we must error on the side of <chklp> to avoid bouncing 974 * between threads in the acquire code. 975 */ 976 if (chklp) { 977 if (chklp->lwp_priority < lp->lwp_priority + PPQ) 978 return(NULL); 979 } 980 981 #ifdef SMP 982 /* 983 * If the chosen lwp does not reside on this cpu spend a few 984 * cycles looking for a better candidate at the same priority level. 985 * This is a fallback check, setrunqueue() tries to wakeup the 986 * correct cpu and is our front-line affinity. 987 */ 988 if (lp->lwp_thread->td_gd != mycpu && 989 (chklp = TAILQ_NEXT(lp, lwp_procq)) != NULL 990 ) { 991 if (chklp->lwp_thread->td_gd == mycpu) { 992 ++choose_affinity; 993 lp = chklp; 994 } 995 } 996 #endif 997 998 TAILQ_REMOVE(q, lp, lwp_procq); 999 --bsd4_runqcount; 1000 if (TAILQ_EMPTY(q)) 1001 *which &= ~(1 << pri); 1002 KASSERT((lp->lwp_flag & LWP_ONRUNQ) != 0, ("not on runq6!")); 1003 lp->lwp_flag &= ~LWP_ONRUNQ; 1004 return lp; 1005 } 1006 1007 #ifdef SMP 1008 1009 static 1010 void 1011 need_user_resched_remote(void *dummy) 1012 { 1013 globaldata_t gd = mycpu; 1014 bsd4_pcpu_t dd = &bsd4_pcpu[gd->gd_cpuid]; 1015 1016 need_user_resched(); 1017 lwkt_schedule(&dd->helper_thread); 1018 } 1019 1020 #endif 1021 1022 /* 1023 * bsd4_remrunqueue_locked() removes a given process from the run queue 1024 * that it is on, clearing the queue busy bit if it becomes empty. 1025 * 1026 * Note that user process scheduler is different from the LWKT schedule. 1027 * The user process scheduler only manages user processes but it uses LWKT 1028 * underneath, and a user process operating in the kernel will often be 1029 * 'released' from our management. 1030 * 1031 * MPSAFE - bsd4_spin must be held exclusively on call 1032 */ 1033 static void 1034 bsd4_remrunqueue_locked(struct lwp *lp) 1035 { 1036 struct rq *q; 1037 u_int32_t *which; 1038 u_int8_t pri; 1039 1040 KKASSERT(lp->lwp_flag & LWP_ONRUNQ); 1041 lp->lwp_flag &= ~LWP_ONRUNQ; 1042 --bsd4_runqcount; 1043 KKASSERT(bsd4_runqcount >= 0); 1044 1045 pri = lp->lwp_rqindex; 1046 switch(lp->lwp_rqtype) { 1047 case RTP_PRIO_NORMAL: 1048 q = &bsd4_queues[pri]; 1049 which = &bsd4_queuebits; 1050 break; 1051 case RTP_PRIO_REALTIME: 1052 case RTP_PRIO_FIFO: 1053 q = &bsd4_rtqueues[pri]; 1054 which = &bsd4_rtqueuebits; 1055 break; 1056 case RTP_PRIO_IDLE: 1057 q = &bsd4_idqueues[pri]; 1058 which = &bsd4_idqueuebits; 1059 break; 1060 default: 1061 panic("remrunqueue: invalid rtprio type"); 1062 /* NOT REACHED */ 1063 } 1064 TAILQ_REMOVE(q, lp, lwp_procq); 1065 if (TAILQ_EMPTY(q)) { 1066 KASSERT((*which & (1 << pri)) != 0, 1067 ("remrunqueue: remove from empty queue")); 1068 *which &= ~(1 << pri); 1069 } 1070 } 1071 1072 /* 1073 * bsd4_setrunqueue_locked() 1074 * 1075 * Add a process whos rqtype and rqindex had previously been calculated 1076 * onto the appropriate run queue. Determine if the addition requires 1077 * a reschedule on a cpu and return the cpuid or -1. 1078 * 1079 * NOTE: Lower priorities are better priorities. 1080 * 1081 * MPSAFE - bsd4_spin must be held exclusively on call 1082 */ 1083 static void 1084 bsd4_setrunqueue_locked(struct lwp *lp) 1085 { 1086 struct rq *q; 1087 u_int32_t *which; 1088 int pri; 1089 1090 KKASSERT((lp->lwp_flag & LWP_ONRUNQ) == 0); 1091 lp->lwp_flag |= LWP_ONRUNQ; 1092 ++bsd4_runqcount; 1093 1094 pri = lp->lwp_rqindex; 1095 1096 switch(lp->lwp_rqtype) { 1097 case RTP_PRIO_NORMAL: 1098 q = &bsd4_queues[pri]; 1099 which = &bsd4_queuebits; 1100 break; 1101 case RTP_PRIO_REALTIME: 1102 case RTP_PRIO_FIFO: 1103 q = &bsd4_rtqueues[pri]; 1104 which = &bsd4_rtqueuebits; 1105 break; 1106 case RTP_PRIO_IDLE: 1107 q = &bsd4_idqueues[pri]; 1108 which = &bsd4_idqueuebits; 1109 break; 1110 default: 1111 panic("remrunqueue: invalid rtprio type"); 1112 /* NOT REACHED */ 1113 } 1114 1115 /* 1116 * Add to the correct queue and set the appropriate bit. If no 1117 * lower priority (i.e. better) processes are in the queue then 1118 * we want a reschedule, calculate the best cpu for the job. 1119 * 1120 * Always run reschedules on the LWPs original cpu. 1121 */ 1122 TAILQ_INSERT_TAIL(q, lp, lwp_procq); 1123 *which |= 1 << pri; 1124 } 1125 1126 #ifdef SMP 1127 1128 /* 1129 * For SMP systems a user scheduler helper thread is created for each 1130 * cpu and is used to allow one cpu to wakeup another for the purposes of 1131 * scheduling userland threads from setrunqueue(). 1132 * 1133 * UP systems do not need the helper since there is only one cpu. 1134 * 1135 * We can't use the idle thread for this because we might block. 1136 * Additionally, doing things this way allows us to HLT idle cpus 1137 * on MP systems. 1138 * 1139 * MPSAFE 1140 */ 1141 static void 1142 sched_thread(void *dummy) 1143 { 1144 globaldata_t gd; 1145 bsd4_pcpu_t dd; 1146 struct lwp *nlp; 1147 cpumask_t mask; 1148 int cpuid; 1149 #ifdef SMP 1150 cpumask_t tmpmask; 1151 int tmpid; 1152 #endif 1153 1154 gd = mycpu; 1155 cpuid = gd->gd_cpuid; /* doesn't change */ 1156 mask = gd->gd_cpumask; /* doesn't change */ 1157 dd = &bsd4_pcpu[cpuid]; 1158 1159 /* 1160 * Since we are woken up only when no user processes are scheduled 1161 * on a cpu, we can run at an ultra low priority. 1162 */ 1163 lwkt_setpri_self(TDPRI_USER_SCHEDULER); 1164 1165 for (;;) { 1166 /* 1167 * We use the LWKT deschedule-interlock trick to avoid racing 1168 * bsd4_rdyprocmask. This means we cannot block through to the 1169 * manual lwkt_switch() call we make below. 1170 */ 1171 crit_enter_gd(gd); 1172 lwkt_deschedule_self(gd->gd_curthread); 1173 spin_lock(&bsd4_spin); 1174 atomic_set_cpumask(&bsd4_rdyprocmask, mask); 1175 1176 clear_user_resched(); /* This satisfied the reschedule request */ 1177 dd->rrcount = 0; /* Reset the round-robin counter */ 1178 1179 if ((bsd4_curprocmask & mask) == 0) { 1180 /* 1181 * No thread is currently scheduled. 1182 */ 1183 KKASSERT(dd->uschedcp == NULL); 1184 if ((nlp = chooseproc_locked(NULL)) != NULL) { 1185 atomic_set_cpumask(&bsd4_curprocmask, mask); 1186 dd->upri = nlp->lwp_priority; 1187 dd->uschedcp = nlp; 1188 spin_unlock(&bsd4_spin); 1189 lwkt_acquire(nlp->lwp_thread); 1190 lwkt_schedule(nlp->lwp_thread); 1191 } else { 1192 spin_unlock(&bsd4_spin); 1193 } 1194 } else if (bsd4_runqcount) { 1195 if ((nlp = chooseproc_locked(dd->uschedcp)) != NULL) { 1196 dd->upri = nlp->lwp_priority; 1197 dd->uschedcp = nlp; 1198 spin_unlock(&bsd4_spin); 1199 lwkt_acquire(nlp->lwp_thread); 1200 lwkt_schedule(nlp->lwp_thread); 1201 } else { 1202 /* 1203 * CHAINING CONDITION TRAIN 1204 * 1205 * We could not deal with the scheduler wakeup 1206 * request on this cpu, locate a ready scheduler 1207 * with no current lp assignment and chain to it. 1208 * 1209 * This ensures that a wakeup race which fails due 1210 * to priority test does not leave other unscheduled 1211 * cpus idle when the runqueue is not empty. 1212 */ 1213 tmpmask = ~bsd4_curprocmask & bsd4_rdyprocmask & 1214 smp_active_mask; 1215 if (tmpmask) { 1216 tmpid = BSFCPUMASK(tmpmask); 1217 gd = globaldata_find(cpuid); 1218 dd = &bsd4_pcpu[cpuid]; 1219 atomic_clear_cpumask(&bsd4_rdyprocmask, 1220 CPUMASK(tmpid)); 1221 spin_unlock(&bsd4_spin); 1222 lwkt_schedule(&dd->helper_thread); 1223 } else { 1224 spin_unlock(&bsd4_spin); 1225 } 1226 } 1227 } else { 1228 /* 1229 * The runq is empty. 1230 */ 1231 spin_unlock(&bsd4_spin); 1232 } 1233 crit_exit_gd(gd); 1234 lwkt_switch(); 1235 } 1236 } 1237 1238 /* 1239 * Setup our scheduler helpers. Note that curprocmask bit 0 has already 1240 * been cleared by rqinit() and we should not mess with it further. 1241 */ 1242 static void 1243 sched_thread_cpu_init(void) 1244 { 1245 int i; 1246 1247 if (bootverbose) 1248 kprintf("start scheduler helpers on cpus:"); 1249 1250 for (i = 0; i < ncpus; ++i) { 1251 bsd4_pcpu_t dd = &bsd4_pcpu[i]; 1252 cpumask_t mask = CPUMASK(i); 1253 1254 if ((mask & smp_active_mask) == 0) 1255 continue; 1256 1257 if (bootverbose) 1258 kprintf(" %d", i); 1259 1260 lwkt_create(sched_thread, NULL, NULL, &dd->helper_thread, 1261 TDF_STOPREQ, i, "usched %d", i); 1262 1263 /* 1264 * Allow user scheduling on the target cpu. cpu #0 has already 1265 * been enabled in rqinit(). 1266 */ 1267 if (i) 1268 atomic_clear_cpumask(&bsd4_curprocmask, mask); 1269 atomic_set_cpumask(&bsd4_rdyprocmask, mask); 1270 dd->upri = PRIBASE_NULL; 1271 } 1272 if (bootverbose) 1273 kprintf("\n"); 1274 } 1275 SYSINIT(uschedtd, SI_BOOT2_USCHED, SI_ORDER_SECOND, 1276 sched_thread_cpu_init, NULL) 1277 1278 #endif 1279 1280