# 2.11BSD#431 - /usr/src/bin/tcsh/sh.time.c

##### Functions

    donice            X
    dotime            X
    prusage           X
    ruadd             X
    settimes          X
    tvadd             X
    tvsub             X

##### Macros

    IADJUST           X
    LOG1024           X
    RUSAGE_CHILDREN   X
    RUSAGE_SELF       X
    pagetok           X

       1: /* $Header: /home/hyperion/mu/christos/src/sys/tcsh-6.00/RCS/sh.time.c,v 3.0 1991/07/04 21:49:28 christos Exp $ */
       2: /*
       3:  * sh.time.c: Shell time keeping and printing.
       4:  */
       5: /*-
       6:  * Copyright (c) 1980, 1991 The Regents of the University of California.
       7:  * All rights reserved.
       8:  *
       9:  * Redistribution and use in source and binary forms, with or without
      10:  * modification, are permitted provided that the following conditions
      11:  * are met:
      12:  * 1. Redistributions of source code must retain the above copyright
      13:  *    notice, this list of conditions and the following disclaimer.
      14:  * 2. Redistributions in binary form must reproduce the above copyright
      15:  *    notice, this list of conditions and the following disclaimer in the
      16:  *    documentation and/or other materials provided with the distribution.
      17:  * 3. All advertising materials mentioning features or use of this software
      18:  *    must display the following acknowledgement:
      19:  *	This product includes software developed by the University of
      20:  *	California, Berkeley and its contributors.
      21:  * 4. Neither the name of the University nor the names of its contributors
      22:  *    may be used to endorse or promote products derived from this software
      23:  *    without specific prior written permission.
      24:  *
      25:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
      26:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      27:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      28:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
      29:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      30:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      31:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      32:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      33:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      34:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      35:  * SUCH DAMAGE.
      36:  */
      37: #include "config.h"
      38: #if !defined(lint) && !defined(pdp11)
      39: static char *rcsid()
      40:     { return "$Id: sh.time.c,v 3.0 1991/07/04 21:49:28 christos Exp $"; }
      41: #endif
      42:
      43: #include "sh.h"
      44: #if defined(sun) && ! defined(MACH)
      45: # include <machine/param.h>
      46: #endif				/* sun */
      47:
      48: /*
      49:  * C Shell - routines handling process timing and niceing
      50:  */
      51: #ifdef BSDTIMES
      52: # ifndef RUSAGE_SELF
      53: #  define   RUSAGE_SELF 0
      54: #  define   RUSAGE_CHILDREN -1
      55: # endif				/* RUSAGE_SELF */
      56: #else               /* BSDTIMES */
      57: struct tms times0;
      58:
      59: #endif				/* BSDTIMES */
      60:
      61: #if !defined(BSDTIMES) && !defined(_SEQUENT_)
      62: #ifdef POSIX
      63: static  void    pdtimet __P((clock_t, clock_t));
      64: #else               /* POSIX */
      65: static  void    pdtimet __P((time_t, time_t));
      66: #endif				/* POSIX */
      67: #else
      68: static  void    pdeltat __P((tmval_t *, tmval_t *));
      69: #endif
      70:
      71: void
      72: settimes()
      73: {
      74: #ifdef BSDTIMES
      75:     struct rusage ruch;
      76:
      77:     (void) gettimeofday(&time0, NULL);
      78:     (void) getrusage(RUSAGE_SELF, &ru0);
      79:     (void) getrusage(RUSAGE_CHILDREN, &ruch);
      80:     ruadd(&ru0, &ruch);
      81: #else
      82: # ifdef _SEQUENT_
      83:     struct pro_stats ruch;
      84:
      85:     (void) get_pro_stats(&time0, PS_SELF, &ru0, &ruch);
      86:     ruadd(&ru0, &ruch);
      87: # else              /* _SEQUENT_ */
      88:             time0 = times(&times0);
      89:     times0.tms_stime += times0.tms_cstime;
      90:     times0.tms_utime += times0.tms_cutime;
      91:     times0.tms_cstime = 0;
      92:     times0.tms_cutime = 0;
      93: # endif				/* _SEQUENT_ */
      94: #endif				/* BSDTIMES */
      95: }
      96:
      97: /*
      98:  * dotime is only called if it is truly a builtin function and not a
      99:  * prefix to another command
     100:  */
     101: void
     102: dotime()
     103: {
     104: #ifdef BSDTIMES
     105:     tmval_t timedol;
     106:     struct rusage ru1, ruch;
     107:
     108:     (void) getrusage(RUSAGE_SELF, &ru1);
     109:     (void) getrusage(RUSAGE_CHILDREN, &ruch);
     110:     ruadd(&ru1, &ruch);
     111:     (void) gettimeofday(&timedol, NULL);
     112:     prusage(&ru0, &ru1, &timedol, &time0);
     113: #else
     114: # ifdef _SEQUENT_
     115:     tmval_t timedol;
     116:     struct pro_stats ru1, ruch;
     117:
     118:     (void) get_pro_stats(&timedol, PS_SELF, &ru1, &ruch);
     119:     ruadd(&ru1, &ruch);
     120:     prusage(&ru0, &ru1, &timedol, &time0);
     121: # else              /* _SEQUENT_ */
     122: #  ifndef POSIX
     123:     time_t  timedol;
     124: #  else             /* POSIX */
     125:     clock_t timedol;
     126: #  endif				/* POSIX */
     127:
     128:     struct tms times_dol;
     129:
     130:     timedol = times(&times_dol);
     131:     times_dol.tms_stime += times_dol.tms_cstime;
     132:     times_dol.tms_utime += times_dol.tms_cutime;
     133:     times_dol.tms_cstime = 0;
     134:     times_dol.tms_cutime = 0;
     135:     prusage(&times0, &times_dol, timedol, time0);
     136: # endif				/* _SEQUENT_ */
     137: #endif				/* BSDTIMES */
     138: }
     139:
     140: /*
     141:  * donice is only called when it on the line by itself or with a +- value
     142:  */
     143: void
     144: donice(v)
     145:     register Char **v;
     146: {
     147:     register Char *cp;
     148:     int     nval = 0;
     149:
     150:     v++, cp = *v++;
     151:     if (cp == 0)
     152:     nval = 4;
     153:     else if (*v == 0 && any("+-", cp[0]))
     154:     nval = getn(cp);
     155: #ifdef BSDNICE
     156:     (void) setpriority(PRIO_PROCESS, 0, nval);
     157: #else               /* BSDNICE */
     158:     (void) nice(nval);
     159: #endif				/* BSDNICE */
     160: }
     161:
     162: #ifdef BSDTIMES
     163: void
     164: ruadd(ru, ru2)
     165:     register struct rusage *ru, *ru2;
     166: {
     167:     tvadd(&ru->ru_utime, &ru2->ru_utime);
     168:     tvadd(&ru->ru_stime, &ru2->ru_stime);
     169:     if (ru2->ru_maxrss > ru->ru_maxrss)
     170:     ru->ru_maxrss = ru2->ru_maxrss;
     171:
     172:     ru->ru_ixrss += ru2->ru_ixrss;
     173:     ru->ru_idrss += ru2->ru_idrss;
     174:     ru->ru_isrss += ru2->ru_isrss;
     175:     ru->ru_minflt += ru2->ru_minflt;
     176:     ru->ru_majflt += ru2->ru_majflt;
     177:     ru->ru_nswap += ru2->ru_nswap;
     178:     ru->ru_inblock += ru2->ru_inblock;
     179:     ru->ru_oublock += ru2->ru_oublock;
     180:     ru->ru_msgsnd += ru2->ru_msgsnd;
     181:     ru->ru_msgrcv += ru2->ru_msgrcv;
     182:     ru->ru_nsignals += ru2->ru_nsignals;
     183:     ru->ru_nvcsw += ru2->ru_nvcsw;
     184:     ru->ru_nivcsw += ru2->ru_nivcsw;
     185: }
     186:
     187: #else               /* BSDTIMES */
     188: # ifdef _SEQUENT_
     189: void
     190: ruadd(ru, ru2)
     191:     register struct pro_stats *ru, *ru2;
     192: {
     193:     tvadd(&ru->ps_utime, &ru2->ps_utime);
     194:     tvadd(&ru->ps_stime, &ru2->ps_stime);
     195:     if (ru2->ps_maxrss > ru->ps_maxrss)
     196:     ru->ps_maxrss = ru2->ps_maxrss;
     197:
     198:     ru->ps_pagein += ru2->ps_pagein;
     199:     ru->ps_reclaim += ru2->ps_reclaim;
     200:     ru->ps_zerofill += ru2->ps_zerofill;
     201:     ru->ps_pffincr += ru2->ps_pffincr;
     202:     ru->ps_pffdecr += ru2->ps_pffdecr;
     203:     ru->ps_swap += ru2->ps_swap;
     204:     ru->ps_syscall += ru2->ps_syscall;
     205:     ru->ps_volcsw += ru2->ps_volcsw;
     206:     ru->ps_involcsw += ru2->ps_involcsw;
     207:     ru->ps_signal += ru2->ps_signal;
     208:     ru->ps_lread += ru2->ps_lread;
     209:     ru->ps_lwrite += ru2->ps_lwrite;
     210:     ru->ps_bread += ru2->ps_bread;
     211:     ru->ps_bwrite += ru2->ps_bwrite;
     212:     ru->ps_phread += ru2->ps_phread;
     213:     ru->ps_phwrite += ru2->ps_phwrite;
     214: }
     215:
     216: # endif				/* _SEQUENT_ */
     217: #endif				/* BSDTIMES */
     218:
     219: #ifdef BSDTIMES
     220:
     221: /*
     222:  * PWP: the LOG1024 and pagetok stuff taken from the top command,
     223:  * written by William LeFebvre
     224:  */
     225: /* Log base 2 of 1024 is 10 (2^10 == 1024) */
     226: #define LOG1024         10
     227:
     228: /* Convert clicks (kernel pages) to kbytes ... */
     229: /* If there is no PGSHIFT defined, assume it is 11 */
     230: /* Is this needed for compatability with some old flavor of 4.2 or 4.1? */
     231: #ifndef PGSHIFT
     232: # define pagetok(size)   ((size) << 1)
     233: #else
     234: # if PGSHIFT>10
     235: #  define pagetok(size)   ((size) << (PGSHIFT - LOG1024))
     236: # else
     237: #  define pagetok(size)   ((size) >> (LOG1024 - PGSHIFT))
     238: # endif
     239: #endif
     240:
     241: /*
     242:  * if any other machines return wierd values in the ru_i* stuff, put
     243:  * the adjusting macro here:
     244:  */
     245: #ifdef sun
     246: # define IADJUST(i) (pagetok(i)/2)
     247: #else               /* sun */
     248: # define IADJUST(i) (i)
     249: #endif				/* sun */
     250:
     251: void
     252: prusage(r0, r1, e, b)
     253:     register struct rusage *r0, *r1;
     254:     tmval_t *e, *b;
     255:
     256: #else               /* BSDTIMES */
     257: # ifdef _SEQUENT_
     258: void
     259: prusage(r0, r1, e, b)
     260:     register struct pro_stats *r0, *r1;
     261:     tmval_t *e, *b;
     262:
     263: # else              /* _SEQUENT_ */
     264: void
     265: prusage(bs, es, e, b)
     266:     struct tms *bs, *es;
     267:
     268: #  ifndef POSIX
     269:     time_t  e, b;
     270:
     271: #  else             /* POSIX */
     272:     clock_t e, b;
     273:
     274: #  endif				/* POSIX */
     275: # endif				/* _SEQUENT_ */
     276: #endif				/* BSDTIMES */
     277: {
     278: #ifdef BSDTIMES
     279:     register time_t t =
     280:     (r1->ru_utime.tv_sec - r0->ru_utime.tv_sec) * 100 +
     281:     (r1->ru_utime.tv_usec - r0->ru_utime.tv_usec) / 10000 +
     282:     (r1->ru_stime.tv_sec - r0->ru_stime.tv_sec) * 100 +
     283:     (r1->ru_stime.tv_usec - r0->ru_stime.tv_usec) / 10000;
     284:
     285: #else
     286: # ifdef _SEQUENT_
     287:     register time_t t =
     288:     (r1->ps_utime.tv_sec - r0->ps_utime.tv_sec) * 100 +
     289:     (r1->ps_utime.tv_usec - r0->ps_utime.tv_usec) / 10000 +
     290:     (r1->ps_stime.tv_sec - r0->ps_stime.tv_sec) * 100 +
     291:     (r1->ps_stime.tv_usec - r0->ps_stime.tv_usec) / 10000;
     292:
     293: # else              /* _SEQUENT_ */
     294: #  ifndef POSIX
     295:     register time_t t = (es->tms_utime - bs->tms_utime +
     296:              es->tms_stime - bs->tms_stime) * 100 / HZ;
     297:
     298: #  else             /* POSIX */
     299:     register clock_t t = (es->tms_utime - bs->tms_utime +
     300:               es->tms_stime - bs->tms_stime) * 100 / CLK_TCK;
     301:
     302: #  endif				/* POSIX */
     303: # endif				/* _SEQUENT_ */
     304: #endif				/* BSDTIMES */
     305:
     306:     register char *cp;
     307:     register long i;
     308:     register struct varent *vp = adrof(STRtime);
     309:
     310: #ifdef BSDTIMES
     311: #ifdef pdp11
     312:     long    ms =
     313: #else
     314:     int     ms =
     315: #endif
     316:     (e->tv_sec - b->tv_sec) * 100 + (e->tv_usec - b->tv_usec) / 10000;
     317:
     318: #ifdef pdp11
     319:     cp = "%Uu %Ss %E %P %I+%Oio %Vov %Wsw";
     320: #else
     321:     cp = "%Uu %Ss %E %P %X+%Dk %I+%Oio %Fpf+%Ww";
     322: #endif
     323: #else
     324: # ifdef _SEQUENT_
     325:     int     ms =
     326:     (e->tv_sec - b->tv_sec) * 100 + (e->tv_usec - b->tv_usec) / 10000;
     327:
     328:     cp = "%Uu %Ss %E %P %I+%Oio %Fpf+%Ww";
     329: # else              /* _SEQUENT_ */
     330: #  ifndef POSIX
     331:     time_t  ms = (e - b) * 100 / HZ;
     332:
     333: #  else             /* POSIX */
     334:     clock_t ms = (e - b) * 100 / CLK_TCK;
     335:
     336: #  endif				/* POSIX */
     337:     cp = "%Uu %Ss %E %P";
     338:
     339:     /*
     340:      * the tms stuff is not very precise, so we fudge it.
     341:      * granularity fix: can't be more than 100%
     342:      * this breaks in multi-processor systems...
     343:      * maybe I should take it out and let people see more then 100%
     344:      * utilizations.
     345:      */
     346:     if (ms < t && ms != 0)
     347:     ms = t;
     348: # endif				/* _SEQUENT_ */
     349: #endif				/* BSDTIMES */
     350: #ifdef TDEBUG
     351:     xprintf("es->tms_utime %lu bs->tms_utime %lu\n",
     352:         es->tms_utime, bs->tms_utime);
     353:     xprintf("es->tms_stime %lu bs->tms_stime %lu\n",
     354:         es->tms_stime, bs->tms_stime);
     355:     xprintf("ms %lu e %lu b %lu\n", ms, e, b);
     356:     xprintf("t %lu\n", t);
     357: #endif				/* TDEBUG */
     358:
     359:     if (vp && vp->vec[0] && vp->vec[1])
     360:     cp = short2str(vp->vec[1]);
     361:     for (; *cp; cp++)
     362:     if (*cp != '%')
     363:         xputchar(*cp);
     364:     else if (cp[1])
     365:         switch (*++cp) {
     366:
     367:         case 'U':       /* user CPU time used */
     368: #ifdef BSDTIMES
     369:         pdeltat(&r1->ru_utime, &r0->ru_utime);
     370: #else
     371: # ifdef _SEQUENT_
     372:         pdeltat(&r1->ps_utime, &r0->ps_utime);
     373: # else              /* _SEQUENT_ */
     374: #  ifndef POSIX
     375:         pdtimet(es->tms_utime, bs->tms_utime);
     376: #  else             /* POSIX */
     377:         pdtimet(es->tms_utime, bs->tms_utime);
     378: #  endif				/* POSIX */
     379: # endif				/* _SEQUENT_ */
     380: #endif				/* BSDTIMES */
     381:         break;
     382:
     383:         case 'S':       /* system CPU time used */
     384: #ifdef BSDTIMES
     385:         pdeltat(&r1->ru_stime, &r0->ru_stime);
     386: #else
     387: # ifdef _SEQUENT_
     388:         pdeltat(&r1->ps_stime, &r0->ps_stime);
     389: # else              /* _SEQUENT_ */
     390: #  ifndef POSIX
     391:         pdtimet(es->tms_stime, bs->tms_stime);
     392: #  else             /* POSIX */
     393:         pdtimet(es->tms_stime, bs->tms_stime);
     394: #  endif				/* POSIX */
     395: # endif				/* _SEQUENT_ */
     396: #endif				/* BSDTIMES */
     397:         break;
     398:
     399:         case 'E':       /* elapsed (wall-clock) time */
     400: #ifdef BSDTIMES
     401:         pcsecs((long) ms);
     402: #else               /* BSDTIMES */
     403:         pcsecs(ms);
     404: #endif				/* BSDTIMES */
     405:         break;
     406:
     407:         case 'P':       /* percent time spent running */
     408:         /* check if the process did not run */
     409:         i = (ms == 0) ? 0 : (t * 1000 / ms);
     410:         xprintf("%ld.%01ld%%", i / 10, i % 10); /* nn.n% */
     411:         break;
     412:
     413: #ifdef BSDTIMES
     414: #ifdef pdp11
     415:         case 'V':
     416:         xprintf("%ld", r1->ru_ovly - r0->ru_ovly);
     417:         break;
     418: #endif
     419:
     420:         case 'W':       /* number of swaps */
     421:         i = r1->ru_nswap - r0->ru_nswap;
     422:         xprintf("%ld", i);
     423:         break;
     424:
     425:         case 'X':       /* (average) shared text size */
     426:         xprintf("%ld", t == 0 ? 0L :
     427:             IADJUST(r1->ru_ixrss - r0->ru_ixrss) / t);
     428:         break;
     429:
     430:         case 'D':       /* (average) unshared data size */
     431:         xprintf("%ld", t == 0 ? 0L :
     432:             IADJUST(r1->ru_idrss + r1->ru_isrss -
     433:                 (r0->ru_idrss + r0->ru_isrss)) / t);
     434:         break;
     435:
     436:         case 'K':       /* (average) total data memory used  */
     437:         xprintf("%ld", t == 0 ? 0L :
     438:             IADJUST((r1->ru_ixrss + r1->ru_isrss + r1->ru_idrss) -
     439:                (r0->ru_ixrss + r0->ru_idrss + r0->ru_isrss)) / t);
     440:         break;
     441:
     442:         case 'M':       /* max. Resident Set Size */
     443: #ifdef sun
     444:         /* xprintf("%ld", r1->ru_maxrss * 1024L/(long) getpagesize()); */
     445:         xprintf("%ld", pagetok(r1->ru_maxrss));
     446: #else
     447:         xprintf("%ld", r1->ru_maxrss / 2L);
     448: #endif				/* sun */
     449:         break;
     450:
     451:         case 'F':       /* page faults */
     452:         xprintf("%ld", r1->ru_majflt - r0->ru_majflt);
     453:         break;
     454:
     455:         case 'R':       /* page reclaims */
     456:         xprintf("%ld", r1->ru_minflt - r0->ru_minflt);
     457:         break;
     458:
     459:         case 'I':       /* FS blocks in */
     460:         xprintf("%ld", r1->ru_inblock - r0->ru_inblock);
     461:         break;
     462:
     463:         case 'O':       /* FS blocks out */
     464:         xprintf("%ld", r1->ru_oublock - r0->ru_oublock);
     465:         break;
     466:
     467:         case 'r':       /* PWP: socket messages recieved */
     468:         xprintf("%ld", r1->ru_msgrcv - r0->ru_msgrcv);
     469:         break;
     470:
     471:         case 's':       /* PWP: socket messages sent */
     472:         xprintf("%ld", r1->ru_msgsnd - r0->ru_msgsnd);
     473:         break;
     474:
     475:         case 'k':       /* PWP: number of signals recieved */
     476:         xprintf("%ld", r1->ru_nsignals - r0->ru_nsignals);
     477:         break;
     478:
     479:         case 'w':       /* PWP: num. voluntary context switches (waits) */
     480:         xprintf("%ld", r1->ru_nvcsw - r0->ru_nvcsw);
     481:         break;
     482:
     483:         case 'c':       /* PWP: num. involuntary context switches */
     484:         xprintf("%ld", r1->ru_nivcsw - r0->ru_nivcsw);
     485:         break;
     486: #else               /* BSDTIMES */
     487: # ifdef _SEQUENT_
     488:         case 'W':       /* number of swaps */
     489:         i = r1->ps_swap - r0->ps_swap;
     490:         xprintf("%ld", i);
     491:         break;
     492:
     493:         case 'M':
     494:         xprintf("%ld", r1->ps_maxrss / 2);
     495:         break;
     496:
     497:         case 'F':
     498:         xprintf("%ld", r1->ps_pagein - r0->ps_pagein);
     499:         break;
     500:
     501:         case 'R':
     502:         xprintf("%ld", r1->ps_reclaim - r0->ps_reclaim);
     503:         break;
     504:
     505:         case 'I':
     506:         xprintf("%ld", r1->ps_bread - r0->ps_bread);
     507:         break;
     508:
     509:         case 'O':
     510:         xprintf("%ld", r1->ps_bwrite - r0->ps_bwrite);
     511:         break;
     512:
     513:         case 'k':
     514:         xprintf("%ld", r1->ps_signal - r0->ps_signal);
     515:         break;
     516:
     517:         case 'w':
     518:         xprintf("%ld", r1->ps_volcsw - r0->ps_volcsw);
     519:         break;
     520:
     521:         case 'c':
     522:         xprintf("%ld", r1->ps_involcsw - r0->ps_involcsw);
     523:         break;
     524:
     525:         case 'Z':
     526:         xprintf("%ld", r1->ps_zerofill - r0->ps_zerofill);
     527:         break;
     528:
     529:         case 'i':
     530:         xprintf("%ld", r1->ps_pffincr - r0->ps_pffincr);
     531:         break;
     532:
     533:         case 'd':
     534:         xprintf("%ld", r1->ps_pffdecr - r0->ps_pffdecr);
     535:         break;
     536:
     537:         case 'Y':
     538:         xprintf("%ld", r1->ps_syscall - r0->ps_syscall);
     539:         break;
     540:
     541:         case 'l':
     542:         xprintf("%ld", r1->ps_lread - r0->ps_lread);
     543:         break;
     544:
     545:         case 'm':
     546:         xprintf("%ld", r1->ps_lwrite - r0->ps_lwrite);
     547:         break;
     548:
     549:         case 'p':
     550:         xprintf("%ld", r1->ps_phread - r0->ps_phread);
     551:         break;
     552:
     553:         case 'q':
     554:         xprintf("%ld", r1->ps_phwrite - r0->ps_phwrite);
     555:         break;
     556: # endif				/* _SEQUENT_ */
     557: #endif				/* BSDTIMES */
     558:         }
     559:     xputchar('\n');
     560: }
     561:
     562: #if defined(BSDTIMES) || defined(_SEQUENT_)
     563: static void
     564: pdeltat(t1, t0)
     565:     tmval_t *t1, *t0;
     566: {
     567:     tmval_t td;
     568:
     569:     tvsub(&td, t1, t0);
     570:     xprintf("%d.%01d", td.tv_sec, td.tv_usec / 100000);
     571: }
     572:
     573: void
     574: tvadd(tsum, t0)
     575:     tmval_t *tsum, *t0;
     576: {
     577:
     578:     tsum->tv_sec += t0->tv_sec;
     579:     tsum->tv_usec += t0->tv_usec;
     580:     if (tsum->tv_usec > 1000000)
     581:     tsum->tv_sec++, tsum->tv_usec -= 1000000;
     582: }
     583:
     584: void
     585: tvsub(tdiff, t1, t0)
     586:     tmval_t *tdiff, *t1, *t0;
     587: {
     588:
     589:     tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
     590:     tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
     591:     if (tdiff->tv_usec < 0)
     592:     tdiff->tv_sec--, tdiff->tv_usec += 1000000;
     593: }
     594:
     595: #else               /* !BSDTIMES && !_SEQUENT_ */
     596: static void
     597: pdtimet(eval, bval)
     598: #ifndef POSIX
     599:     time_t  eval, bval;
     600:
     601: #else               /* POSIX */
     602:     clock_t eval, bval;
     603:
     604: #endif				/* POSIX */
     605: {
     606: #ifndef POSIX
     607:     time_t  val;
     608:
     609: #else               /* POSIX */
     610:     clock_t val;
     611:
     612: #endif				/* POSIX */
     613:
     614: #ifndef POSIX
     615:     val = (eval - bval) * 100 / HZ;
     616: #else               /* POSIX */
     617:     val = (eval - bval) * 100 / CLK_TCK;
     618: #endif				/* POSIX */
     619:
     620:     xprintf("%ld.%02ld", val / 100, val - (val / 100 * 100));
     621: }
     622:
     623: #endif				/* BSDTIMES || _SEQUENT_ */

#### Defined functions

donice defined in line 143; used 1 times

- in /usr/src/bin/tcsh/sh.init.c line 114

dotime defined in line 101; used 1 times

- in /usr/src/bin/tcsh/sh.init.c line 147

pdeltat defined in line 563; used 4 times

- in line 369-372(2), 385-388(2)

pdtimet defined in line 596; used 4 times

- in line 375-377(2), 391-393(2)

prusage defined in line 264; used 11 times

- in line 112, 120, 135
- in /usr/src/bin/tcsh/sh.proc.c line 1089, 1096, 1138, 1158, 1196
- in /usr/src/bin/tcsh/sh.time.c line 112, 120, 135

rcsid defined in line 39; never used
ruadd defined in line 189; used 10 times

- in line 80, 86, 110, 119
- in /usr/src/bin/tcsh/sh.proc.c line 1133, 1153
- in /usr/src/bin/tcsh/sh.time.c line 80, 86, 110, 119

settimes defined in line 71; used 1 times

- in /usr/src/bin/tcsh/sh.proc.c line 1685

tvadd defined in line 573; used 8 times

- in line 167-168(2), 193-194(2)
- in /usr/src/bin/tcsh/sh.time.c line 167-168(2), 193-194(2)

tvsub defined in line 584; used 4 times

- in line 569
- in /usr/src/bin/tcsh/sh.proc.c line 1134, 1154
- in /usr/src/bin/tcsh/sh.time.c line 569

#### Defined variables

times0 defined in line 57; used 8 times

- in line 88-92(7), 135

#### Defined macros

IADJUST defined in line 248; used 3 times

- in line 427-432(2), 438

LOG1024 defined in line 226; used 2 times

- in line 235-237(2)

RUSAGE_CHILDREN defined in line 54; used 2 times

- in line 79, 109

RUSAGE_SELF defined in line 53; used 3 times

- in line 52, 78, 108

pagetok defined in line 237; used 2 times

- in line 246, 445

Last modified: 1991-08-30 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1163 |