/contrib/ntp/util/jitter.h

https://bitbucket.org/freebsd/freebsd-head/ · C++ Header · 412 lines · 287 code · 40 blank · 85 comment · 76 complexity · ecdf8aa897516eac890f592e847f2b6b MD5 · raw file

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