diff options
Diffstat (limited to 'include/timespecops.h')
-rw-r--r-- | include/timespecops.h | 393 |
1 files changed, 393 insertions, 0 deletions
diff --git a/include/timespecops.h b/include/timespecops.h new file mode 100644 index 0000000..fa32e42 --- /dev/null +++ b/include/timespecops.h @@ -0,0 +1,393 @@ +/* + * timespecops.h -- calculations on 'struct timespec' values + * + * Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project. + * The contents of 'html/copyright.html' apply. + * + * Rationale + * --------- + * + * Doing basic arithmetic on a 'struct timespec' is not exceedingly + * hard, but it requires tedious and repetitive code to keep the result + * normalised. We consider a timespec normalised when the nanosecond + * fraction is in the interval [0 .. 10^9[ ; there are multiple value + * pairs of seconds and nanoseconds that denote the same time interval, + * but the normalised representation is unique. No two different + * intervals can have the same normalised representation. + * + * Another topic is the representation of negative time intervals. + * There's more than one way to this, since both the seconds and the + * nanoseconds of a timespec are signed values. IMHO, the easiest way is + * to use a complement representation where the nanoseconds are still + * normalised, no matter what the sign of the seconds value. This makes + * normalisation easier, since the sign of the integer part is + * irrelevant, and it removes several sign decision cases during the + * calculations. + * + * As long as no signed integer overflow can occur with the nanosecond + * part of the operands, all operations work as expected and produce a + * normalised result. + * + * The exception to this are functions fix a '_fast' suffix, which do no + * normalisation on input data and therefore expect the input data to be + * normalised. + * + * Input and output operands may overlap; all input is consumed before + * the output is written to. + */ +#ifndef TIMESPECOPS_H +#define TIMESPECOPS_H + +#include <sys/types.h> +#include <stdio.h> +#include <math.h> + +#include "ntp.h" +#include "timetoa.h" + + +/* nanoseconds per second */ +#define NANOSECONDS 1000000000 + +/* predicate: returns TRUE if the nanoseconds are in nominal range */ +#define timespec_isnormal(x) \ + ((x)->tv_nsec >= 0 && (x)->tv_nsec < NANOSECONDS) + +/* predicate: returns TRUE if the nanoseconds are out-of-bounds */ +#define timespec_isdenormal(x) (!timespec_isnormal(x)) + +/* conversion between l_fp fractions and nanoseconds */ +#ifdef HAVE_U_INT64 +# define FTOTVN(tsf) \ + ((int32) \ + (((u_int64)(tsf) * NANOSECONDS + 0x80000000) >> 32)) +# define TVNTOF(tvu) \ + ((u_int32) \ + ((((u_int64)(tvu) << 32) + NANOSECONDS / 2) / \ + NANOSECONDS)) +#else +# define NSECFRAC (FRAC / NANOSECONDS) +# define FTOTVN(tsf) \ + ((int32)((tsf) / NSECFRAC + 0.5)) +# define TVNTOF(tvu) \ + ((u_int32)((tvu) * NSECFRAC + 0.5)) +#endif + + + +/* make sure nanoseconds are in nominal range */ +static inline struct timespec +normalize_tspec( + struct timespec x + ) +{ +#if SIZEOF_LONG > 4 + long z; + + /* + * tv_nsec is of type 'long', and on a 64-bit machine using only + * loops becomes prohibitive once the upper 32 bits get + * involved. On the other hand, division by constant should be + * fast enough; so we do a division of the nanoseconds in that + * case. The floor adjustment step follows with the standard + * normalisation loops. And labs() is intentionally not used + * here: it has implementation-defined behaviour when applied + * to LONG_MIN. + */ + if (x.tv_nsec < -3l * NANOSECONDS || + x.tv_nsec > 3l * NANOSECONDS) { + z = x.tv_nsec / NANOSECONDS; + x.tv_nsec -= z * NANOSECONDS; + x.tv_sec += z; + } +#endif + /* since 10**9 is close to 2**32, we don't divide but do a + * normalisation in a loop; this takes 3 steps max, and should + * outperform a division even if the mul-by-inverse trick is + * employed. */ + if (x.tv_nsec < 0) + do { + x.tv_nsec += NANOSECONDS; + x.tv_sec--; + } while (x.tv_nsec < 0); + else if (x.tv_nsec >= NANOSECONDS) + do { + x.tv_nsec -= NANOSECONDS; + x.tv_sec++; + } while (x.tv_nsec >= NANOSECONDS); + + return x; +} + +/* x = a + b */ +static inline struct timespec +add_tspec( + struct timespec a, + struct timespec b + ) +{ + struct timespec x; + + x = a; + x.tv_sec += b.tv_sec; + x.tv_nsec += b.tv_nsec; + + return normalize_tspec(x); +} + +/* x = a + b, b is fraction only */ +static inline struct timespec +add_tspec_ns( + struct timespec a, + long b + ) +{ + struct timespec x; + + x = a; + x.tv_nsec += b; + + return normalize_tspec(x); +} + +/* x = a - b */ +static inline struct timespec +sub_tspec( + struct timespec a, + struct timespec b + ) +{ + struct timespec x; + + x = a; + x.tv_sec -= b.tv_sec; + x.tv_nsec -= b.tv_nsec; + + return normalize_tspec(x); +} + +/* x = a - b, b is fraction only */ +static inline struct timespec +sub_tspec_ns( + struct timespec a, + long b + ) +{ + struct timespec x; + + x = a; + x.tv_nsec -= b; + + return normalize_tspec(x); +} + +/* x = -a */ +static inline struct timespec +neg_tspec( + struct timespec a + ) +{ + struct timespec x; + + x.tv_sec = -a.tv_sec; + x.tv_nsec = -a.tv_nsec; + + return normalize_tspec(x); +} + +/* x = abs(a) */ +static inline struct timespec +abs_tspec( + struct timespec a + ) +{ + struct timespec c; + + c = normalize_tspec(a); + if (c.tv_sec < 0) { + if (c.tv_nsec != 0) { + c.tv_sec = -c.tv_sec - 1; + c.tv_nsec = NANOSECONDS - c.tv_nsec; + } else { + c.tv_sec = -c.tv_sec; + } + } + + return c; +} + +/* + * compare previously-normalised a and b + * return 1 / 0 / -1 if a < / == / > b + */ +static inline int +cmp_tspec( + struct timespec a, + struct timespec b + ) +{ + int r; + + r = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec); + if (0 == r) + r = (a.tv_nsec > b.tv_nsec) - + (a.tv_nsec < b.tv_nsec); + + return r; +} + +/* + * compare possibly-denormal a and b + * return 1 / 0 / -1 if a < / == / > b + */ +static inline int +cmp_tspec_denorm( + struct timespec a, + struct timespec b + ) +{ + return cmp_tspec(normalize_tspec(a), normalize_tspec(b)); +} + +/* + * test previously-normalised a + * return 1 / 0 / -1 if a < / == / > 0 + */ +static inline int +test_tspec( + struct timespec a + ) +{ + int r; + + r = (a.tv_sec > 0) - (a.tv_sec < 0); + if (r == 0) + r = (a.tv_nsec > 0); + + return r; +} + +/* + * test possibly-denormal a + * return 1 / 0 / -1 if a < / == / > 0 + */ +static inline int +test_tspec_denorm( + struct timespec a + ) +{ + return test_tspec(normalize_tspec(a)); +} + +/* return LIB buffer ptr to string rep */ +static inline const char * +tspectoa( + struct timespec x + ) +{ + return format_time_fraction(x.tv_sec, x.tv_nsec, 9); +} + +/* + * convert to l_fp type, relative and absolute + */ + +/* convert from timespec duration to l_fp duration */ +static inline l_fp +tspec_intv_to_lfp( + struct timespec x + ) +{ + struct timespec v; + l_fp y; + + v = normalize_tspec(x); + y.l_uf = TVNTOF(v.tv_nsec); + y.l_i = (int32)v.tv_sec; + + return y; +} + +/* x must be UN*X epoch, output will be in NTP epoch */ +static inline l_fp +tspec_stamp_to_lfp( + struct timespec x + ) +{ + l_fp y; + + y = tspec_intv_to_lfp(x); + y.l_ui += JAN_1970; + + return y; +} + +/* convert from l_fp type, relative signed/unsigned and absolute */ +static inline struct timespec +lfp_intv_to_tspec( + l_fp x + ) +{ + struct timespec out; + l_fp absx; + int neg; + + neg = L_ISNEG(&x); + absx = x; + if (neg) { + L_NEG(&absx); + } + out.tv_nsec = FTOTVN(absx.l_uf); + out.tv_sec = absx.l_i; + if (neg) { + out.tv_sec = -out.tv_sec; + out.tv_nsec = -out.tv_nsec; + out = normalize_tspec(out); + } + + return out; +} + +static inline struct timespec +lfp_uintv_to_tspec( + l_fp x + ) +{ + struct timespec out; + + out.tv_nsec = FTOTVN(x.l_uf); + out.tv_sec = x.l_ui; + + return out; +} + +/* + * absolute (timestamp) conversion. Input is time in NTP epoch, output + * is in UN*X epoch. The NTP time stamp will be expanded around the + * pivot time *p or the current time, if p is NULL. + */ +static inline struct timespec +lfp_stamp_to_tspec( + l_fp x, + const time_t * p + ) +{ + struct timespec out; + vint64 sec; + + sec = ntpcal_ntp_to_time(x.l_ui, p); + out.tv_nsec = FTOTVN(x.l_uf); + + /* copying a vint64 to a time_t needs some care... */ +#if SIZEOF_TIME_T <= 4 + out.tv_sec = (time_t)sec.d_s.lo; +#elif defined(HAVE_INT64) + out.tv_sec = (time_t)sec.q_s; +#else + out.tv_sec = ((time_t)sec.d_s.hi << 32) | sec.d_s.lo; +#endif + + return out; +} + +#endif /* TIMESPECOPS_H */ |