447 lines
8.3 KiB
C
447 lines
8.3 KiB
C
/*
|
|
* timevalops.h -- calculations on 'struct timeval' values
|
|
*
|
|
* Written by Juergen Perlinger (perlinger@ntp.org) for the NTP project.
|
|
* The contents of 'html/copyright.html' apply.
|
|
*
|
|
* For a rationale look at 'timespecops.h'; we do the same here, but the
|
|
* normalisation keeps the microseconds in [0 .. 10^6[, of course.
|
|
*/
|
|
#ifndef TIMEVALOPS_H
|
|
#define TIMEVALOPS_H
|
|
|
|
#include <sys/types.h>
|
|
#include <stdio.h>
|
|
|
|
#include "ntp.h"
|
|
#include "timetoa.h"
|
|
|
|
|
|
/* microseconds per second */
|
|
#define MICROSECONDS 1000000
|
|
|
|
#ifndef HAVE_U_INT64
|
|
# define USE_TSF_USEC_TABLES
|
|
#endif
|
|
|
|
/*
|
|
* Convert usec to a time stamp fraction.
|
|
*/
|
|
#ifdef USE_TSF_USEC_TABLES
|
|
extern const u_int32 ustotslo[];
|
|
extern const u_int32 ustotsmid[];
|
|
extern const u_int32 ustotshi[];
|
|
|
|
# define TVUTOTSF(tvu, tsf) \
|
|
((tsf) = ustotslo[(tvu) & 0xff] \
|
|
+ ustotsmid[((tvu) >> 8) & 0xff] \
|
|
+ ustotshi[((tvu) >> 16) & 0xf])
|
|
#else
|
|
# define TVUTOTSF(tvu, tsf) \
|
|
((tsf) = (u_int32) \
|
|
((((u_int64)(tvu) << 32) + MICROSECONDS / 2) / \
|
|
MICROSECONDS))
|
|
#endif
|
|
|
|
/*
|
|
* Convert a time stamp fraction to microseconds. The time stamp
|
|
* fraction is assumed to be unsigned.
|
|
*/
|
|
#ifdef USE_TSF_USEC_TABLES
|
|
extern const u_int32 tstouslo[256];
|
|
extern const u_int32 tstousmid[256];
|
|
extern const u_int32 tstoushi[128];
|
|
|
|
/*
|
|
* TV_SHIFT is used to turn the table result into a usec value. To
|
|
* round, add in TV_ROUNDBIT before shifting.
|
|
*/
|
|
#define TV_SHIFT 3
|
|
#define TV_ROUNDBIT 0x4
|
|
|
|
# define TSFTOTVU(tsf, tvu) \
|
|
((tvu) = (tstoushi[((tsf) >> 24) & 0xff] \
|
|
+ tstousmid[((tsf) >> 16) & 0xff] \
|
|
+ tstouslo[((tsf) >> 9) & 0x7f] \
|
|
+ TV_ROUNDBIT) >> TV_SHIFT)
|
|
#else
|
|
# define TSFTOTVU(tsf, tvu) \
|
|
((tvu) = (int32) \
|
|
(((u_int64)(tsf) * MICROSECONDS + 0x80000000) >> 32))
|
|
#endif
|
|
|
|
/*
|
|
* Convert a struct timeval to a time stamp.
|
|
*/
|
|
#define TVTOTS(tv, ts) \
|
|
do { \
|
|
(ts)->l_ui = (u_long)(tv)->tv_sec; \
|
|
TVUTOTSF((tv)->tv_usec, (ts)->l_uf); \
|
|
} while (FALSE)
|
|
|
|
#define sTVTOTS(tv, ts) \
|
|
do { \
|
|
int isneg = 0; \
|
|
long usec; \
|
|
(ts)->l_ui = (tv)->tv_sec; \
|
|
usec = (tv)->tv_usec; \
|
|
if (((tv)->tv_sec < 0) || ((tv)->tv_usec < 0)) { \
|
|
usec = -usec; \
|
|
(ts)->l_ui = -(ts)->l_ui; \
|
|
isneg = 1; \
|
|
} \
|
|
TVUTOTSF(usec, (ts)->l_uf); \
|
|
if (isneg) { \
|
|
L_NEG((ts)); \
|
|
} \
|
|
} while (FALSE)
|
|
|
|
/*
|
|
* Convert a time stamp to a struct timeval. The time stamp
|
|
* has to be positive.
|
|
*/
|
|
#define TSTOTV(ts, tv) \
|
|
do { \
|
|
(tv)->tv_sec = (ts)->l_ui; \
|
|
TSFTOTVU((ts)->l_uf, (tv)->tv_usec); \
|
|
if ((tv)->tv_usec == 1000000) { \
|
|
(tv)->tv_sec++; \
|
|
(tv)->tv_usec = 0; \
|
|
} \
|
|
} while (FALSE)
|
|
|
|
|
|
/*
|
|
* predicate: returns TRUE if the microseconds are in nominal range
|
|
* use like: int timeval_isnormal(const struct timeval *x)
|
|
*/
|
|
#define timeval_isnormal(x) \
|
|
((x)->tv_usec >= 0 && (x)->tv_usec < MICROSECONDS)
|
|
|
|
/*
|
|
* Convert milliseconds to a time stamp fraction. Unused except for
|
|
* refclock_leitch.c, so accompanying lookup tables were removed in
|
|
* favor of reusing the microseconds conversion tables.
|
|
*/
|
|
#define MSUTOTSF(msu, tsf) TVUTOTSF((msu) * 1000, tsf)
|
|
|
|
/*
|
|
* predicate: returns TRUE if the microseconds are out-of-bounds
|
|
* use like: int timeval_isdenormal(const struct timeval *x)
|
|
*/
|
|
#define timeval_isdenormal(x) (!timeval_isnormal(x))
|
|
|
|
/* make sure microseconds are in nominal range */
|
|
static inline struct timeval
|
|
normalize_tval(
|
|
struct timeval x
|
|
)
|
|
{
|
|
long z;
|
|
|
|
/*
|
|
* If the fraction becomes excessive denormal, we use division
|
|
* to do first partial normalisation. The normalisation loops
|
|
* following will do the remaining cleanup. Since the size of
|
|
* tv_usec has a peculiar definition by the standard the range
|
|
* check is coded manually. And labs() is intentionally not used
|
|
* here: it has implementation-defined behaviour when applied
|
|
* to LONG_MIN.
|
|
*/
|
|
if (x.tv_usec < -3l * MICROSECONDS ||
|
|
x.tv_usec > 3l * MICROSECONDS ) {
|
|
z = x.tv_usec / MICROSECONDS;
|
|
x.tv_usec -= z * MICROSECONDS;
|
|
x.tv_sec += z;
|
|
}
|
|
|
|
/*
|
|
* Do any remaining normalisation steps in loops. This takes 3
|
|
* steps max, and should outperform a division even if the
|
|
* mul-by-inverse trick is employed. (It also does the floor
|
|
* division adjustment if the above division was executed.)
|
|
*/
|
|
if (x.tv_usec < 0)
|
|
do {
|
|
x.tv_usec += MICROSECONDS;
|
|
x.tv_sec--;
|
|
} while (x.tv_usec < 0);
|
|
else if (x.tv_usec >= MICROSECONDS)
|
|
do {
|
|
x.tv_usec -= MICROSECONDS;
|
|
x.tv_sec++;
|
|
} while (x.tv_usec >= MICROSECONDS);
|
|
|
|
return x;
|
|
}
|
|
|
|
/* x = a + b */
|
|
static inline struct timeval
|
|
add_tval(
|
|
struct timeval a,
|
|
struct timeval b
|
|
)
|
|
{
|
|
struct timeval x;
|
|
|
|
x = a;
|
|
x.tv_sec += b.tv_sec;
|
|
x.tv_usec += b.tv_usec;
|
|
|
|
return normalize_tval(x);
|
|
}
|
|
|
|
/* x = a + b, b is fraction only */
|
|
static inline struct timeval
|
|
add_tval_us(
|
|
struct timeval a,
|
|
long b
|
|
)
|
|
{
|
|
struct timeval x;
|
|
|
|
x = a;
|
|
x.tv_usec += b;
|
|
|
|
return normalize_tval(x);
|
|
}
|
|
|
|
/* x = a - b */
|
|
static inline struct timeval
|
|
sub_tval(
|
|
struct timeval a,
|
|
struct timeval b
|
|
)
|
|
{
|
|
struct timeval x;
|
|
|
|
x = a;
|
|
x.tv_sec -= b.tv_sec;
|
|
x.tv_usec -= b.tv_usec;
|
|
|
|
return normalize_tval(x);
|
|
}
|
|
|
|
/* x = a - b, b is fraction only */
|
|
static inline struct timeval
|
|
sub_tval_us(
|
|
struct timeval a,
|
|
long b
|
|
)
|
|
{
|
|
struct timeval x;
|
|
|
|
x = a;
|
|
x.tv_usec -= b;
|
|
|
|
return normalize_tval(x);
|
|
}
|
|
|
|
/* x = -a */
|
|
static inline struct timeval
|
|
neg_tval(
|
|
struct timeval a
|
|
)
|
|
{
|
|
struct timeval x;
|
|
|
|
x.tv_sec = -a.tv_sec;
|
|
x.tv_usec = -a.tv_usec;
|
|
|
|
return normalize_tval(x);
|
|
}
|
|
|
|
/* x = abs(a) */
|
|
static inline struct timeval
|
|
abs_tval(
|
|
struct timeval a
|
|
)
|
|
{
|
|
struct timeval c;
|
|
|
|
c = normalize_tval(a);
|
|
if (c.tv_sec < 0) {
|
|
if (c.tv_usec != 0) {
|
|
c.tv_sec = -c.tv_sec - 1;
|
|
c.tv_usec = MICROSECONDS - c.tv_usec;
|
|
} 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_tval(
|
|
struct timeval a,
|
|
struct timeval b
|
|
)
|
|
{
|
|
int r;
|
|
|
|
r = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
|
|
if (0 == r)
|
|
r = (a.tv_usec > b.tv_usec) -
|
|
(a.tv_usec < b.tv_usec);
|
|
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* compare possibly-denormal a and b
|
|
* return 1 / 0 / -1 if a < / == / > b
|
|
*/
|
|
static inline int
|
|
cmp_tval_denorm(
|
|
struct timeval a,
|
|
struct timeval b
|
|
)
|
|
{
|
|
return cmp_tval(normalize_tval(a), normalize_tval(b));
|
|
}
|
|
|
|
/*
|
|
* test previously-normalised a
|
|
* return 1 / 0 / -1 if a < / == / > 0
|
|
*/
|
|
static inline int
|
|
test_tval(
|
|
struct timeval a
|
|
)
|
|
{
|
|
int r;
|
|
|
|
r = (a.tv_sec > 0) - (a.tv_sec < 0);
|
|
if (r == 0)
|
|
r = (a.tv_usec > 0);
|
|
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* test possibly-denormal a
|
|
* return 1 / 0 / -1 if a < / == / > 0
|
|
*/
|
|
static inline int
|
|
test_tval_denorm(
|
|
struct timeval a
|
|
)
|
|
{
|
|
return test_tval(normalize_tval(a));
|
|
}
|
|
|
|
/* return LIB buffer ptr to string rep */
|
|
static inline const char *
|
|
tvaltoa(
|
|
struct timeval x
|
|
)
|
|
{
|
|
return format_time_fraction(x.tv_sec, x.tv_usec, 6);
|
|
}
|
|
|
|
/* convert from timeval duration to l_fp duration */
|
|
static inline l_fp
|
|
tval_intv_to_lfp(
|
|
struct timeval x
|
|
)
|
|
{
|
|
struct timeval v;
|
|
l_fp y;
|
|
|
|
v = normalize_tval(x);
|
|
TVUTOTSF(v.tv_usec, y.l_uf);
|
|
y.l_i = (int32)v.tv_sec;
|
|
|
|
return y;
|
|
}
|
|
|
|
/* x must be UN*X epoch, output *y will be in NTP epoch */
|
|
static inline l_fp
|
|
tval_stamp_to_lfp(
|
|
struct timeval x
|
|
)
|
|
{
|
|
l_fp y;
|
|
|
|
y = tval_intv_to_lfp(x);
|
|
y.l_ui += JAN_1970;
|
|
|
|
return y;
|
|
}
|
|
|
|
/* convert to l_fp type, relative signed/unsigned and absolute */
|
|
static inline struct timeval
|
|
lfp_intv_to_tval(
|
|
l_fp x
|
|
)
|
|
{
|
|
struct timeval out;
|
|
l_fp absx;
|
|
int neg;
|
|
|
|
neg = L_ISNEG(&x);
|
|
absx = x;
|
|
if (neg) {
|
|
L_NEG(&absx);
|
|
}
|
|
TSFTOTVU(absx.l_uf, out.tv_usec);
|
|
out.tv_sec = absx.l_i;
|
|
if (neg) {
|
|
out.tv_sec = -out.tv_sec;
|
|
out.tv_usec = -out.tv_usec;
|
|
out = normalize_tval(out);
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
static inline struct timeval
|
|
lfp_uintv_to_tval(
|
|
l_fp x
|
|
)
|
|
{
|
|
struct timeval out;
|
|
|
|
TSFTOTVU(x.l_uf, out.tv_usec);
|
|
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 timeval
|
|
lfp_stamp_to_tval(
|
|
l_fp x,
|
|
const time_t * p
|
|
)
|
|
{
|
|
struct timeval out;
|
|
vint64 sec;
|
|
|
|
sec = ntpcal_ntp_to_time(x.l_ui, p);
|
|
TSFTOTVU(x.l_uf, out.tv_usec);
|
|
|
|
/* 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
|
|
out = normalize_tval(out);
|
|
|
|
return out;
|
|
}
|
|
|
|
#endif /* TIMEVALOPS_H */
|