FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
time.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 /*
16  Copyright (c) 2001, 2002, 2003 Eliot Dresselhaus
17 
18  Permission is hereby granted, free of charge, to any person obtaining
19  a copy of this software and associated documentation files (the
20  "Software"), to deal in the Software without restriction, including
21  without limitation the rights to use, copy, modify, merge, publish,
22  distribute, sublicense, and/or sell copies of the Software, and to
23  permit persons to whom the Software is furnished to do so, subject to
24  the following conditions:
25 
26  The above copyright notice and this permission notice shall be
27  included in all copies or substantial portions of the Software.
28 
29  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
30  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
31  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
32  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
33  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
34  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
35  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
36 */
37 
38 #ifndef included_time_h
39 #define included_time_h
40 
41 #include <vppinfra/clib.h>
42 #include <vppinfra/format.h>
43 
44 typedef struct
45 {
46  /* Total run time in clock cycles
47  since clib_time_init call. */
49 
50  /* Last recorded time stamp. */
52 
53  /* CPU clock frequency. */
55 
56  /* 1 / cpu clock frequency: conversion factor
57  from clock cycles into seconds. */
59 
60  /* Time stamp of call to clib_time_init call. */
63 
65 
66  /* Same but for reference time (if present). */
68 
69  u32 log2_clocks_per_second, log2_clocks_per_frequency_verify;
70 
71  /* Damping constant */
73 
74 } clib_time_t;
75 
77 
78 /* Return CPU time stamp as 64bit number. */
79 #if defined(__x86_64__) || defined(i386)
82 {
83  u32 a, d;
84  asm volatile ("rdtsc":"=a" (a), "=d" (d));
85  return (u64) a + ((u64) d << (u64) 32);
86 }
87 
88 #elif defined (__powerpc64__)
89 
91 clib_cpu_time_now (void)
92 {
93  u64 t;
94  asm volatile ("mftb %0":"=r" (t));
95  return t;
96 }
97 
98 #elif defined (__SPU__)
99 
101 clib_cpu_time_now (void)
102 {
103 #ifdef _XLC
104  return spu_rdch (0x8);
105 #else
106  return 0 /* __builtin_si_rdch (0x8) FIXME */ ;
107 #endif
108 }
109 
110 #elif defined (__powerpc__)
111 
113 clib_cpu_time_now (void)
114 {
115  u32 hi1, hi2, lo;
116  asm volatile ("1:\n"
117  "mftbu %[hi1]\n"
118  "mftb %[lo]\n"
119  "mftbu %[hi2]\n"
120  "cmpw %[hi1],%[hi2]\n"
121  "bne 1b\n":[hi1] "=r" (hi1),[hi2] "=r" (hi2),[lo] "=r" (lo));
122  return (u64) lo + ((u64) hi2 << (u64) 32);
123 }
124 
125 #elif defined (__aarch64__)
127 clib_cpu_time_now (void)
128 {
129  u64 vct;
130  /* User access to cntvct_el0 is enabled in Linux kernel since 3.12. */
131  asm volatile ("mrs %0, cntvct_el0":"=r" (vct));
132  return vct;
133 }
134 
135 #elif defined (__arm__)
136 #if defined(__ARM_ARCH_8A__)
138 clib_cpu_time_now (void) /* We may run arm64 in aarch32 mode, to leverage 64bit counter */
139 {
140  u64 tsc;
141  asm volatile ("mrrc p15, 0, %Q0, %R0, c9":"=r" (tsc));
142  return tsc;
143 }
144 #elif defined(__ARM_ARCH_7A__)
146 clib_cpu_time_now (void)
147 {
148  u32 tsc;
149  asm volatile ("mrc p15, 0, %0, c9, c13, 0":"=r" (tsc));
150  return (u64) tsc;
151 }
152 #else
154 clib_cpu_time_now (void)
155 {
156  u32 lo;
157  asm volatile ("mrc p15, 0, %[lo], c15, c12, 1":[lo] "=r" (lo));
158  return (u64) lo;
159 }
160 #endif
161 
162 #elif defined (__xtensa__)
163 
164 /* Stub for now. */
166 clib_cpu_time_now (void)
167 {
168  return 0;
169 }
170 
171 #elif defined (__TMS320C6X__)
172 
174 clib_cpu_time_now (void)
175 {
176  u32 l, h;
177 
178  asm volatile (" dint\n"
179  " mvc .s2 TSCL,%0\n"
180  " mvc .s2 TSCH,%1\n" " rint\n":"=b" (l), "=b" (h));
181 
182  return ((u64) h << 32) | l;
183 }
184 
185 #elif defined(_mips) && __mips == 64
186 
188 clib_cpu_time_now (void)
189 {
190  u64 result;
191  asm volatile ("rdhwr %0,$31\n":"=r" (result));
192  return result;
193 }
194 
195 #else
196 #error "don't know how to read CPU time stamp"
197 
198 #endif
199 
201 
202 /* Define it as the type returned by clib_time_now */
205 
206 #define CLIB_US_TIME_PERIOD (1e-6)
207 #define CLIB_US_TIME_FREQ (1.0/CLIB_US_TIME_PERIOD)
208 
211 {
212  u64 l = c->last_cpu_time;
213  u64 t = c->total_cpu_time;
214  f64 rv;
215  t += n - l;
216  c->total_cpu_time = t;
217  c->last_cpu_time = n;
218  rv = t * c->seconds_per_clock;
219  if (PREDICT_FALSE
220  ((c->last_cpu_time -
223  return rv;
224 }
225 
226 /* Maximum f64 value as max clib_time */
227 #define CLIB_TIME_MAX (1.7976931348623157e+308)
228 
231 {
233 }
234 
235 always_inline void
237 {
238  u64 t_end = clib_cpu_time_now () + dt;
239  while (clib_cpu_time_now () < t_end)
240  ;
241 }
242 
243 void clib_time_init (clib_time_t * c);
244 
245 #ifdef CLIB_UNIX
246 
247 #include <time.h>
248 #include <sys/time.h>
249 #include <sys/resource.h>
250 #include <unistd.h>
251 #include <sys/syscall.h>
252 
253 /* Use 64bit floating point to represent time offset from epoch. */
256 {
257  struct timespec ts;
258 #ifdef __MACH__
259  clock_gettime (CLOCK_REALTIME, &ts);
260 #else
261  /* clock_gettime without indirect syscall uses GLIBC wrappers which
262  we don't want. Just the bare metal, please. */
263  syscall (SYS_clock_gettime, CLOCK_REALTIME, &ts);
264 #endif
265  return ts.tv_sec + 1e-9 * ts.tv_nsec;
266 }
267 
268 /* As above but integer number of nano-seconds. */
271 {
272  struct timespec ts;
273 #ifdef __MACH__
274  clock_gettime (CLOCK_REALTIME, &ts);
275 #else
276  syscall (SYS_clock_gettime, CLOCK_REALTIME, &ts);
277 #endif
278  return 1e9 * ts.tv_sec + ts.tv_nsec;
279 }
280 
281 always_inline void
283 {
284  struct timespec ts;
285 #ifdef __MACH__
286  clock_gettime (CLOCK_REALTIME, &ts);
287 #else
288  syscall (SYS_clock_gettime, CLOCK_REALTIME, &ts);
289 #endif
290  *sec = ts.tv_sec;
291  *nsec = ts.tv_nsec;
292 }
293 
296 {
297  struct rusage u;
298  getrusage (RUSAGE_SELF, &u);
299  return u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec
300  + u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
301 }
302 
303 always_inline void
305 {
306  struct timespec ts, tsrem;
307  ts.tv_sec = dt;
308  ts.tv_nsec = 1e9 * (dt - (f64) ts.tv_sec);
309 
310  while (nanosleep (&ts, &tsrem) < 0)
311  ts = tsrem;
312 }
313 
314 #else /* ! CLIB_UNIX */
315 
317 unix_time_now (void)
318 {
319  return 0;
320 }
321 
323 unix_time_now_nsec (void)
324 {
325  return 0;
326 }
327 
328 always_inline void
329 unix_time_now_nsec_fraction (u32 * sec, u32 * nsec)
330 {
331 }
332 
334 unix_usage_now (void)
335 {
336  return 0;
337 }
338 
339 always_inline void
340 unix_sleep (f64 dt)
341 {
342 }
343 
344 #endif
345 
346 #endif /* included_time_h */
347 
348 /*
349  * fd.io coding-style-patch-verification: ON
350  *
351  * Local Variables:
352  * eval: (c-set-style "gnu")
353  * End:
354  */
f64 clib_time_type_t
Definition: time.h:203
a
Definition: bitmap.h:538
static void clib_cpu_time_wait(u64 dt)
Definition: time.h:236
unsigned long u64
Definition: types.h:89
void clib_time_verify_frequency(clib_time_t *c)
Definition: time.c:251
f64 clocks_per_second
Definition: time.h:54
format_function_t format_clib_time
Definition: time.h:76
static f64 clib_time_now(clib_time_t *c)
Definition: time.h:230
static u64 clib_cpu_time_now(void)
Definition: time.h:81
u32 log2_clocks_per_second
Definition: time.h:69
u64 last_verify_cpu_time
Definition: time.h:64
double f64
Definition: types.h:142
u8 *() format_function_t(u8 *s, va_list *args)
Definition: format.h:48
static void unix_sleep(f64 dt)
Definition: time.h:304
static f64 unix_time_now(void)
Definition: time.h:255
unsigned int u32
Definition: types.h:88
static void unix_time_now_nsec_fraction(u32 *sec, u32 *nsec)
Definition: time.h:282
lo
u32 log2_clocks_per_frequency_verify
Definition: time.h:69
vec_header_t h
Definition: buffer.c:322
#define PREDICT_FALSE(x)
Definition: clib.h:120
#define always_inline
Definition: ipsec.h:28
f64 seconds_per_clock
Definition: time.h:58
u64 total_cpu_time
Definition: time.h:48
f64 damping_constant
Definition: time.h:72
static u64 unix_time_now_nsec(void)
Definition: time.h:270
static f64 unix_usage_now(void)
Definition: time.h:295
u64 last_cpu_time
Definition: time.h:51
f64 init_reference_time
Definition: time.h:62
f64 last_verify_reference_time
Definition: time.h:67
static f64 clib_time_now_internal(clib_time_t *c, u64 n)
Definition: time.h:210
u64 init_cpu_time
Definition: time.h:61
#define SYS_clock_gettime
void clib_time_init(clib_time_t *c)
Definition: time.c:207
u64 clib_us_time_t
Definition: time.h:204