Return to hist.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / util

Annotation of embedaddon/ntp/util/hist.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * This program can be used to calibrate the clock reading jitter of a
                      3:  * particular CPU and operating system. It first tickles every element
                      4:  * of an array, in order to force pages into memory, then repeatedly calls
                      5:  * gettimeofday() and, finally, writes out the time values for later
                      6:  * analysis. From this you can determine the jitter and if the clock ever
                      7:  * runs backwards.
                      8:  */
                      9: 
                     10: #ifdef HAVE_CONFIG_H
                     11: # include <config.h>
                     12: #endif
                     13: 
                     14: #include "ntp_types.h"
                     15: 
                     16: #include <stdio.h>
                     17: #include <stdlib.h>
                     18: 
                     19: #define NBUF 100001            /* size of basic histogram */
                     20: #define NSRT 20000             /* size of overflow histogram */
                     21: #define NCNT (600 * 1000000)   /* sample interval (us) */
                     22: 
                     23: int col (long *, long *);
                     24: 
                     25: int
                     26: main(
                     27:        int argc,
                     28:        char *argv[]
                     29:        )
                     30: {
                     31:        struct timeval ts, tr, tp;
                     32:        struct timezone tzp;
                     33:        int i, j, n;
                     34:        long t, u, v, w, gtod[NBUF], ovfl[NSRT];
                     35: 
                     36:        /*
                     37:         * Force pages into memory
                     38:         */
                     39:        for (i = 0; i < NBUF; i++)
                     40:            gtod[i] = 0;
                     41:        for (i = 0; i < NSRT; i++)
                     42:            ovfl[i] = 0;
                     43: 
                     44:        /*
                     45:         * Construct histogram
                     46:         */
                     47:        n = 0;
                     48:        gettimeofday(&ts, &tzp);
                     49:        t = ts.tv_sec * 1000000 + ts.tv_usec;
                     50:        v = t;
                     51:        while (1) {
                     52:                gettimeofday(&tr, &tzp);
                     53:                u = tr.tv_sec * 1000000 + tr.tv_usec; 
                     54:                if (u - v > NCNT)
                     55:                    break;
                     56:                w = u - t;
                     57:                if (w <= 0) {
                     58: /*
                     59:                        printf("error <= 0 %ld %d %d, %d %d\n", w, ts.tv_sec,
                     60:                               ts.tv_usec, tr.tv_sec, tr.tv_usec);
                     61: */
                     62:                } else if (w > NBUF - 1) {
                     63:                        ovfl[n] = w;
                     64:                        if (n < NSRT - 1)
                     65:                            n++;
                     66:                } else {
                     67:                        gtod[w]++;
                     68:                }
                     69:                ts = tr;
                     70:                t = u;
                     71:        }
                     72: 
                     73:        /*
                     74:         * Write out histogram
                     75:         */
                     76:        for (i = 0; i < NBUF - 1; i++) {
                     77:                if (gtod[i] > 0)
                     78:                    printf("%ld %ld\n", i, gtod[i]);
                     79:        }
                     80:        if (n == 0)
                     81:            return;
                     82:        qsort(
                     83: #ifdef QSORT_USES_VOID_P
                     84:            (void *)
                     85: #else
                     86:            (char *)
                     87: #endif
                     88:            ovfl, (size_t)n, sizeof(long), col);
                     89:        w = 0;
                     90:        j = 0;
                     91:        for (i = 0; i < n; i++) {
                     92:                if (ovfl[i] != w) {
                     93:                        if (j > 0)
                     94:                            printf("%ld %ld\n", w, j);
                     95:                        w = ovfl[i];
                     96:                        j = 1;
                     97:                } else
                     98:                    j++;
                     99:        }
                    100:        if (j > 0)
                    101:            printf("%ld %ld\n", w, j);
                    102:  
                    103:        exit(0);
                    104: }
                    105: 
                    106: int
                    107: col(
                    108:        long *x,
                    109:        long *y
                    110:        )
                    111: {
                    112:        return (*x - *y);
                    113: }