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
normalize_tspec(struct timespec x)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
abs_tspec(struct timespec a)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
cmp_tspec(struct timespec a,struct timespec b)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
test_tspec(struct timespec a)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
tspec_intv_to_lfp(struct timespec x)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
lfp_intv_to_tspec(l_fp x)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
lfp_uintv_to_tspec(l_fp x)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
lfp_stamp_to_tspec(l_fp x,const time_t * p)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-*- */
234