external/bsd/ntp/dist/util/jitter.h

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