1 #include "ntp_unixtime.h"
2
3 #include <stdio.h>
4
5 #define DEFAULT_SYS_PRECISION -99
6
7 int default_get_resolution();
8 int default_get_precision();
9
10 int
main(int argc,char * argv[])11 main(
12 int argc,
13 char *argv[]
14 )
15 {
16 printf("log2(resolution) = %d, log2(precision) = %d\n",
17 default_get_resolution(),
18 default_get_precision());
19 return 0;
20 }
21
22 /* Find the resolution of the system clock by watching how the current time
23 * changes as we read it repeatedly.
24 *
25 * struct timeval is only good to 1us, which may cause problems as machines
26 * get faster, but until then the logic goes:
27 *
28 * If a machine has resolution (i.e. accurate timing info) > 1us, then it will
29 * probably use the "unused" low order bits as a counter (to force time to be
30 * a strictly increaing variable), incrementing it each time any process
31 * requests the time [[ or maybe time will stand still ? ]].
32 *
33 * SO: the logic goes:
34 *
35 * IF the difference from the last time is "small" (< MINSTEP)
36 * THEN this machine is "counting" with the low order bits
37 * ELIF this is not the first time round the loop
38 * THEN this machine *WAS* counting, and has now stepped
39 * ELSE this machine has resolution < time to read clock
40 *
41 * SO: if it exits on the first loop, assume "full accuracy" (1us)
42 * otherwise, take the log2(observered difference, rounded UP)
43 *
44 * MINLOOPS > 1 ensures that even if there is a STEP between the initial call
45 * and the first loop, it doesn't stop too early.
46 * Making it even greater allows MINSTEP to be reduced, assuming that the
47 * chance of MINSTEP-1 other processes getting in and calling gettimeofday
48 * between this processes's calls.
49 * Reducing MINSTEP may be necessary as this sets an upper bound for the time
50 * to actually call gettimeofday.
51 */
52
53 #define DUSECS 1000000
54 #define HUSECS (1024 * 1024)
55 #define MINSTEP 5 /* some systems increment uS on each call */
56 /* Don't use "1" as some *other* process may read too*/
57 /*We assume no system actually *ANSWERS* in this time*/
58 #define MAXSTEP 20000 /* maximum clock increment (us) */
59 #define MINLOOPS 5 /* minimum number of step samples */
60 #define MAXLOOPS HUSECS /* Assume precision < .1s ! */
61
62 int
default_get_resolution(void)63 default_get_resolution(void)
64 {
65 struct timeval tp;
66 struct timezone tzp;
67 long last;
68 int i;
69 long diff;
70 long val;
71 int minsteps = MINLOOPS; /* need at least this many steps */
72
73 gettimeofday(&tp, &tzp);
74 last = tp.tv_usec;
75 for (i = - --minsteps; i< MAXLOOPS; i++) {
76 gettimeofday(&tp, &tzp);
77 diff = tp.tv_usec - last;
78 if (diff < 0) diff += DUSECS;
79 if (diff > MINSTEP) if (minsteps-- <= 0) break;
80 last = tp.tv_usec;
81 }
82
83 printf("resolution = %ld usec after %d loop%s\n",
84 diff, i, (i==1) ? "" : "s");
85
86 diff = (diff *3)/2;
87 if (i >= MAXLOOPS) {
88 printf(
89 " (Boy this machine is fast ! %d loops without a step)\n",
90 MAXLOOPS);
91 diff = 1; /* No STEP, so FAST machine */
92 }
93 if (i == 0) {
94 printf(
95 " (The resolution is less than the time to read the clock -- Assume 1us)\n");
96 diff = 1; /* time to read clock >= resolution */
97 }
98 for (i=0, val=HUSECS; val>0; i--, val >>= 1) if (diff >= val) return i;
99 printf(" (Oh dear -- that wasn't expected ! I'll guess !)\n");
100 return DEFAULT_SYS_PRECISION /* Something's BUST, so lie ! */;
101 }
102
103 /* ===== Rest of this code lifted straight from xntpd/ntp_proto.c ! ===== */
104
105 /*
106 * This routine calculates the differences between successive calls to
107 * gettimeofday(). If a difference is less than zero, the us field
108 * has rolled over to the next second, so we add a second in us. If
109 * the difference is greater than zero and less than MINSTEP, the
110 * clock has been advanced by a small amount to avoid standing still.
111 * If the clock has advanced by a greater amount, then a timer interrupt
112 * has occurred and this amount represents the precision of the clock.
113 * In order to guard against spurious values, which could occur if we
114 * happen to hit a fat interrupt, we do this for MINLOOPS times and
115 * keep the minimum value obtained.
116 */
117 int
default_get_precision(void)118 default_get_precision(void)
119 {
120 struct timeval tp;
121 struct timezone tzp;
122 #ifdef HAVE_GETCLOCK
123 struct timespec ts;
124 #endif
125 long last;
126 int i;
127 long diff;
128 long val;
129 long usec;
130
131 usec = 0;
132 val = MAXSTEP;
133 #ifdef HAVE_GETCLOCK
134 (void) getclock(TIMEOFDAY, &ts);
135 tp.tv_sec = ts.tv_sec;
136 tp.tv_usec = ts.tv_nsec / 1000;
137 #else /* not HAVE_GETCLOCK */
138 GETTIMEOFDAY(&tp, &tzp);
139 #endif /* not HAVE_GETCLOCK */
140 last = tp.tv_usec;
141 for (i = 0; i < MINLOOPS && usec < HUSECS;) {
142 #ifdef HAVE_GETCLOCK
143 (void) getclock(TIMEOFDAY, &ts);
144 tp.tv_sec = ts.tv_sec;
145 tp.tv_usec = ts.tv_nsec / 1000;
146 #else /* not HAVE_GETCLOCK */
147 GETTIMEOFDAY(&tp, &tzp);
148 #endif /* not HAVE_GETCLOCK */
149 diff = tp.tv_usec - last;
150 last = tp.tv_usec;
151 if (diff < 0)
152 diff += DUSECS;
153 usec += diff;
154 if (diff > MINSTEP) {
155 i++;
156 if (diff < val)
157 val = diff;
158 }
159 }
160 printf("precision = %ld usec after %d loop%s\n",
161 val, i, (i == 1) ? "" : "s");
162 if (usec >= HUSECS) {
163 printf(" (Boy this machine is fast ! usec was %ld)\n",
164 usec);
165 val = MINSTEP; /* val <= MINSTEP; fast machine */
166 }
167 diff = HUSECS;
168 for (i = 0; diff > val; i--)
169 diff >>= 1;
170 return (i);
171 }
172