diff options
Diffstat (limited to 'usr.sbin/xntpd/util/precision.c')
-rw-r--r-- | usr.sbin/xntpd/util/precision.c | 87 |
1 files changed, 78 insertions, 9 deletions
diff --git a/usr.sbin/xntpd/util/precision.c b/usr.sbin/xntpd/util/precision.c index 69af19f..6961475 100644 --- a/usr.sbin/xntpd/util/precision.c +++ b/usr.sbin/xntpd/util/precision.c @@ -1,23 +1,27 @@ #include <sys/types.h> #include <sys/time.h> +#include "ntp_unixtime.h" #define DEFAULT_SYS_PRECISION -99 +int default_get_resolution(); int default_get_precision(); int main() { - printf("log2(precision) = %d\n", default_get_precision()); + printf("log2(resolution) = %d, log2(precision) = %d\n", + default_get_resolution(), + default_get_precision()); return 0; } -/* Find the precision of the system clock by watching how the current time +/* Find the resolution of the system clock by watching how the current time * changes as we read it repeatedly. * * struct timeval is only good to 1us, which may cause problems as machines * get faster, but until then the logic goes: * - * If a machine has precision (i.e. accurate timing info) > 1us, then it will + * If a machine has resolution (i.e. accurate timing info) > 1us, then it will * probably use the "unused" low order bits as a counter (to force time to be * a strictly increaing variable), incrementing it each time any process * requests the time [[ or maybe time will stand still ? ]]. @@ -28,7 +32,7 @@ main() { * THEN this machine is "counting" with the low order bits * ELIF this is not the first time round the loop * THEN this machine *WAS* counting, and has now stepped - * ELSE this machine has precision < time to read clock + * ELSE this machine has resolution < time to read clock * * SO: if it exits on the first loop, assume "full accuracy" (1us) * otherwise, take the log2(observered difference, rounded UP) @@ -47,9 +51,11 @@ main() { #define MINSTEP 5 /* some systems increment uS on each call */ /* Don't use "1" as some *other* process may read too*/ /*We assume no system actually *ANSWERS* in this time*/ +#define MAXSTEP 20000 /* maximum clock increment (us) */ +#define MINLOOPS 5 /* minimum number of step samples */ #define MAXLOOPS HUSECS /* Assume precision < .1s ! */ -int default_get_precision() +int default_get_resolution() { struct timeval tp; struct timezone tzp; @@ -57,7 +63,7 @@ int default_get_precision() int i; long diff; long val; - int minsteps = 2; /* need at least this many steps */ + int minsteps = MINLOOPS; /* need at least this many steps */ gettimeofday(&tp, &tzp); last = tp.tv_usec; @@ -69,13 +75,76 @@ int default_get_precision() last = tp.tv_usec; } - printf("precision calculation given %dus after %d loop%s\n", + printf("resolution = %ld usec after %d loop%s\n", diff, i, (i==1) ? "" : "s"); diff = (diff *3)/2; - if (i >= MAXLOOPS) diff = 1; /* No STEP, so FAST machine */ - if (i == 0) diff = 1; /* time to read clock >= precision */ + if (i >= MAXLOOPS) { + printf( + " (Boy this machine is fast ! %d loops without a step)\n", + MAXLOOPS); + diff = 1; /* No STEP, so FAST machine */ + } + if (i == 0) { + printf( +" (The resolution is less than the time to read the clock -- Assume 1us)\n"); + diff = 1; /* time to read clock >= resolution */ + } for (i=0, val=HUSECS; val>0; i--, val >>= 1) if (diff >= val) return i; + printf(" (Oh dear -- that wasn't expected ! I'll guess !)\n"); return DEFAULT_SYS_PRECISION /* Something's BUST, so lie ! */; } +/* ===== Rest of this code lifted straight from xntpd/ntp_proto.c ! ===== */ + +/* + * This routine calculates the differences between successive calls to + * gettimeofday(). If a difference is less than zero, the us field + * has rolled over to the next second, so we add a second in us. If + * the difference is greater than zero and less than MINSTEP, the + * clock has been advanced by a small amount to avoid standing still. + * If the clock has advanced by a greater amount, then a timer interrupt + * has occurred and this amount represents the precision of the clock. + * In order to guard against spurious values, which could occur if we + * happen to hit a fat interrupt, we do this for MINLOOPS times and + * keep the minimum value obtained. + */ +int default_get_precision() +{ + struct timeval tp; + struct timezone tzp; + long last; + int i; + long diff; + long val; + long usec; + + usec = 0; + val = MAXSTEP; + GETTIMEOFDAY(&tp, &tzp); + last = tp.tv_usec; + for (i = 0; i < MINLOOPS && usec < HUSECS;) { + GETTIMEOFDAY(&tp, &tzp); + diff = tp.tv_usec - last; + last = tp.tv_usec; + if (diff < 0) + diff += DUSECS; + usec += diff; + if (diff > MINSTEP) { + i++; + if (diff < val) + val = diff; + } + } + printf("precision = %ld usec after %d loop%s\n", + val, i, (i == 1) ? "" : "s"); + if (usec >= HUSECS) { + printf(" (Boy this machine is fast ! usec was %ld)\n", + usec); + val = MINSTEP; /* val <= MINSTEP; fast machine */ + } + diff = HUSECS; + for (i = 0; diff > val; i--) + diff >>= 1; + return (i); +} |