![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sh.time.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / bin / csh|
Return to sh.time.c CVS log | Up to [CSRG BSD Unix] / 42BSD / bin / csh |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)sh.time.c 4.4 (Berkeley) 8/11/83";
3: #endif
4:
5: #include "sh.h"
6:
7: /*
8: * C Shell - routines handling process timing and niceing
9: */
10: struct tms times0;
11: struct tms timesdol;
12:
13: settimes()
14: {
15: struct rusage ruch;
16:
17: gettimeofday(&time0, (struct timezone *)0);
18: getrusage(RUSAGE_SELF, &ru0);
19: getrusage(RUSAGE_CHILDREN, &ruch);
20: ruadd(&ru0, &ruch);
21: }
22:
23: /*
24: * dotime is only called if it is truly a builtin function and not a
25: * prefix to another command
26: */
27: dotime()
28: {
29: struct timeval timedol;
30: struct rusage ru1, ruch;
31:
32: getrusage(RUSAGE_SELF, &ru1);
33: getrusage(RUSAGE_CHILDREN, &ruch);
34: ruadd(&ru1, &ruch);
35: gettimeofday(&timedol, (struct timezone *)0);
36: prusage(&ru0, &ru1, &timedol, &time0);
37: }
38:
39: /*
40: * donice is only called when it on the line by itself or with a +- value
41: */
42: donice(v)
43: register char **v;
44: {
45: register char *cp;
46:
47: v++, cp = *v++;
48: if (cp == 0) {
49: #ifndef V6
50: nice(20);
51: nice(-10);
52: #endif
53: nice(4);
54: } else if (*v == 0 && any(cp[0], "+-")) {
55: #ifndef V6
56: nice(20);
57: nice(-10);
58: #endif
59: nice(getn(cp));
60: }
61: }
62:
63: ruadd(ru, ru2)
64: register struct rusage *ru, *ru2;
65: {
66: register long *lp, *lp2;
67: register int cnt;
68:
69: tvadd(&ru->ru_utime, &ru2->ru_utime);
70: tvadd(&ru->ru_stime, &ru2->ru_stime);
71: if (ru2->ru_maxrss > ru->ru_maxrss)
72: ru->ru_maxrss = ru2->ru_maxrss;
73: cnt = &ru->ru_last - &ru->ru_first + 1;
74: lp = &ru->ru_first; lp2 = &ru2->ru_first;
75: do
76: *lp++ += *lp2++;
77: while (--cnt > 0);
78: }
79:
80: prusage(r0, r1, e, b)
81: register struct rusage *r0, *r1;
82: struct timeval *e, *b;
83: {
84: register time_t t =
85: (r1->ru_utime.tv_sec-r0->ru_utime.tv_sec)*100+
86: (r1->ru_utime.tv_usec-r0->ru_utime.tv_usec)/10000+
87: (r1->ru_stime.tv_sec-r0->ru_stime.tv_sec)*100+
88: (r1->ru_stime.tv_usec-r0->ru_stime.tv_usec)/10000;
89: register char *cp;
90: register int i;
91: register struct varent *vp = adrof("time");
92: int ms =
93: (e->tv_sec-b->tv_sec)*100 + (e->tv_usec-b->tv_usec)/10000;
94:
95: cp = "%Uu %Ss %E %P %X+%Dk %I+%Oio %Fpf+%Ww";
96: if (vp && vp->vec[0] && vp->vec[1])
97: cp = vp->vec[1];
98: for (; *cp; cp++)
99: if (*cp != '%')
100: putchar(*cp);
101: else if (cp[1]) switch(*++cp) {
102:
103: case 'U':
104: pdeltat(&r1->ru_utime, &r0->ru_utime);
105: break;
106:
107: case 'S':
108: pdeltat(&r1->ru_stime, &r0->ru_stime);
109: break;
110:
111: case 'E':
112: psecs(ms / 100);
113: break;
114:
115: case 'P':
116: printf("%d%%", (int) (t*100 / ((ms ? ms : 1))));
117: break;
118:
119: case 'W':
120: i = r1->ru_nswap - r0->ru_nswap;
121: printf("%d", i);
122: break;
123:
124: case 'X':
125: printf("%d", t == 0 ? 0 : (r1->ru_ixrss-r0->ru_ixrss)/t);
126: break;
127:
128: case 'D':
129: printf("%d", t == 0 ? 0 :
130: (r1->ru_idrss+r1->ru_isrss-(r0->ru_idrss+r0->ru_isrss))/t);
131: break;
132:
133: case 'K':
134: printf("%d", t == 0 ? 0 :
135: ((r1->ru_ixrss+r1->ru_isrss+r1->ru_idrss) -
136: (r0->ru_ixrss+r0->ru_idrss+r0->ru_isrss))/t);
137: break;
138:
139: case 'M':
140: printf("%d", r1->ru_maxrss/2);
141: break;
142:
143: case 'F':
144: printf("%d", r1->ru_majflt-r0->ru_majflt);
145: break;
146:
147: case 'R':
148: printf("%d", r1->ru_minflt-r0->ru_minflt);
149: break;
150:
151: case 'I':
152: printf("%d", r1->ru_inblock-r0->ru_inblock);
153: break;
154:
155: case 'O':
156: printf("%d", r1->ru_oublock-r0->ru_oublock);
157: break;
158: }
159: putchar('\n');
160: }
161:
162: pdeltat(t1, t0)
163: struct timeval *t1, *t0;
164: {
165: struct timeval td;
166:
167: tvsub(&td, t1, t0);
168: printf("%d.%01d", td.tv_sec, td.tv_usec/100000);
169: }
170:
171: tvadd(tsum, t0)
172: struct timeval *tsum, *t0;
173: {
174:
175: tsum->tv_sec += t0->tv_sec;
176: tsum->tv_usec += t0->tv_usec;
177: if (tsum->tv_usec > 1000000)
178: tsum->tv_sec++, tsum->tv_usec -= 1000000;
179: }
180:
181: tvsub(tdiff, t1, t0)
182: struct timeval *tdiff, *t1, *t0;
183: {
184:
185: tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
186: tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
187: if (tdiff->tv_usec < 0)
188: tdiff->tv_sec--, tdiff->tv_usec += 1000000;
189: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.