contrib/ntp/libntp/timespecops.c

   1 /*
   2  * timespecops.c -- calculations on 'struct timespec' values
   3  *
   4  * Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
   5  * The contents of 'html/copyright.html' apply.
   6  *
   7  */
   8
   9 #include "config.h"
  10
  11 #include <sys/types.h>
  12 #include <stdio.h>
  13 #include <math.h>
  14
  15 #include "ntp.h"
  16 #include "timetoa.h"
  17 #include "timespecops.h"
  18
  19
  20 /* nanoseconds per second */
  21 #define NANOSECONDS 1000000000
  22
  23 /* conversion between l_fp fractions and nanoseconds */
  24 #ifdef HAVE_U_INT64
  25 # define FTOTVN(tsf)                                            \
  26         ((int32)                                                \
  27          (((u_int64)(tsf) * NANOSECONDS + 0x80000000) >> 32))
  28 # define TVNTOF(tvu)                                            \
  29         ((u_int32)                                              \
  30          ((((u_int64)(tvu) << 32) + NANOSECONDS / 2) /          \
  31           NANOSECONDS))
  32 #else
  33 # define NSECFRAC       (FRAC / NANOSECONDS)
  34 # define FTOTVN(tsf)                                            \
  35         ((int32)((tsf) / NSECFRAC + 0.5))
  36 # define TVNTOF(tvu)                                            \
  37         ((u_int32)((tvu) * NSECFRAC + 0.5))
  38 #endif
  39
  40
  41
  42 /* make sure nanoseconds are in nominal range */
  43 struct timespec
  44 normalize_tspec(
  45         struct timespec x
  46         )
  47 {
  48 #if SIZEOF_LONG > 4
  49         long    z;
  50
  51         /*
  52          * tv_nsec is of type 'long', and on a 64-bit machine using only
  53          * loops becomes prohibitive once the upper 32 bits get
  54          * involved. On the other hand, division by constant should be
  55          * fast enough; so we do a division of the nanoseconds in that
  56          * case. The floor adjustment step follows with the standard
  57          * normalisation loops. And labs() is intentionally not used
  58          * here: it has implementation-defined behaviour when applied
  59          * to LONG_MIN.
  60          */
  61         if (x.tv_nsec < -3l * NANOSECONDS ||
  62             x.tv_nsec > 3l * NANOSECONDS) {
  63                 z = x.tv_nsec / NANOSECONDS;
  64                 x.tv_nsec -= z * NANOSECONDS;
  65                 x.tv_sec += z;
  66         }
  67 #endif
  68         /* since 10**9 is close to 2**32, we don't divide but do a
  69          * normalisation in a loop; this takes 3 steps max, and should
  70          * outperform a division even if the mul-by-inverse trick is
  71          * employed. */
  72         if (x.tv_nsec < 0)
  73                 do {
  74                         x.tv_nsec += NANOSECONDS;
  75                         x.tv_sec--;
  76                 } while (x.tv_nsec < 0);
  77         else if (x.tv_nsec >= NANOSECONDS)
  78                 do {
  79                         x.tv_nsec -= NANOSECONDS;
  80                         x.tv_sec++;
  81                 } while (x.tv_nsec >= NANOSECONDS);
  82
  83         return x;
  84 }
  85
  86 /* x = abs(a) */
  87 struct timespec
  88 abs_tspec(
  89         struct timespec a
  90         )
  91 {
  92         struct timespec c;
  93
  94         c = normalize_tspec(a);
  95         if (c.tv_sec < 0) {
  96                 if (c.tv_nsec != 0) {
  97                         c.tv_sec = -c.tv_sec - 1;
  98                         c.tv_nsec = NANOSECONDS - c.tv_nsec;
  99                 } else {
 100                         c.tv_sec = -c.tv_sec;
 101                 }
 102         }
 103
 104         return c;
 105 }
 106
 107 /*
 108  * compare previously-normalised a and b
 109  * return 1 / 0 / -1 if a < / == / > b
 110  */
 111 int
 112 cmp_tspec(
 113         struct timespec a,
 114         struct timespec b
 115         )
 116 {
 117         int r;
 118
 119         r = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
 120         if (0 == r)
 121                 r = (a.tv_nsec > b.tv_nsec) -
 122                     (a.tv_nsec < b.tv_nsec);
 123
 124         return r;
 125 }
 126
 127 /*
 128  * test previously-normalised a
 129  * return 1 / 0 / -1 if a < / == / > 0
 130  */
 131 int
 132 test_tspec(
 133         struct timespec a
 134         )
 135 {
 136         int             r;
 137
 138         r = (a.tv_sec > 0) - (a.tv_sec < 0);
 139         if (r == 0)
 140                 r = (a.tv_nsec > 0);
 141
 142         return r;
 143 }
 144
 145 /*
 146  *  convert to l_fp type, relative and absolute
 147  */
 148
 149 /* convert from timespec duration to l_fp duration */
 150 l_fp
 151 tspec_intv_to_lfp(
 152         struct timespec x
 153         )
 154 {
 155         struct timespec v;
 156         l_fp            y;
 157
 158         v = normalize_tspec(x);
 159         y.l_uf = TVNTOF(v.tv_nsec);
 160         y.l_i = (int32)v.tv_sec;
 161
 162         return y;
 163 }
 164
 165 /* convert from l_fp type, relative signed/unsigned and absolute */
 166 struct timespec
 167 lfp_intv_to_tspec(
 168         l_fp            x
 169         )
 170 {
 171         struct timespec out;
 172         l_fp            absx;
 173         int             neg;
 174
 175         neg = L_ISNEG(&x);
 176         absx = x;
 177         if (neg) {
 178                 L_NEG(&absx);
 179         }
 180         out.tv_nsec = FTOTVN(absx.l_uf);
 181         out.tv_sec = absx.l_i;
 182         if (neg) {
 183                 out.tv_sec = -out.tv_sec;
 184                 out.tv_nsec = -out.tv_nsec;
 185                 out = normalize_tspec(out);
 186         }
 187
 188         return out;
 189 }
 190
 191 struct timespec
 192 lfp_uintv_to_tspec(
 193         l_fp            x
 194         )
 195 {
 196         struct timespec out;
 197
 198         out.tv_nsec = FTOTVN(x.l_uf);
 199         out.tv_sec = x.l_ui;
 200
 201         return out;
 202 }
 203
 204 /*
 205  * absolute (timestamp) conversion. Input is time in NTP epoch, output
 206  * is in UN*X epoch. The NTP time stamp will be expanded around the
 207  * pivot time *p or the current time, if p is NULL.
 208  */
 209 struct timespec
 210 lfp_stamp_to_tspec(
 211         l_fp            x,
 212         const time_t *  p
 213         )
 214 {
 215         struct timespec out;
 216         vint64          sec;
 217
 218         sec = ntpcal_ntp_to_time(x.l_ui, p);
 219         out.tv_nsec = FTOTVN(x.l_uf);
 220
 221         /* copying a vint64 to a time_t needs some care... */
 222 #if SIZEOF_TIME_T <= 4
 223         out.tv_sec = (time_t)sec.d_s.lo;
 224 #elif defined(HAVE_INT64)
 225         out.tv_sec = (time_t)sec.q_s;
 226 #else
 227         out.tv_sec = ((time_t)sec.d_s.hi << 32) | sec.d_s.lo;
 228 #endif
 229
 230         return out;
 231 }
 232
 233 /* -*-EOF-*- */