1 0 stevel /* 2 0 stevel * CDDL HEADER START 3 0 stevel * 4 0 stevel * The contents of this file are subject to the terms of the 5 3426 johansen * Common Development and Distribution License (the "License"). 6 3426 johansen * You may not use this file except in compliance with the License. 7 0 stevel * 8 0 stevel * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 0 stevel * or http://www.opensolaris.org/os/licensing. 10 0 stevel * See the License for the specific language governing permissions 11 0 stevel * and limitations under the License. 12 0 stevel * 13 0 stevel * When distributing Covered Code, include this CDDL HEADER in each 14 0 stevel * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 0 stevel * If applicable, add the following below this CDDL HEADER, with the 16 0 stevel * fields enclosed by brackets "[]" replaced with your own identifying 17 0 stevel * information: Portions Copyright [yyyy] [name of copyright owner] 18 0 stevel * 19 0 stevel * CDDL HEADER END 20 0 stevel */ 21 0 stevel /* 22 11173 Jonathan * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 0 stevel * Use is subject to license terms. 24 0 stevel */ 25 0 stevel 26 0 stevel #include <sys/types.h> 27 0 stevel #include <sys/param.h> 28 0 stevel #include <sys/systm.h> 29 0 stevel #include <sys/user.h> 30 0 stevel #include <sys/proc.h> 31 0 stevel #include <sys/cpuvar.h> 32 0 stevel #include <sys/thread.h> 33 0 stevel #include <sys/debug.h> 34 0 stevel #include <sys/msacct.h> 35 0 stevel #include <sys/time.h> 36 0 stevel 37 0 stevel /* 38 0 stevel * Mega-theory block comment: 39 0 stevel * 40 0 stevel * Microstate accounting uses finite states and the transitions between these 41 0 stevel * states to measure timing and accounting information. The state information 42 0 stevel * is presently tracked for threads (via microstate accounting) and cpus (via 43 0 stevel * cpu microstate accounting). In each case, these accounting mechanisms use 44 0 stevel * states and transitions to measure time spent in each state instead of 45 0 stevel * clock-based sampling methodologies. 46 0 stevel * 47 0 stevel * For microstate accounting: 48 0 stevel * state transitions are accomplished by calling new_mstate() to switch between 49 0 stevel * states. Transitions from a sleeping state (LMS_SLEEP and LMS_STOPPED) occur 50 0 stevel * by calling restore_mstate() which restores a thread to its previously running 51 0 stevel * state. This code is primarialy executed by the dispatcher in disp() before 52 0 stevel * running a process that was put to sleep. If the thread was not in a sleeping 53 0 stevel * state, this call has little effect other than to update the count of time the 54 0 stevel * thread has spent waiting on run-queues in its lifetime. 55 0 stevel * 56 0 stevel * For cpu microstate accounting: 57 0 stevel * Cpu microstate accounting is similar to the microstate accounting for threads 58 0 stevel * but it tracks user, system, and idle time for cpus. Cpu microstate 59 0 stevel * accounting does not track interrupt times as there is a pre-existing 60 0 stevel * interrupt accounting mechanism for this purpose. Cpu microstate accounting 61 0 stevel * tracks time that user threads have spent active, idle, or in the system on a 62 0 stevel * given cpu. Cpu microstate accounting has fewer states which allows it to 63 0 stevel * have better defined transitions. The states transition in the following 64 0 stevel * order: 65 0 stevel * 66 0 stevel * CMS_USER <-> CMS_SYSTEM <-> CMS_IDLE 67 0 stevel * 68 0 stevel * In order to get to the idle state, the cpu microstate must first go through 69 0 stevel * the system state, and vice-versa for the user state from idle. The switching 70 0 stevel * of the microstates from user to system is done as part of the regular thread 71 0 stevel * microstate accounting code, except for the idle state which is switched by 72 0 stevel * the dispatcher before it runs the idle loop. 73 0 stevel * 74 0 stevel * Cpu percentages: 75 0 stevel * Cpu percentages are now handled by and based upon microstate accounting 76 0 stevel * information (the same is true for load averages). The routines which handle 77 0 stevel * the growing/shrinking and exponentiation of cpu percentages have been moved 78 0 stevel * here as it now makes more sense for them to be generated from the microstate 79 0 stevel * code. Cpu percentages are generated similarly to the way they were before; 80 0 stevel * however, now they are based upon high-resolution timestamps and the 81 0 stevel * timestamps are modified at various state changes instead of during a clock() 82 0 stevel * interrupt. This allows us to generate more accurate cpu percentages which 83 0 stevel * are also in-sync with microstate data. 84 0 stevel */ 85 0 stevel 86 0 stevel /* 87 0 stevel * Initialize the microstate level and the 88 0 stevel * associated accounting information for an LWP. 89 0 stevel */ 90 0 stevel void 91 0 stevel init_mstate( 92 0 stevel kthread_t *t, 93 0 stevel int init_state) 94 0 stevel { 95 0 stevel struct mstate *ms; 96 0 stevel klwp_t *lwp; 97 0 stevel hrtime_t curtime; 98 0 stevel 99 0 stevel ASSERT(init_state != LMS_WAIT_CPU); 100 0 stevel ASSERT((unsigned)init_state < NMSTATES); 101 0 stevel 102 0 stevel if ((lwp = ttolwp(t)) != NULL) { 103 0 stevel ms = &lwp->lwp_mstate; 104 0 stevel curtime = gethrtime_unscaled(); 105 0 stevel ms->ms_prev = LMS_SYSTEM; 106 0 stevel ms->ms_start = curtime; 107 0 stevel ms->ms_term = 0; 108 0 stevel ms->ms_state_start = curtime; 109 0 stevel t->t_mstate = init_state; 110 0 stevel t->t_waitrq = 0; 111 0 stevel t->t_hrtime = curtime; 112 0 stevel if ((t->t_proc_flag & TP_MSACCT) == 0) 113 0 stevel t->t_proc_flag |= TP_MSACCT; 114 0 stevel bzero((caddr_t)&ms->ms_acct[0], sizeof (ms->ms_acct)); 115 0 stevel } 116 0 stevel } 117 0 stevel 118 0 stevel /* 119 0 stevel * Initialize the microstate level and associated accounting information 120 0 stevel * for the specified cpu 121 0 stevel */ 122 0 stevel 123 0 stevel void 124 0 stevel init_cpu_mstate( 125 0 stevel cpu_t *cpu, 126 0 stevel int init_state) 127 0 stevel { 128 0 stevel ASSERT(init_state != CMS_DISABLED); 129 0 stevel 130 0 stevel cpu->cpu_mstate = init_state; 131 0 stevel cpu->cpu_mstate_start = gethrtime_unscaled(); 132 0 stevel cpu->cpu_waitrq = 0; 133 0 stevel bzero((caddr_t)&cpu->cpu_acct[0], sizeof (cpu->cpu_acct)); 134 0 stevel } 135 0 stevel 136 0 stevel /* 137 0 stevel * sets cpu state to OFFLINE. We don't actually track this time, 138 0 stevel * but it serves as a useful placeholder state for when we're not 139 0 stevel * doing anything. 140 0 stevel */ 141 0 stevel 142 0 stevel void 143 0 stevel term_cpu_mstate(struct cpu *cpu) 144 0 stevel { 145 0 stevel ASSERT(cpu->cpu_mstate != CMS_DISABLED); 146 0 stevel cpu->cpu_mstate = CMS_DISABLED; 147 0 stevel cpu->cpu_mstate_start = 0; 148 0 stevel } 149 0 stevel 150 1058 esolom /* NEW_CPU_MSTATE comments inline in new_cpu_mstate below. */ 151 1058 esolom 152 1058 esolom #define NEW_CPU_MSTATE(state) \ 153 1058 esolom gen = cpu->cpu_mstate_gen; \ 154 1058 esolom cpu->cpu_mstate_gen = 0; \ 155 1058 esolom /* Need membar_producer() here if stores not ordered / TSO */ \ 156 1058 esolom cpu->cpu_acct[cpu->cpu_mstate] += curtime - cpu->cpu_mstate_start; \ 157 1058 esolom cpu->cpu_mstate = state; \ 158 1058 esolom cpu->cpu_mstate_start = curtime; \ 159 1058 esolom /* Need membar_producer() here if stores not ordered / TSO */ \ 160 1058 esolom cpu->cpu_mstate_gen = (++gen == 0) ? 1 : gen; 161 1058 esolom 162 0 stevel void 163 590 esolom new_cpu_mstate(int cmstate, hrtime_t curtime) 164 0 stevel { 165 590 esolom cpu_t *cpu = CPU; 166 590 esolom uint16_t gen; 167 0 stevel 168 0 stevel ASSERT(cpu->cpu_mstate != CMS_DISABLED); 169 0 stevel ASSERT(cmstate < NCMSTATES); 170 0 stevel ASSERT(cmstate != CMS_DISABLED); 171 590 esolom 172 590 esolom /* 173 590 esolom * This function cannot be re-entrant on a given CPU. As such, 174 590 esolom * we ASSERT and panic if we are called on behalf of an interrupt. 175 590 esolom * The one exception is for an interrupt which has previously 176 590 esolom * blocked. Such an interrupt is being scheduled by the dispatcher 177 590 esolom * just like a normal thread, and as such cannot arrive here 178 590 esolom * in a re-entrant manner. 179 590 esolom */ 180 590 esolom 181 590 esolom ASSERT(!CPU_ON_INTR(cpu) && curthread->t_intr == NULL); 182 0 stevel ASSERT(curthread->t_preempt > 0 || curthread == cpu->cpu_idle_thread); 183 0 stevel 184 590 esolom /* 185 590 esolom * LOCKING, or lack thereof: 186 590 esolom * 187 590 esolom * Updates to CPU mstate can only be made by the CPU 188 590 esolom * itself, and the above check to ignore interrupts 189 590 esolom * should prevent recursion into this function on a given 190 590 esolom * processor. i.e. no possible write contention. 191 590 esolom * 192 590 esolom * However, reads of CPU mstate can occur at any time 193 590 esolom * from any CPU. Any locking added to this code path 194 590 esolom * would seriously impact syscall performance. So, 195 590 esolom * instead we have a best-effort protection for readers. 196 590 esolom * The reader will want to account for any time between 197 590 esolom * cpu_mstate_start and the present time. This requires 198 590 esolom * some guarantees that the reader is getting coherent 199 590 esolom * information. 200 590 esolom * 201 590 esolom * We use a generation counter, which is set to 0 before 202 590 esolom * we start making changes, and is set to a new value 203 590 esolom * after we're done. Someone reading the CPU mstate 204 590 esolom * should check for the same non-zero value of this 205 590 esolom * counter both before and after reading all state. The 206 590 esolom * important point is that the reader is not a 207 590 esolom * performance-critical path, but this function is. 208 1058 esolom * 209 1058 esolom * The ordering of writes is critical. cpu_mstate_gen must 210 1058 esolom * be visibly zero on all CPUs before we change cpu_mstate 211 1058 esolom * and cpu_mstate_start. Additionally, cpu_mstate_gen must 212 1058 esolom * not be restored to oldgen+1 until after all of the other 213 1058 esolom * writes have become visible. 214 1058 esolom * 215 1058 esolom * Normally one puts membar_producer() calls to accomplish 216 1058 esolom * this. Unfortunately this routine is extremely performance 217 1058 esolom * critical (esp. in syscall_mstate below) and we cannot 218 1058 esolom * afford the additional time, particularly on some x86 219 1058 esolom * architectures with extremely slow sfence calls. On a 220 1058 esolom * CPU which guarantees write ordering (including sparc, x86, 221 1058 esolom * and amd64) this is not a problem. The compiler could still 222 1058 esolom * reorder the writes, so we make the four cpu fields 223 1058 esolom * volatile to prevent this. 224 1058 esolom * 225 1058 esolom * TSO warning: should we port to a non-TSO (or equivalent) 226 1058 esolom * CPU, this will break. 227 1058 esolom * 228 1058 esolom * The reader stills needs the membar_consumer() calls because, 229 1058 esolom * although the volatiles prevent the compiler from reordering 230 1058 esolom * loads, the CPU can still do so. 231 590 esolom */ 232 590 esolom 233 1058 esolom NEW_CPU_MSTATE(cmstate); 234 3792 akolb } 235 3792 akolb 236 3792 akolb /* 237 3792 akolb * Return an aggregation of user and system CPU time consumed by 238 3792 akolb * the specified thread in scaled nanoseconds. 239 3792 akolb */ 240 3792 akolb hrtime_t 241 3792 akolb mstate_thread_onproc_time(kthread_t *t) 242 3792 akolb { 243 3792 akolb hrtime_t aggr_time; 244 3792 akolb hrtime_t now; 245 11173 Jonathan hrtime_t waitrq; 246 3792 akolb hrtime_t state_start; 247 3792 akolb struct mstate *ms; 248 3792 akolb klwp_t *lwp; 249 3792 akolb int mstate; 250 3792 akolb 251 3792 akolb ASSERT(THREAD_LOCK_HELD(t)); 252 3792 akolb 253 3792 akolb if ((lwp = ttolwp(t)) == NULL) 254 3792 akolb return (0); 255 3792 akolb 256 3792 akolb mstate = t->t_mstate; 257 11173 Jonathan waitrq = t->t_waitrq; 258 3792 akolb ms = &lwp->lwp_mstate; 259 3792 akolb state_start = ms->ms_state_start; 260 3792 akolb 261 3792 akolb aggr_time = ms->ms_acct[LMS_USER] + 262 3792 akolb ms->ms_acct[LMS_SYSTEM] + ms->ms_acct[LMS_TRAP]; 263 3792 akolb 264 3792 akolb now = gethrtime_unscaled(); 265 3792 akolb 266 3792 akolb /* 267 3792 akolb * NOTE: gethrtime_unscaled on X86 taken on different CPUs is 268 3792 akolb * inconsistent, so it is possible that now < state_start. 269 3792 akolb */ 270 11173 Jonathan if (mstate == LMS_USER || mstate == LMS_SYSTEM || mstate == LMS_TRAP) { 271 11173 Jonathan /* if waitrq is zero, count all of the time. */ 272 11173 Jonathan if (waitrq == 0) { 273 11173 Jonathan waitrq = now; 274 11173 Jonathan } 275 11173 Jonathan 276 11173 Jonathan if (waitrq > state_start) { 277 11173 Jonathan aggr_time += waitrq - state_start; 278 11173 Jonathan } 279 3792 akolb } 280 3792 akolb 281 3792 akolb scalehrtime(&aggr_time); 282 3792 akolb return (aggr_time); 283 11173 Jonathan } 284 11173 Jonathan 285 11173 Jonathan /* 286 11173 Jonathan * Return the amount of onproc and runnable time this thread has experienced. 287 11173 Jonathan * 288 11173 Jonathan * Because the fields we read are not protected by locks when updated 289 11173 Jonathan * by the thread itself, this is an inherently racey interface. In 290 11173 Jonathan * particular, the ASSERT(THREAD_LOCK_HELD(t)) doesn't guarantee as much 291 11173 Jonathan * as it might appear to. 292 11173 Jonathan * 293 11173 Jonathan * The implication for users of this interface is that onproc and runnable 294 11173 Jonathan * are *NOT* monotonically increasing; they may temporarily be larger than 295 11173 Jonathan * they should be. 296 11173 Jonathan */ 297 11173 Jonathan void 298 11173 Jonathan mstate_systhread_times(kthread_t *t, hrtime_t *onproc, hrtime_t *runnable) 299 11173 Jonathan { 300 11173 Jonathan struct mstate *const ms = &ttolwp(t)->lwp_mstate; 301 11173 Jonathan 302 11173 Jonathan int mstate; 303 11173 Jonathan hrtime_t now; 304 11173 Jonathan hrtime_t state_start; 305 11173 Jonathan hrtime_t waitrq; 306 11173 Jonathan hrtime_t aggr_onp; 307 11173 Jonathan hrtime_t aggr_run; 308 11173 Jonathan 309 11173 Jonathan ASSERT(THREAD_LOCK_HELD(t)); 310 11173 Jonathan ASSERT(t->t_procp->p_flag & SSYS); 311 11173 Jonathan ASSERT(ttolwp(t) != NULL); 312 11173 Jonathan 313 11173 Jonathan /* shouldn't be any non-SYSTEM on-CPU time */ 314 11173 Jonathan ASSERT(ms->ms_acct[LMS_USER] == 0); 315 11173 Jonathan ASSERT(ms->ms_acct[LMS_TRAP] == 0); 316 11173 Jonathan 317 11173 Jonathan mstate = t->t_mstate; 318 11173 Jonathan waitrq = t->t_waitrq; 319 11173 Jonathan state_start = ms->ms_state_start; 320 11173 Jonathan 321 11173 Jonathan aggr_onp = ms->ms_acct[LMS_SYSTEM]; 322 11173 Jonathan aggr_run = ms->ms_acct[LMS_WAIT_CPU]; 323 11173 Jonathan 324 11173 Jonathan now = gethrtime_unscaled(); 325 11173 Jonathan 326 11173 Jonathan /* if waitrq == 0, then there is no time to account to TS_RUN */ 327 11173 Jonathan if (waitrq == 0) 328 11173 Jonathan waitrq = now; 329 11173 Jonathan 330 11173 Jonathan /* If there is system time to accumulate, do so */ 331 11173 Jonathan if (mstate == LMS_SYSTEM && state_start < waitrq) 332 11173 Jonathan aggr_onp += waitrq - state_start; 333 11173 Jonathan 334 11173 Jonathan if (waitrq < now) 335 11173 Jonathan aggr_run += now - waitrq; 336 11173 Jonathan 337 11173 Jonathan scalehrtime(&aggr_onp); 338 11173 Jonathan scalehrtime(&aggr_run); 339 11173 Jonathan 340 11173 Jonathan *onproc = aggr_onp; 341 11173 Jonathan *runnable = aggr_run; 342 0 stevel } 343 0 stevel 344 0 stevel /* 345 0 stevel * Return an aggregation of microstate times in scaled nanoseconds (high-res 346 0 stevel * time). This keeps in mind that p_acct is already scaled, and ms_acct is 347 0 stevel * not. 348 0 stevel */ 349 0 stevel hrtime_t 350 0 stevel mstate_aggr_state(proc_t *p, int a_state) 351 0 stevel { 352 0 stevel struct mstate *ms; 353 0 stevel kthread_t *t; 354 0 stevel klwp_t *lwp; 355 0 stevel hrtime_t aggr_time; 356 0 stevel hrtime_t scaledtime; 357 0 stevel 358 0 stevel ASSERT(MUTEX_HELD(&p->p_lock)); 359 0 stevel ASSERT((unsigned)a_state < NMSTATES); 360 0 stevel 361 0 stevel aggr_time = p->p_acct[a_state]; 362 0 stevel if (a_state == LMS_SYSTEM) 363 0 stevel aggr_time += p->p_acct[LMS_TRAP]; 364 0 stevel 365 0 stevel t = p->p_tlist; 366 0 stevel if (t == NULL) 367 0 stevel return (aggr_time); 368 0 stevel 369 0 stevel do { 370 0 stevel if (t->t_proc_flag & TP_LWPEXIT) 371 0 stevel continue; 372 0 stevel 373 0 stevel lwp = ttolwp(t); 374 0 stevel ms = &lwp->lwp_mstate; 375 0 stevel scaledtime = ms->ms_acct[a_state]; 376 0 stevel scalehrtime(&scaledtime); 377 0 stevel aggr_time += scaledtime; 378 0 stevel if (a_state == LMS_SYSTEM) { 379 0 stevel scaledtime = ms->ms_acct[LMS_TRAP]; 380 0 stevel scalehrtime(&scaledtime); 381 0 stevel aggr_time += scaledtime; 382 0 stevel } 383 0 stevel } while ((t = t->t_forw) != p->p_tlist); 384 0 stevel 385 0 stevel return (aggr_time); 386 0 stevel } 387 0 stevel 388 1058 esolom 389 0 stevel void 390 0 stevel syscall_mstate(int fromms, int toms) 391 0 stevel { 392 0 stevel kthread_t *t = curthread; 393 0 stevel struct mstate *ms; 394 0 stevel hrtime_t *mstimep; 395 0 stevel hrtime_t curtime; 396 0 stevel klwp_t *lwp; 397 0 stevel hrtime_t newtime; 398 1058 esolom cpu_t *cpu; 399 1058 esolom uint16_t gen; 400 0 stevel 401 0 stevel if ((lwp = ttolwp(t)) == NULL) 402 0 stevel return; 403 0 stevel 404 0 stevel ASSERT(fromms < NMSTATES); 405 0 stevel ASSERT(toms < NMSTATES); 406 0 stevel 407 0 stevel ms = &lwp->lwp_mstate; 408 0 stevel mstimep = &ms->ms_acct[fromms]; 409 0 stevel curtime = gethrtime_unscaled(); 410 0 stevel newtime = curtime - ms->ms_state_start; 411 0 stevel while (newtime < 0) { 412 0 stevel curtime = gethrtime_unscaled(); 413 0 stevel newtime = curtime - ms->ms_state_start; 414 0 stevel } 415 0 stevel *mstimep += newtime; 416 0 stevel t->t_mstate = toms; 417 0 stevel ms->ms_state_start = curtime; 418 0 stevel ms->ms_prev = fromms; 419 590 esolom kpreempt_disable(); /* don't change CPU while changing CPU's state */ 420 1058 esolom cpu = CPU; 421 1058 esolom ASSERT(cpu == t->t_cpu); 422 1058 esolom if ((toms != LMS_USER) && (cpu->cpu_mstate != CMS_SYSTEM)) { 423 1058 esolom NEW_CPU_MSTATE(CMS_SYSTEM); 424 1058 esolom } else if ((toms == LMS_USER) && (cpu->cpu_mstate != CMS_USER)) { 425 1058 esolom NEW_CPU_MSTATE(CMS_USER); 426 1058 esolom } 427 0 stevel kpreempt_enable(); 428 0 stevel } 429 1058 esolom 430 1058 esolom #undef NEW_CPU_MSTATE 431 0 stevel 432 0 stevel /* 433 0 stevel * The following is for computing the percentage of cpu time used recently 434 0 stevel * by an lwp. The function cpu_decay() is also called from /proc code. 435 0 stevel * 436 0 stevel * exp_x(x): 437 0 stevel * Given x as a 64-bit non-negative scaled integer of arbitrary magnitude, 438 0 stevel * Return exp(-x) as a 64-bit scaled integer in the range [0 .. 1]. 439 0 stevel * 440 0 stevel * Scaling for 64-bit scaled integer: 441 0 stevel * The binary point is to the right of the high-order bit 442 0 stevel * of the low-order 32-bit word. 443 0 stevel */ 444 0 stevel 445 0 stevel #define LSHIFT 31 446 0 stevel #define LSI_ONE ((uint32_t)1 << LSHIFT) /* 32-bit scaled integer 1 */ 447 0 stevel 448 0 stevel #ifdef DEBUG 449 0 stevel uint_t expx_cnt = 0; /* number of calls to exp_x() */ 450 0 stevel uint_t expx_mul = 0; /* number of long multiplies in exp_x() */ 451 0 stevel #endif 452 0 stevel 453 0 stevel static uint64_t 454 0 stevel exp_x(uint64_t x) 455 0 stevel { 456 0 stevel int i; 457 0 stevel uint64_t ull; 458 0 stevel uint32_t ui; 459 0 stevel 460 0 stevel #ifdef DEBUG 461 0 stevel expx_cnt++; 462 0 stevel #endif 463 0 stevel /* 464 0 stevel * By the formula: 465 0 stevel * exp(-x) = exp(-x/2) * exp(-x/2) 466 0 stevel * we keep halving x until it becomes small enough for 467 0 stevel * the following approximation to be accurate enough: 468 0 stevel * exp(-x) = 1 - x 469 0 stevel * We reduce x until it is less than 1/4 (the 2 in LSHIFT-2 below). 470 0 stevel * Our final error will be smaller than 4% . 471 0 stevel */ 472 0 stevel 473 0 stevel /* 474 0 stevel * Use a uint64_t for the initial shift calculation. 475 0 stevel */ 476 0 stevel ull = x >> (LSHIFT-2); 477 0 stevel 478 0 stevel /* 479 0 stevel * Short circuit: 480 0 stevel * A number this large produces effectively 0 (actually .005). 481 0 stevel * This way, we will never do more than 5 multiplies. 482 0 stevel */ 483 0 stevel if (ull >= (1 << 5)) 484 0 stevel return (0); 485 0 stevel 486 0 stevel ui = ull; /* OK. Now we can use a uint_t. */ 487 0 stevel for (i = 0; ui != 0; i++) 488 0 stevel ui >>= 1; 489 0 stevel 490 0 stevel if (i != 0) { 491 0 stevel #ifdef DEBUG 492 0 stevel expx_mul += i; /* seldom happens */ 493 0 stevel #endif 494 0 stevel x >>= i; 495 0 stevel } 496 0 stevel 497 0 stevel /* 498 0 stevel * Now we compute 1 - x and square it the number of times 499 0 stevel * that we halved x above to produce the final result: 500 0 stevel */ 501 0 stevel x = LSI_ONE - x; 502 0 stevel while (i--) 503 0 stevel x = (x * x) >> LSHIFT; 504 0 stevel 505 0 stevel return (x); 506 0 stevel } 507 0 stevel 508 0 stevel /* 509 0 stevel * Given the old percent cpu and a time delta in nanoseconds, 510 0 stevel * return the new decayed percent cpu: pct * exp(-tau), 511 0 stevel * where 'tau' is the time delta multiplied by a decay factor. 512 0 stevel * We have chosen the decay factor (cpu_decay_factor in param.c) 513 0 stevel * to make the decay over five seconds be approximately 20%. 514 0 stevel * 515 0 stevel * 'pct' is a 32-bit scaled integer <= 1 516 0 stevel * The binary point is to the right of the high-order bit 517 0 stevel * of the 32-bit word. 518 0 stevel */ 519 0 stevel static uint32_t 520 0 stevel cpu_decay(uint32_t pct, hrtime_t nsec) 521 0 stevel { 522 0 stevel uint64_t delta = (uint64_t)nsec; 523 0 stevel 524 0 stevel delta /= cpu_decay_factor; 525 0 stevel return ((pct * exp_x(delta)) >> LSHIFT); 526 0 stevel } 527 0 stevel 528 0 stevel /* 529 0 stevel * Given the old percent cpu and a time delta in nanoseconds, 530 0 stevel * return the new grown percent cpu: 1 - ( 1 - pct ) * exp(-tau) 531 0 stevel */ 532 0 stevel static uint32_t 533 0 stevel cpu_grow(uint32_t pct, hrtime_t nsec) 534 0 stevel { 535 0 stevel return (LSI_ONE - cpu_decay(LSI_ONE - pct, nsec)); 536 0 stevel } 537 0 stevel 538 0 stevel 539 0 stevel /* 540 0 stevel * Defined to determine whether a lwp is still on a processor. 541 0 stevel */ 542 0 stevel 543 0 stevel #define T_ONPROC(kt) \ 544 0 stevel ((kt)->t_mstate < LMS_SLEEP) 545 0 stevel #define T_OFFPROC(kt) \ 546 0 stevel ((kt)->t_mstate >= LMS_SLEEP) 547 0 stevel 548 0 stevel uint_t 549 0 stevel cpu_update_pct(kthread_t *t, hrtime_t newtime) 550 0 stevel { 551 0 stevel hrtime_t delta; 552 0 stevel hrtime_t hrlb; 553 0 stevel uint_t pctcpu; 554 0 stevel uint_t npctcpu; 555 0 stevel 556 0 stevel /* 557 0 stevel * This routine can get called at PIL > 0, this *has* to be 558 0 stevel * done atomically. Holding locks here causes bad things to happen. 559 0 stevel * (read: deadlock). 560 0 stevel */ 561 0 stevel 562 0 stevel do { 563 0 stevel if (T_ONPROC(t) && t->t_waitrq == 0) { 564 0 stevel hrlb = t->t_hrtime; 565 0 stevel delta = newtime - hrlb; 566 0 stevel if (delta < 0) { 567 0 stevel newtime = gethrtime_unscaled(); 568 0 stevel delta = newtime - hrlb; 569 0 stevel } 570 0 stevel t->t_hrtime = newtime; 571 0 stevel scalehrtime(&delta); 572 0 stevel pctcpu = t->t_pctcpu; 573 0 stevel npctcpu = cpu_grow(pctcpu, delta); 574 0 stevel } else { 575 0 stevel hrlb = t->t_hrtime; 576 0 stevel delta = newtime - hrlb; 577 0 stevel if (delta < 0) { 578 0 stevel newtime = gethrtime_unscaled(); 579 0 stevel delta = newtime - hrlb; 580 0 stevel } 581 0 stevel t->t_hrtime = newtime; 582 0 stevel scalehrtime(&delta); 583 0 stevel pctcpu = t->t_pctcpu; 584 0 stevel npctcpu = cpu_decay(pctcpu, delta); 585 0 stevel } 586 0 stevel } while (cas32(&t->t_pctcpu, pctcpu, npctcpu) != pctcpu); 587 0 stevel 588 0 stevel return (npctcpu); 589 0 stevel } 590 0 stevel 591 0 stevel /* 592 0 stevel * Change the microstate level for the LWP and update the 593 0 stevel * associated accounting information. Return the previous 594 0 stevel * LWP state. 595 0 stevel */ 596 0 stevel int 597 0 stevel new_mstate(kthread_t *t, int new_state) 598 0 stevel { 599 0 stevel struct mstate *ms; 600 0 stevel unsigned state; 601 0 stevel hrtime_t *mstimep; 602 0 stevel hrtime_t curtime; 603 0 stevel hrtime_t newtime; 604 0 stevel hrtime_t oldtime; 605 0 stevel klwp_t *lwp; 606 0 stevel 607 0 stevel ASSERT(new_state != LMS_WAIT_CPU); 608 0 stevel ASSERT((unsigned)new_state < NMSTATES); 609 0 stevel ASSERT(t == curthread || THREAD_LOCK_HELD(t)); 610 0 stevel 611 4071 johansen /* 612 4071 johansen * Don't do microstate processing for threads without a lwp (kernel 613 4071 johansen * threads). Also, if we're an interrupt thread that is pinning another 614 4071 johansen * thread, our t_mstate hasn't been initialized. We'd be modifying the 615 4071 johansen * microstate of the underlying lwp which doesn't realize that it's 616 4071 johansen * pinned. In this case, also don't change the microstate. 617 4071 johansen */ 618 4071 johansen if (((lwp = ttolwp(t)) == NULL) || t->t_intr) 619 0 stevel return (LMS_SYSTEM); 620 0 stevel 621 0 stevel curtime = gethrtime_unscaled(); 622 0 stevel 623 0 stevel /* adjust cpu percentages before we go any further */ 624 0 stevel (void) cpu_update_pct(t, curtime); 625 0 stevel 626 0 stevel ms = &lwp->lwp_mstate; 627 0 stevel state = t->t_mstate; 628 0 stevel do { 629 0 stevel switch (state) { 630 0 stevel case LMS_TFAULT: 631 0 stevel case LMS_DFAULT: 632 0 stevel case LMS_KFAULT: 633 0 stevel case LMS_USER_LOCK: 634 0 stevel mstimep = &ms->ms_acct[LMS_SYSTEM]; 635 0 stevel break; 636 0 stevel default: 637 0 stevel mstimep = &ms->ms_acct[state]; 638 0 stevel break; 639 0 stevel } 640 0 stevel newtime = curtime - ms->ms_state_start; 641 0 stevel if (newtime < 0) { 642 0 stevel curtime = gethrtime_unscaled(); 643 0 stevel oldtime = *mstimep - 1; /* force CAS to fail */ 644 0 stevel continue; 645 0 stevel } 646 0 stevel oldtime = *mstimep; 647 0 stevel newtime += oldtime; 648 0 stevel t->t_mstate = new_state; 649 0 stevel ms->ms_state_start = curtime; 650 0 stevel } while (cas64((uint64_t *)mstimep, oldtime, newtime) != oldtime); 651 0 stevel /* 652 0 stevel * Remember the previous running microstate. 653 0 stevel */ 654 0 stevel if (state != LMS_SLEEP && state != LMS_STOPPED) 655 0 stevel ms->ms_prev = state; 656 0 stevel 657 0 stevel /* 658 0 stevel * Switch CPU microstate if appropriate 659 0 stevel */ 660 590 esolom 661 0 stevel kpreempt_disable(); /* MUST disable kpreempt before touching t->cpu */ 662 590 esolom ASSERT(t->t_cpu == CPU); 663 590 esolom if (!CPU_ON_INTR(t->t_cpu) && curthread->t_intr == NULL) { 664 590 esolom if (new_state == LMS_USER && t->t_cpu->cpu_mstate != CMS_USER) 665 590 esolom new_cpu_mstate(CMS_USER, curtime); 666 590 esolom else if (new_state != LMS_USER && 667 590 esolom t->t_cpu->cpu_mstate != CMS_SYSTEM) 668 590 esolom new_cpu_mstate(CMS_SYSTEM, curtime); 669 0 stevel } 670 0 stevel kpreempt_enable(); 671 0 stevel 672 0 stevel return (ms->ms_prev); 673 0 stevel } 674 0 stevel 675 0 stevel /* 676 0 stevel * Restore the LWP microstate to the previous runnable state. 677 0 stevel * Called from disp() with the newly selected lwp. 678 0 stevel */ 679 0 stevel void 680 0 stevel restore_mstate(kthread_t *t) 681 0 stevel { 682 0 stevel struct mstate *ms; 683 0 stevel hrtime_t *mstimep; 684 0 stevel klwp_t *lwp; 685 0 stevel hrtime_t curtime; 686 0 stevel hrtime_t waitrq; 687 0 stevel hrtime_t newtime; 688 0 stevel hrtime_t oldtime; 689 4071 johansen 690 4071 johansen /* 691 4071 johansen * Don't call restore mstate of threads without lwps. (Kernel threads) 692 4071 johansen * 693 4071 johansen * threads with t_intr set shouldn't be in the dispatcher, so assert 694 4071 johansen * that nobody here has t_intr. 695 4071 johansen */ 696 4071 johansen ASSERT(t->t_intr == NULL); 697 0 stevel 698 0 stevel if ((lwp = ttolwp(t)) == NULL) 699 0 stevel return; 700 0 stevel 701 0 stevel curtime = gethrtime_unscaled(); 702 0 stevel (void) cpu_update_pct(t, curtime); 703 0 stevel ms = &lwp->lwp_mstate; 704 0 stevel ASSERT((unsigned)t->t_mstate < NMSTATES); 705 0 stevel do { 706 0 stevel switch (t->t_mstate) { 707 0 stevel case LMS_SLEEP: 708 0 stevel /* 709 0 stevel * Update the timer for the current sleep state. 710 0 stevel */ 711 0 stevel ASSERT((unsigned)ms->ms_prev < NMSTATES); 712 0 stevel switch (ms->ms_prev) { 713 0 stevel case LMS_TFAULT: 714 0 stevel case LMS_DFAULT: 715 0 stevel case LMS_KFAULT: 716 0 stevel case LMS_USER_LOCK: 717 0 stevel mstimep = &ms->ms_acct[ms->ms_prev]; 718 0 stevel break; 719 0 stevel default: 720 0 stevel mstimep = &ms->ms_acct[LMS_SLEEP]; 721 0 stevel break; 722 0 stevel } 723 0 stevel /* 724 0 stevel * Return to the previous run state. 725 0 stevel */ 726 0 stevel t->t_mstate = ms->ms_prev; 727 0 stevel break; 728 0 stevel case LMS_STOPPED: 729 0 stevel mstimep = &ms->ms_acct[LMS_STOPPED]; 730 0 stevel /* 731 0 stevel * Return to the previous run state. 732 0 stevel */ 733 0 stevel t->t_mstate = ms->ms_prev; 734 0 stevel break; 735 0 stevel case LMS_TFAULT: 736 0 stevel case LMS_DFAULT: 737 0 stevel case LMS_KFAULT: 738 0 stevel case LMS_USER_LOCK: 739 0 stevel mstimep = &ms->ms_acct[LMS_SYSTEM]; 740 0 stevel break; 741 0 stevel default: 742 0 stevel mstimep = &ms->ms_acct[t->t_mstate]; 743 0 stevel break; 744 0 stevel } 745 0 stevel waitrq = t->t_waitrq; /* hopefully atomic */ 746 3426 johansen if (waitrq == 0) { 747 3426 johansen waitrq = curtime; 748 3426 johansen } 749 0 stevel t->t_waitrq = 0; 750 0 stevel newtime = waitrq - ms->ms_state_start; 751 0 stevel if (newtime < 0) { 752 0 stevel curtime = gethrtime_unscaled(); 753 0 stevel oldtime = *mstimep - 1; /* force CAS to fail */ 754 0 stevel continue; 755 0 stevel } 756 0 stevel oldtime = *mstimep; 757 0 stevel newtime += oldtime; 758 0 stevel } while (cas64((uint64_t *)mstimep, oldtime, newtime) != oldtime); 759 0 stevel /* 760 0 stevel * Update the WAIT_CPU timer and per-cpu waitrq total. 761 0 stevel */ 762 0 stevel ms->ms_acct[LMS_WAIT_CPU] += (curtime - waitrq); 763 477 mishra CPU->cpu_waitrq += (curtime - waitrq); 764 0 stevel ms->ms_state_start = curtime; 765 0 stevel } 766 0 stevel 767 0 stevel /* 768 0 stevel * Copy lwp microstate accounting and resource usage information 769 0 stevel * to the process. (lwp is terminating) 770 0 stevel */ 771 0 stevel void 772 0 stevel term_mstate(kthread_t *t) 773 0 stevel { 774 0 stevel struct mstate *ms; 775 0 stevel proc_t *p = ttoproc(t); 776 0 stevel klwp_t *lwp = ttolwp(t); 777 0 stevel int i; 778 0 stevel hrtime_t tmp; 779 0 stevel 780 0 stevel ASSERT(MUTEX_HELD(&p->p_lock)); 781 0 stevel 782 0 stevel ms = &lwp->lwp_mstate; 783 0 stevel (void) new_mstate(t, LMS_STOPPED); 784 0 stevel ms->ms_term = ms->ms_state_start; 785 0 stevel tmp = ms->ms_term - ms->ms_start; 786 0 stevel scalehrtime(&tmp); 787 0 stevel p->p_mlreal += tmp; 788 0 stevel for (i = 0; i < NMSTATES; i++) { 789 0 stevel tmp = ms->ms_acct[i]; 790 0 stevel scalehrtime(&tmp); 791 0 stevel p->p_acct[i] += tmp; 792 0 stevel } 793 0 stevel p->p_ru.minflt += lwp->lwp_ru.minflt; 794 0 stevel p->p_ru.majflt += lwp->lwp_ru.majflt; 795 0 stevel p->p_ru.nswap += lwp->lwp_ru.nswap; 796 0 stevel p->p_ru.inblock += lwp->lwp_ru.inblock; 797 0 stevel p->p_ru.oublock += lwp->lwp_ru.oublock; 798 0 stevel p->p_ru.msgsnd += lwp->lwp_ru.msgsnd; 799 0 stevel p->p_ru.msgrcv += lwp->lwp_ru.msgrcv; 800 0 stevel p->p_ru.nsignals += lwp->lwp_ru.nsignals; 801 0 stevel p->p_ru.nvcsw += lwp->lwp_ru.nvcsw; 802 0 stevel p->p_ru.nivcsw += lwp->lwp_ru.nivcsw; 803 0 stevel p->p_ru.sysc += lwp->lwp_ru.sysc; 804 0 stevel p->p_ru.ioch += lwp->lwp_ru.ioch; 805 0 stevel p->p_defunct++; 806 0 stevel } 807
Indexes created Wed Nov 25 00:25:59 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.