![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_clock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to kern_clock.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)kern_clock.c 7.10 (Berkeley) 6/30/90
7: */
8:
9: #include "param.h"
10: #include "systm.h"
11: #include "dkstat.h"
12: #include "callout.h"
13: #include "user.h"
14: #include "kernel.h"
15: #include "proc.h"
16: #include "vm.h"
17: #include "text.h"
18:
19: #include "machine/reg.h"
20: #include "machine/psl.h"
21:
22: #if defined(vax) || defined(tahoe)
23: #include "machine/mtpr.h"
24: #include "machine/clock.h"
25: #endif
26: #if defined(hp300)
27: #include "machine/mtpr.h"
28: #endif
29: #ifdef i386
30: #include "machine/frame.h"
31: #include "machine/segments.h"
32: #endif
33:
34: #ifdef GPROF
35: #include "gprof.h"
36: #endif
37:
38: /*
39: * Clock handling routines.
40: *
41: * This code is written to operate with two timers which run
42: * independently of each other. The main clock, running at hz
43: * times per second, is used to do scheduling and timeout calculations.
44: * The second timer does resource utilization estimation statistically
45: * based on the state of the machine phz times a second. Both functions
46: * can be performed by a single clock (ie hz == phz), however the
47: * statistics will be much more prone to errors. Ideally a machine
48: * would have separate clocks measuring time spent in user state, system
49: * state, interrupt state, and idle state. These clocks would allow a non-
50: * approximate measure of resource utilization.
51: */
52:
53: /*
54: * TODO:
55: * time of day, system/user timing, timeouts, profiling on separate timers
56: * allocate more timeout table slots when table overflows.
57: */
58:
59: /*
60: * Bump a timeval by a small number of usec's.
61: */
62: #define BUMPTIME(t, usec) { \
63: register struct timeval *tp = (t); \
64: \
65: tp->tv_usec += (usec); \
66: if (tp->tv_usec >= 1000000) { \
67: tp->tv_usec -= 1000000; \
68: tp->tv_sec++; \
69: } \
70: }
71:
72: /*
73: * The hz hardware interval timer.
74: * We update the events relating to real time.
75: * If this timer is also being used to gather statistics,
76: * we run through the statistics gathering routine as well.
77: */
78: /*ARGSUSED*/
79: #ifndef i386
80: hardclock(pc, ps)
81: caddr_t pc;
82: int ps;
83: #else
84: hardclock(frame)
85: struct intrframe frame;
86: #define pc frame.if_eip
87: #endif
88: {
89: register struct callout *p1;
90: register struct proc *p = u.u_procp;
91: register int s;
92: int needsoft = 0;
93: extern int tickdelta;
94: extern long timedelta;
95:
96: /*
97: * Update real-time timeout queue.
98: * At front of queue are some number of events which are ``due''.
99: * The time to these is <= 0 and if negative represents the
100: * number of ticks which have passed since it was supposed to happen.
101: * The rest of the q elements (times > 0) are events yet to happen,
102: * where the time for each is given as a delta from the previous.
103: * Decrementing just the first of these serves to decrement the time
104: * to all events.
105: */
106: p1 = calltodo.c_next;
107: while (p1) {
108: if (--p1->c_time > 0)
109: break;
110: needsoft = 1;
111: if (p1->c_time == 0)
112: break;
113: p1 = p1->c_next;
114: }
115:
116: /*
117: * Charge the time out based on the mode the cpu is in.
118: * Here again we fudge for the lack of proper interval timers
119: * assuming that the current state has been around at least
120: * one tick.
121: */
122: #ifdef i386
123: if (ISPL(frame.if_cs) == SEL_UPL) {
124: #else
125: if (USERMODE(ps)) {
126: #endif
127: if (u.u_prof.pr_scale)
128: needsoft = 1;
129: /*
130: * CPU was in user state. Increment
131: * user time counter, and process process-virtual time
132: * interval timer.
133: */
134: BUMPTIME(&p->p_utime, tick);
135: if (timerisset(&u.u_timer[ITIMER_VIRTUAL].it_value) &&
136: itimerdecr(&u.u_timer[ITIMER_VIRTUAL], tick) == 0)
137: psignal(p, SIGVTALRM);
138: } else {
139: /*
140: * CPU was in system state.
141: */
142: if (!noproc)
143: BUMPTIME(&p->p_stime, tick);
144: }
145:
146: /*
147: * If the cpu is currently scheduled to a process, then
148: * charge it with resource utilization for a tick, updating
149: * statistics which run in (user+system) virtual time,
150: * such as the cpu time limit and profiling timers.
151: * This assumes that the current process has been running
152: * the entire last tick.
153: */
154: if (noproc == 0) {
155: if ((p->p_utime.tv_sec+p->p_stime.tv_sec+1) >
156: u.u_rlimit[RLIMIT_CPU].rlim_cur) {
157: psignal(p, SIGXCPU);
158: if (u.u_rlimit[RLIMIT_CPU].rlim_cur <
159: u.u_rlimit[RLIMIT_CPU].rlim_max)
160: u.u_rlimit[RLIMIT_CPU].rlim_cur += 5;
161: }
162: if (timerisset(&u.u_timer[ITIMER_PROF].it_value) &&
163: itimerdecr(&u.u_timer[ITIMER_PROF], tick) == 0)
164: psignal(p, SIGPROF);
165: s = p->p_rssize;
166: u.u_ru.ru_idrss += s;
167: #ifdef notdef
168: u.u_ru.ru_isrss += 0; /* XXX (haven't got this) */
169: #endif
170: if (p->p_textp) {
171: register int xrss = p->p_textp->x_rssize;
172:
173: s += xrss;
174: u.u_ru.ru_ixrss += xrss;
175: }
176: if (s > u.u_ru.ru_maxrss)
177: u.u_ru.ru_maxrss = s;
178: }
179:
180: /*
181: * We adjust the priority of the current process.
182: * The priority of a process gets worse as it accumulates
183: * CPU time. The cpu usage estimator (p_cpu) is increased here
184: * and the formula for computing priorities (in kern_synch.c)
185: * will compute a different value each time the p_cpu increases
186: * by 4. The cpu usage estimator ramps up quite quickly when
187: * the process is running (linearly), and decays away exponentially,
188: * at a rate which is proportionally slower when the system is
189: * busy. The basic principal is that the system will 90% forget
190: * that a process used a lot of CPU time in 5*loadav seconds.
191: * This causes the system to favor processes which haven't run
192: * much recently, and to round-robin among other processes.
193: */
194: if (!noproc) {
195: p->p_cpticks++;
196: if (++p->p_cpu == 0)
197: p->p_cpu--;
198: if ((p->p_cpu&3) == 0) {
199: (void) setpri(p);
200: if (p->p_pri >= PUSER)
201: p->p_pri = p->p_usrpri;
202: }
203: }
204:
205: /*
206: * If the alternate clock has not made itself known then
207: * we must gather the statistics.
208: */
209: if (phz == 0)
210: #ifdef i386
211: gatherstats(pc, ISPL(frame.if_cs), frame.if_ppl);
212: #else
213: gatherstats(pc, ps);
214: #endif
215:
216: /*
217: * Increment the time-of-day, and schedule
218: * processing of the callouts at a very low cpu priority,
219: * so we don't keep the relatively high clock interrupt
220: * priority any longer than necessary.
221: */
222: if (timedelta == 0)
223: BUMPTIME(&time, tick)
224: else {
225: register delta;
226:
227: if (timedelta < 0) {
228: delta = tick - tickdelta;
229: timedelta += tickdelta;
230: } else {
231: delta = tick + tickdelta;
232: timedelta -= tickdelta;
233: }
234: BUMPTIME(&time, delta);
235: }
236: if (needsoft) {
237: #ifdef i386
238: if (frame.if_ppl == 0) {
239: #else
240: if (BASEPRI(ps)) {
241: #endif
242: /*
243: * Save the overhead of a software interrupt;
244: * it will happen as soon as we return, so do it now.
245: */
246: (void) splsoftclock();
247: #ifdef i386
248: softclock(frame);
249: #else
250: softclock(pc, ps);
251: #endif
252: } else
253: setsoftclock();
254: }
255: }
256:
257: int dk_ndrive = DK_NDRIVE;
258: /*
259: * Gather statistics on resource utilization.
260: *
261: * We make a gross assumption: that the system has been in the
262: * state it is in (user state, kernel state, interrupt state,
263: * or idle state) for the entire last time interval, and
264: * update statistics accordingly.
265: */
266: /*ARGSUSED*/
267: #ifdef i386
268: #undef pc
269: gatherstats(pc, ps, ppl)
270: #else
271: gatherstats(pc, ps)
272: #endif
273: caddr_t pc;
274: int ps;
275: {
276: register int cpstate, s;
277:
278: /*
279: * Determine what state the cpu is in.
280: */
281: #ifdef i386
282: if (ps == SEL_UPL) {
283: #else
284: if (USERMODE(ps)) {
285: #endif
286: /*
287: * CPU was in user state.
288: */
289: if (u.u_procp->p_nice > NZERO)
290: cpstate = CP_NICE;
291: else
292: cpstate = CP_USER;
293: } else {
294: /*
295: * CPU was in system state. If profiling kernel
296: * increment a counter. If no process is running
297: * then this is a system tick if we were running
298: * at a non-zero IPL (in a driver). If a process is running,
299: * then we charge it with system time even if we were
300: * at a non-zero IPL, since the system often runs
301: * this way during processing of system calls.
302: * This is approximate, but the lack of true interval
303: * timers makes doing anything else difficult.
304: */
305: cpstate = CP_SYS;
306: #if defined(i386)
307: if (noproc && ps == 0)
308: #else
309: if (noproc && BASEPRI(ps))
310: #endif
311: cpstate = CP_IDLE;
312: #ifdef GPROF
313: s = pc - s_lowpc;
314: if (profiling < 2 && s < s_textsize)
315: kcount[s / (HISTFRACTION * sizeof (*kcount))]++;
316: #endif
317: }
318: /*
319: * We maintain statistics shown by user-level statistics
320: * programs: the amount of time in each cpu state, and
321: * the amount of time each of DK_NDRIVE ``drives'' is busy.
322: */
323: cp_time[cpstate]++;
324: for (s = 0; s < DK_NDRIVE; s++)
325: if (dk_busy&(1<<s))
326: dk_time[s]++;
327: }
328:
329: /*
330: * Software priority level clock interrupt.
331: * Run periodic events from timeout queue.
332: */
333: /*ARGSUSED*/
334: #ifdef i386
335: softclock(frame)
336: struct intrframe frame;
337: #define pc frame.if_eip
338: #else
339: softclock(pc, ps)
340: caddr_t pc;
341: int ps;
342: #endif
343: {
344:
345: for (;;) {
346: register struct callout *p1;
347: register caddr_t arg;
348: register int (*func)();
349: register int a, s;
350:
351: s = splhigh();
352: if ((p1 = calltodo.c_next) == 0 || p1->c_time > 0) {
353: splx(s);
354: break;
355: }
356: arg = p1->c_arg; func = p1->c_func; a = p1->c_time;
357: calltodo.c_next = p1->c_next;
358: p1->c_next = callfree;
359: callfree = p1;
360: splx(s);
361: (*func)(arg, a);
362: }
363: /*
364: * If trapped user-mode and profiling, give it
365: * a profiling tick.
366: */
367: #ifdef i386
368: if (ISPL(frame.if_cs) == SEL_UPL) {
369: #else
370: if (USERMODE(ps)) {
371: #endif
372: register struct proc *p = u.u_procp;
373:
374: if (u.u_prof.pr_scale) {
375: p->p_flag |= SOWEUPC;
376: aston();
377: }
378: /*
379: * Check to see if process has accumulated
380: * more than 10 minutes of user time. If so
381: * reduce priority to give others a chance.
382: */
383: if (p->p_uid && p->p_nice == NZERO &&
384: p->p_utime.tv_sec > 10 * 60) {
385: p->p_nice = NZERO+4;
386: (void) setpri(p);
387: p->p_pri = p->p_usrpri;
388: }
389: }
390: }
391:
392: /*
393: * Arrange that (*fun)(arg) is called in t/hz seconds.
394: */
395: timeout(fun, arg, t)
396: int (*fun)();
397: caddr_t arg;
398: register int t;
399: {
400: register struct callout *p1, *p2, *pnew;
401: register int s = splhigh();
402:
403: if (t <= 0)
404: t = 1;
405: pnew = callfree;
406: if (pnew == NULL)
407: panic("timeout table overflow");
408: callfree = pnew->c_next;
409: pnew->c_arg = arg;
410: pnew->c_func = fun;
411: for (p1 = &calltodo; (p2 = p1->c_next) && p2->c_time < t; p1 = p2)
412: if (p2->c_time > 0)
413: t -= p2->c_time;
414: p1->c_next = pnew;
415: pnew->c_next = p2;
416: pnew->c_time = t;
417: if (p2)
418: p2->c_time -= t;
419: splx(s);
420: }
421:
422: /*
423: * untimeout is called to remove a function timeout call
424: * from the callout structure.
425: */
426: untimeout(fun, arg)
427: int (*fun)();
428: caddr_t arg;
429: {
430: register struct callout *p1, *p2;
431: register int s;
432:
433: s = splhigh();
434: for (p1 = &calltodo; (p2 = p1->c_next) != 0; p1 = p2) {
435: if (p2->c_func == fun && p2->c_arg == arg) {
436: if (p2->c_next && p2->c_time > 0)
437: p2->c_next->c_time += p2->c_time;
438: p1->c_next = p2->c_next;
439: p2->c_next = callfree;
440: callfree = p2;
441: break;
442: }
443: }
444: splx(s);
445: }
446:
447: /*
448: * Compute number of hz until specified time.
449: * Used to compute third argument to timeout() from an
450: * absolute time.
451: */
452: hzto(tv)
453: struct timeval *tv;
454: {
455: register long ticks;
456: register long sec;
457: int s = splhigh();
458:
459: /*
460: * If number of milliseconds will fit in 32 bit arithmetic,
461: * then compute number of milliseconds to time and scale to
462: * ticks. Otherwise just compute number of hz in time, rounding
463: * times greater than representible to maximum value.
464: *
465: * Delta times less than 25 days can be computed ``exactly''.
466: * Maximum value for any timeout in 10ms ticks is 250 days.
467: */
468: sec = tv->tv_sec - time.tv_sec;
469: if (sec <= 0x7fffffff / 1000 - 1000)
470: ticks = ((tv->tv_sec - time.tv_sec) * 1000 +
471: (tv->tv_usec - time.tv_usec) / 1000) / (tick / 1000);
472: else if (sec <= 0x7fffffff / hz)
473: ticks = sec * hz;
474: else
475: ticks = 0x7fffffff;
476: splx(s);
477: return (ticks);
478: }
479:
480: /* ARGSUSED */
481: profil(p, uap, retval)
482: struct proc *p;
483: register struct args {
484: short *bufbase;
485: unsigned bufsize;
486: unsigned pcoffset;
487: unsigned pcscale;
488: } *uap;
489: int *retval;
490: {
491: register struct uprof *upp = &u.u_prof;
492:
493: upp->pr_base = uap->bufbase;
494: upp->pr_size = uap->bufsize;
495: upp->pr_off = uap->pcoffset;
496: upp->pr_scale = uap->pcscale;
497: return (0);
498: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.