Annotation of embedaddon/ntp/util/jitter.h, revision 1.1.1.1
1.1 misho 1: /*
2: * ntp_types.h - defines how int32 and u_int32 are treated.
3: * For 64 bit systems like the DEC Alpha, they have to be defined
4: * as int and u_int.
5: * For 32 bit systems, define them as long and u_long
6: */
7: #define SIZEOF_INT 4
8:
9: /*
10: * VMS DECC (v4.1), {u_char,u_short,u_long} are only in SOCKET.H,
11: * and u_int isn't defined anywhere
12: */
13: #if defined(VMS)
14: #include <socket.h>
15: typedef unsigned int u_int;
16: /*
17: * Note: VMS DECC has long == int (even on __alpha),
18: * so the distinction below doesn't matter
19: */
20: #endif /* VMS */
21:
22: #if (SIZEOF_INT == 4)
23: # ifndef int32
24: # define int32 int
25: # endif
26: # ifndef u_int32
27: # define u_int32 unsigned int
28: # endif
29: #else /* not sizeof(int) == 4 */
30: # if (SIZEOF_LONG == 4)
31: # else /* not sizeof(long) == 4 */
32: # ifndef int32
33: # define int32 long
34: # endif
35: # ifndef u_int32
36: # define u_int32 unsigned long
37: # endif
38: # endif /* not sizeof(long) == 4 */
39: # include "Bletch: what's 32 bits on this machine?"
40: #endif /* not sizeof(int) == 4 */
41:
42: typedef unsigned short associd_t; /* association ID */
43: typedef u_int32 keyid_t; /* cryptographic key ID */
44: typedef u_int32 tstamp_t; /* NTP seconds timestamp */
45:
46: /*
47: * NTP uses two fixed point formats. The first (l_fp) is the "long"
48: * format and is 64 bits long with the decimal between bits 31 and 32.
49: * This is used for time stamps in the NTP packet header (in network
50: * byte order) and for internal computations of offsets (in local host
51: * byte order). We use the same structure for both signed and unsigned
52: * values, which is a big hack but saves rewriting all the operators
53: * twice. Just to confuse this, we also sometimes just carry the
54: * fractional part in calculations, in both signed and unsigned forms.
55: * Anyway, an l_fp looks like:
56: *
57: * 0 1 2 3
58: * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
59: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
60: * | Integral Part |
61: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
62: * | Fractional Part |
63: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
64: *
65: */
66: typedef struct {
67: union {
68: u_int32 Xl_ui;
69: int32 Xl_i;
70: } Ul_i;
71: union {
72: u_int32 Xl_uf;
73: int32 Xl_f;
74: } Ul_f;
75: } l_fp;
76:
77: #define l_ui Ul_i.Xl_ui /* unsigned integral part */
78: #define l_i Ul_i.Xl_i /* signed integral part */
79: #define l_uf Ul_f.Xl_uf /* unsigned fractional part */
80: #define l_f Ul_f.Xl_f /* signed fractional part */
81:
82: /*
83: * Fractional precision (of an l_fp) is actually the number of
84: * bits in a long.
85: */
86: #define FRACTION_PREC (32)
87:
88:
89: /*
90: * The second fixed point format is 32 bits, with the decimal between
91: * bits 15 and 16. There is a signed version (s_fp) and an unsigned
92: * version (u_fp). This is used to represent synchronizing distance
93: * and synchronizing dispersion in the NTP packet header (again, in
94: * network byte order) and internally to hold both distance and
95: * dispersion values (in local byte order). In network byte order
96: * it looks like:
97: *
98: * 0 1 2 3
99: * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
100: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
101: * | Integer Part | Fraction Part |
102: * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
103: *
104: */
105: typedef int32 s_fp;
106: typedef u_int32 u_fp;
107:
108: /*
109: * A unit second in fp format. Actually 2**(half_the_bits_in_a_long)
110: */
111: #define FP_SECOND (0x10000)
112:
113: /*
114: * Byte order conversions
115: */
116: #define HTONS_FP(x) (htonl(x))
117: #define HTONL_FP(h, n) do { (n)->l_ui = htonl((h)->l_ui); \
118: (n)->l_uf = htonl((h)->l_uf); } while (0)
119: #define NTOHS_FP(x) (ntohl(x))
120: #define NTOHL_FP(n, h) do { (h)->l_ui = ntohl((n)->l_ui); \
121: (h)->l_uf = ntohl((n)->l_uf); } while (0)
122: #define NTOHL_MFP(ni, nf, hi, hf) \
123: do { (hi) = ntohl(ni); (hf) = ntohl(nf); } while (0)
124: #define HTONL_MFP(hi, hf, ni, nf) \
125: do { (ni) = ntohl(hi); (nf) = ntohl(hf); } while (0)
126:
127: /* funny ones. Converts ts fractions to net order ts */
128: #define HTONL_UF(uf, nts) \
129: do { (nts)->l_ui = 0; (nts)->l_uf = htonl(uf); } while (0)
130: #define HTONL_F(f, nts) do { (nts)->l_uf = htonl(f); \
131: if ((f) & 0x80000000) \
132: (nts)->l_i = -1; \
133: else \
134: (nts)->l_i = 0; \
135: } while (0)
136:
137: /*
138: * Conversions between the two fixed point types
139: */
140: #define MFPTOFP(x_i, x_f) (((x_i) >= 0x00010000) ? 0x7fffffff : \
141: (((x_i) <= -0x00010000) ? 0x80000000 : \
142: (((x_i)<<16) | (((x_f)>>16)&0xffff))))
143: #define LFPTOFP(v) MFPTOFP((v)->l_i, (v)->l_f)
144:
145: #define UFPTOLFP(x, v) ((v)->l_ui = (u_fp)(x)>>16, (v)->l_uf = (x)<<16)
146: #define FPTOLFP(x, v) (UFPTOLFP((x), (v)), (x) < 0 ? (v)->l_ui -= 0x10000 : 0)
147:
148: #define MAXLFP(v) ((v)->l_ui = 0x7fffffff, (v)->l_uf = 0xffffffff)
149: #define MINLFP(v) ((v)->l_ui = 0x80000000, (v)->l_uf = 0)
150:
151: /*
152: * Primitive operations on long fixed point values. If these are
153: * reminiscent of assembler op codes it's only because some may
154: * be replaced by inline assembler for particular machines someday.
155: * These are the (kind of inefficient) run-anywhere versions.
156: */
157: #define M_NEG(v_i, v_f) /* v = -v */ \
158: do { \
159: if ((v_f) == 0) \
160: (v_i) = -((s_fp)(v_i)); \
161: else { \
162: (v_f) = -((s_fp)(v_f)); \
163: (v_i) = ~(v_i); \
164: } \
165: } while(0)
166:
167: #define M_NEGM(r_i, r_f, a_i, a_f) /* r = -a */ \
168: do { \
169: if ((a_f) == 0) { \
170: (r_f) = 0; \
171: (r_i) = -(a_i); \
172: } else { \
173: (r_f) = -(a_f); \
174: (r_i) = ~(a_i); \
175: } \
176: } while(0)
177:
178: #define M_ADD(r_i, r_f, a_i, a_f) /* r += a */ \
179: do { \
180: register u_int32 lo_tmp; \
181: register u_int32 hi_tmp; \
182: \
183: lo_tmp = ((r_f) & 0xffff) + ((a_f) & 0xffff); \
184: hi_tmp = (((r_f) >> 16) & 0xffff) + (((a_f) >> 16) & 0xffff); \
185: if (lo_tmp & 0x10000) \
186: hi_tmp++; \
187: (r_f) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \
188: \
189: (r_i) += (a_i); \
190: if (hi_tmp & 0x10000) \
191: (r_i)++; \
192: } while (0)
193:
194: #define M_ADD3(r_ovr, r_i, r_f, a_ovr, a_i, a_f) /* r += a, three word */ \
195: do { \
196: register u_int32 lo_tmp; \
197: register u_int32 hi_tmp; \
198: \
199: lo_tmp = ((r_f) & 0xffff) + ((a_f) & 0xffff); \
200: hi_tmp = (((r_f) >> 16) & 0xffff) + (((a_f) >> 16) & 0xffff); \
201: if (lo_tmp & 0x10000) \
202: hi_tmp++; \
203: (r_f) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \
204: \
205: lo_tmp = ((r_i) & 0xffff) + ((a_i) & 0xffff); \
206: if (hi_tmp & 0x10000) \
207: lo_tmp++; \
208: hi_tmp = (((r_i) >> 16) & 0xffff) + (((a_i) >> 16) & 0xffff); \
209: if (lo_tmp & 0x10000) \
210: hi_tmp++; \
211: (r_i) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \
212: \
213: (r_ovr) += (a_ovr); \
214: if (hi_tmp & 0x10000) \
215: (r_ovr)++; \
216: } while (0)
217:
218: #define M_SUB(r_i, r_f, a_i, a_f) /* r -= a */ \
219: do { \
220: register u_int32 lo_tmp; \
221: register u_int32 hi_tmp; \
222: \
223: if ((a_f) == 0) { \
224: (r_i) -= (a_i); \
225: } else { \
226: lo_tmp = ((r_f) & 0xffff) + ((-((s_fp)(a_f))) & 0xffff); \
227: hi_tmp = (((r_f) >> 16) & 0xffff) \
228: + (((-((s_fp)(a_f))) >> 16) & 0xffff); \
229: if (lo_tmp & 0x10000) \
230: hi_tmp++; \
231: (r_f) = ((hi_tmp & 0xffff) << 16) | (lo_tmp & 0xffff); \
232: \
233: (r_i) += ~(a_i); \
234: if (hi_tmp & 0x10000) \
235: (r_i)++; \
236: } \
237: } while (0)
238:
239: #define M_RSHIFTU(v_i, v_f) /* v >>= 1, v is unsigned */ \
240: do { \
241: (v_f) = (u_int32)(v_f) >> 1; \
242: if ((v_i) & 01) \
243: (v_f) |= 0x80000000; \
244: (v_i) = (u_int32)(v_i) >> 1; \
245: } while (0)
246:
247: #define M_RSHIFT(v_i, v_f) /* v >>= 1, v is signed */ \
248: do { \
249: (v_f) = (u_int32)(v_f) >> 1; \
250: if ((v_i) & 01) \
251: (v_f) |= 0x80000000; \
252: if ((v_i) & 0x80000000) \
253: (v_i) = ((v_i) >> 1) | 0x80000000; \
254: else \
255: (v_i) = (v_i) >> 1; \
256: } while (0)
257:
258: #define M_LSHIFT(v_i, v_f) /* v <<= 1 */ \
259: do { \
260: (v_i) <<= 1; \
261: if ((v_f) & 0x80000000) \
262: (v_i) |= 0x1; \
263: (v_f) <<= 1; \
264: } while (0)
265:
266: #define M_LSHIFT3(v_ovr, v_i, v_f) /* v <<= 1, with overflow */ \
267: do { \
268: (v_ovr) <<= 1; \
269: if ((v_i) & 0x80000000) \
270: (v_ovr) |= 0x1; \
271: (v_i) <<= 1; \
272: if ((v_f) & 0x80000000) \
273: (v_i) |= 0x1; \
274: (v_f) <<= 1; \
275: } while (0)
276:
277: #define M_ADDUF(r_i, r_f, uf) /* r += uf, uf is u_int32 fraction */ \
278: M_ADD((r_i), (r_f), 0, (uf)) /* let optimizer worry about it */
279:
280: #define M_SUBUF(r_i, r_f, uf) /* r -= uf, uf is u_int32 fraction */ \
281: M_SUB((r_i), (r_f), 0, (uf)) /* let optimizer worry about it */
282:
283: #define M_ADDF(r_i, r_f, f) /* r += f, f is a int32 fraction */ \
284: do { \
285: if ((f) > 0) \
286: M_ADD((r_i), (r_f), 0, (f)); \
287: else if ((f) < 0) \
288: M_ADD((r_i), (r_f), (-1), (f));\
289: } while(0)
290:
291: #define M_ISNEG(v_i, v_f) /* v < 0 */ \
292: (((v_i) & 0x80000000) != 0)
293:
294: #define M_ISHIS(a_i, a_f, b_i, b_f) /* a >= b unsigned */ \
295: (((u_int32)(a_i)) > ((u_int32)(b_i)) || \
296: ((a_i) == (b_i) && ((u_int32)(a_f)) >= ((u_int32)(b_f))))
297:
298: #define M_ISGEQ(a_i, a_f, b_i, b_f) /* a >= b signed */ \
299: (((int32)(a_i)) > ((int32)(b_i)) || \
300: ((a_i) == (b_i) && ((u_int32)(a_f)) >= ((u_int32)(b_f))))
301:
302: #define M_ISEQU(a_i, a_f, b_i, b_f) /* a == b unsigned */ \
303: ((a_i) == (b_i) && (a_f) == (b_f))
304:
305: /*
306: * Operations on the long fp format
307: */
308: #define L_ADD(r, a) M_ADD((r)->l_ui, (r)->l_uf, (a)->l_ui, (a)->l_uf)
309: #define L_SUB(r, a) M_SUB((r)->l_ui, (r)->l_uf, (a)->l_ui, (a)->l_uf)
310: #define L_NEG(v) M_NEG((v)->l_ui, (v)->l_uf)
311: #define L_ADDUF(r, uf) M_ADDUF((r)->l_ui, (r)->l_uf, (uf))
312: #define L_SUBUF(r, uf) M_SUBUF((r)->l_ui, (r)->l_uf, (uf))
313: #define L_ADDF(r, f) M_ADDF((r)->l_ui, (r)->l_uf, (f))
314: #define L_RSHIFT(v) M_RSHIFT((v)->l_i, (v)->l_uf)
315: #define L_RSHIFTU(v) M_RSHIFT((v)->l_ui, (v)->l_uf)
316: #define L_LSHIFT(v) M_LSHIFT((v)->l_ui, (v)->l_uf)
317: #define L_CLR(v) ((v)->l_ui = (v)->l_uf = 0)
318:
319: #define L_ISNEG(v) (((v)->l_ui & 0x80000000) != 0)
320: #define L_ISZERO(v) ((v)->l_ui == 0 && (v)->l_uf == 0)
321: #define L_ISHIS(a, b) ((a)->l_ui > (b)->l_ui || \
322: ((a)->l_ui == (b)->l_ui && (a)->l_uf >= (b)->l_uf))
323: #define L_ISGEQ(a, b) ((a)->l_i > (b)->l_i || \
324: ((a)->l_i == (b)->l_i && (a)->l_uf >= (b)->l_uf))
325: #define L_ISEQU(a, b) M_ISEQU((a)->l_ui, (a)->l_uf, (b)->l_ui, (b)->l_uf)
326:
327: /*
328: * s_fp/double and u_fp/double conversions
329: */
330: #define FRIC 65536. /* 2^16 as a double */
331: #define DTOFP(r) ((s_fp)((r) * FRIC))
332: #define DTOUFP(r) ((u_fp)((r) * FRIC))
333: #define FPTOD(r) ((double)(r) / FRIC)
334:
335: /*
336: * l_fp/double conversions
337: */
338: #define FRAC 4294967296. /* 2^32 as a double */
339: #define M_DTOLFP(d, r_i, r_uf) /* double to l_fp */ \
340: do { \
341: register double d_tmp; \
342: \
343: d_tmp = (d); \
344: if (d_tmp < 0) { \
345: d_tmp = -d_tmp; \
346: (r_i) = (int32)(d_tmp); \
347: (r_uf) = (u_int32)(((d_tmp) - (double)(r_i)) * FRAC); \
348: M_NEG((r_i), (r_uf)); \
349: } else { \
350: (r_i) = (int32)(d_tmp); \
351: (r_uf) = (u_int32)(((d_tmp) - (double)(r_i)) * FRAC); \
352: } \
353: } while (0)
354: #define M_LFPTOD(r_i, r_uf, d) /* l_fp to double */ \
355: do { \
356: register l_fp l_tmp; \
357: \
358: l_tmp.l_i = (r_i); \
359: l_tmp.l_f = (r_uf); \
360: if (l_tmp.l_i < 0) { \
361: M_NEG(l_tmp.l_i, l_tmp.l_uf); \
362: (d) = -((double)l_tmp.l_i + ((double)l_tmp.l_uf) / FRAC); \
363: } else { \
364: (d) = (double)l_tmp.l_i + ((double)l_tmp.l_uf) / FRAC; \
365: } \
366: } while (0)
367: #define DTOLFP(d, v) M_DTOLFP((d), (v)->l_ui, (v)->l_uf)
368: #define LFPTOD(v, d) M_LFPTOD((v)->l_ui, (v)->l_uf, (d))
369:
370: /*
371: * Prototypes
372: */
373: #if 0
374: extern char * dofptoa (u_fp, int, short, int);
375: extern char * dolfptoa (u_long, u_long, int, short, int);
376: #endif
377:
378: extern int atolfp (const char *, l_fp *);
379: extern int buftvtots (const char *, l_fp *);
380: extern char * fptoa (s_fp, short);
381: extern char * fptoms (s_fp, short);
382: extern int hextolfp (const char *, l_fp *);
383: extern void gpstolfp (int, int, unsigned long, l_fp *);
384: extern int mstolfp (const char *, l_fp *);
385: extern char * prettydate (l_fp *);
386: extern char * gmprettydate (l_fp *);
387: extern char * uglydate (l_fp *);
388: extern void mfp_mul (int32 *, u_int32 *, int32, u_int32, int32, u_int32);
389:
390: extern void get_systime (l_fp *);
391: extern int step_systime (double);
392: extern int adj_systime (double);
393:
394: #define lfptoa(_fpv, _ndec) mfptoa((_fpv)->l_ui, (_fpv)->l_uf, (_ndec))
395: #define lfptoms(_fpv, _ndec) mfptoms((_fpv)->l_ui, (_fpv)->l_uf, (_ndec))
396:
397: #define ufptoa(_fpv, _ndec) dofptoa((_fpv), 0, (_ndec), 0)
398: #define ufptoms(_fpv, _ndec) dofptoa((_fpv), 0, (_ndec), 1)
399: #define ulfptoa(_fpv, _ndec) dolfptoa((_fpv)->l_ui, (_fpv)->l_uf, 0, (_ndec), 0)
400: #define ulfptoms(_fpv, _ndec) dolfptoa((_fpv)->l_ui, (_fpv)->l_uf, 0, (_ndec), 1)
401: #define umfptoa(_fpi, _fpf, _ndec) dolfptoa((_fpi), (_fpf), 0, (_ndec), 0)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to jitter.h 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