Annotation of embedaddon/ntp/util/precision.c, revision 1.1.1.1
1.1 misho 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
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
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
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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to precision.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / util