Annotation of 43BSDReno/sys/nfs/TEST/unix-tests/general/stat.c, revision 1.1.1.1

1.1       root        1: /*     @(#)stat.c      1.2 90/01/03 NFS Rev 2 Testsuite        */
                      2: /*     1.3 Lachman ONC Test Suite source       */
                      3: 
                      4: #include <stdio.h>
                      5: #include <math.h>
                      6: 
                      7: /*
                      8:  *  crunch through time stat files.  This program will handle two
                      9:  *  formats: BSD
                     10:  *             1.7 real         0.0 user         0.4 sys  
                     11:  *  and ATT
                     12:  *             real        1.4
                     13:  *             user        0.0
                     14:  *             sys         0.2
                     15:  *
                     16:  *  ATT format may break out minutes -- 2:03.2
                     17:  */
                     18: #define MAXINDEX 100
                     19: double real[MAXINDEX];
                     20: double user[MAXINDEX];
                     21: double sys[MAXINDEX];
                     22: char   *Prog, *File;
                     23: 
                     24: main(argc, argv)
                     25: int    argc;
                     26: char   *argv[];
                     27: {
                     28:        FILE    *fp;
                     29:        int     i, n;
                     30:        char    c, *fmt;
                     31:        int     attfmt = 0;     /* set if using att time format */
                     32: 
                     33:        Prog = argv[0];
                     34:        if (argc == 1) {
                     35:                fprintf(stderr, "Usage: %s datafile\n", Prog);
                     36:                exit(1);
                     37:        }
                     38:        File = argv[1];
                     39:        fp = fopen(File, "r");
                     40:        if (fp == NULL) {
                     41:                fprintf(stderr, "%s: unable to open %s\n",
                     42:                        Prog, File);
                     43:                exit(1);
                     44:        }
                     45:        if ((i = fgetc(fp)) == EOF) {
                     46:                fprintf(stderr, "%s: %s is empty\n",
                     47:                        Prog, File);
                     48:                exit(1);
                     49:        }
                     50:        c = i & 0x7f;
                     51:        if (c == '\n' || c == '\r' || c == 'r')
                     52:                attfmt = 1;
                     53:        else
                     54:                fmt = "%F %*s %F %*s %F %*s";           /* BSD fmt */
                     55:        if (ungetc(c, fp) == EOF) {
                     56:                fprintf(stderr, "%s: can't push char back to %s\n",
                     57:                         Prog, File);
                     58:                 exit(1); 
                     59:        }
                     60: 
                     61:        if (attfmt) {
                     62:                for (n = 0; getattfmt(fp, n, 1); n++) {
                     63:                        getattfmt(fp, n, 2);
                     64:                        getattfmt(fp, n, 3);
                     65:                }
                     66:        } else {
                     67:                n = 0;
                     68:                while(fscanf(fp, fmt, &real[n], &user[n], &sys[n]) == 3)
                     69:                        n++;
                     70:        }
                     71:        if (n == 0) {
                     72:                fprintf(stderr, "%s: no data in %s\n",
                     73:                         Prog, File);
                     74: #ifdef SVR3
                     75:                 exit(0);
                     76: #else
                     77:                 exit(1);
                     78: #endif
                     79:         }
                     80:        stat(real, n);
                     81:        printf(" real");
                     82:        stat(user, n);
                     83:        printf(" user");
                     84:        stat(sys, n);
                     85:        printf(" sys\n");
                     86: 
                     87:        exit(0);
                     88: }
                     89: 
                     90: /*
                     91:  *  which:  1: real, 2:user, 3:sys
                     92:  *
                     93:  *  returns 0 if no more data, else 1
                     94:  */
                     95: getattfmt(fp, n, which)
                     96: FILE *fp;
                     97: int n, which;
                     98: {
                     99:        char    buf[BUFSIZ];
                    100:        char    *p;
                    101:        char    *fmt;
                    102:        double  *dp;
                    103:        int     min, err = 0;
                    104: 
                    105:        if (n < 0 || n >= MAXINDEX) {
                    106:                fprintf(stderr, "%s: illegal index=%d in getattfmt\n",
                    107:                        Prog, n);
                    108:                exit(1);
                    109:        }
                    110:        switch(which) {
                    111:            case 1:             /* real */
                    112:                dp = &real[n];
                    113:                break;
                    114:            case 2:             /* user */
                    115:                dp = &user[n];
                    116:                break;
                    117:            case 3:             /* sys  */
                    118:                dp = &sys[n];
                    119:                break;
                    120:            default:
                    121:                fprintf(stderr, "%s: illegal which=%d in getattfmt\n",
                    122:                        Prog, which);
                    123:                exit(1);
                    124:        }
                    125: 
                    126:        while (fgets(buf, BUFSIZ, fp)) {
                    127:                /* null out newline */
                    128:                for (p = buf; *p && *p != '\n'; p++)
                    129:                        ;
                    130:                if (*p == '\n')
                    131:                        *p = '\0';
                    132: 
                    133:                /* look for blank line and skip it */
                    134:                for (p = buf; *p && (*p == ' ' || *p == '\t'); p++)
                    135:                        ;
                    136:                if (*p == '\0')
                    137:                        continue;
                    138: 
                    139:                min = 0;
                    140:                for (p = buf; *p && *p != ':'; p++)
                    141:                        ;
                    142:                if (*p == ':') {
                    143:                        fmt = "%*s %d:%F";
                    144:                        if (sscanf(buf, fmt, &min, dp) != 2)
                    145:                                err = 1;
                    146:                } else {
                    147:                        fmt = "%*s %F";
                    148:                        if (sscanf(buf, fmt, dp) != 1)
                    149:                                err = 1;
                    150:                }
                    151:                if (err) {
                    152:                        fprintf(stderr, "%s: bad data format in %s (%s)\n",
                    153:                                Prog, File, buf);
                    154:                        exit(1);
                    155:                }
                    156:                if (min > 0)
                    157:                        *dp += (double)(min * 60);
                    158:                return 1;
                    159:        }
                    160:        /* EOF */
                    161:        if (which == 1)
                    162:                return 0;
                    163:        else {
                    164:                fprintf(stderr, "%s: premature EOF in %s\n",
                    165:                        Prog, File);
                    166:                exit(1);
                    167:        }
                    168: }
                    169:                        
                    170: stat(array, n)
                    171: double array[];
                    172: int    n;
                    173: {
                    174:        double  avg, sd;
                    175:        int     i;
                    176:        
                    177:        avg = 0;
                    178:        for (i = 0; i < n; i++)
                    179:                avg += array[i];
                    180:        avg = avg / (float) n;
                    181:        sd = 0;
                    182:        for (i = 0; i < n; i++)
                    183:                sd += (array[i] - avg)*(array[i] - avg);
                    184:        if (n > 1) {
                    185:                sd = sd / (float) (n - 1);
                    186:                sd = sqrt(sd);  
                    187:        } else {
                    188:                sd = 0.0;
                    189:        }
                    190:        printf("\t%.1f (%.1f)", avg, sd);
                    191: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.