FD.io VPP  v18.01-8-g0eacf49
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 
43 typedef struct
44 {
45  /* Total run time in clock cycles
46  since clib_time_init call. */
48 
49  /* Last recorded time stamp. */
51 
52  /* CPU clock frequency. */
54 
55  /* 1 / cpu clock frequency: conversion factor
56  from clock cycles into seconds. */
58 
59  /* Time stamp of call to clib_time_init call. */
61 
63 
64  /* Same but for reference time (if present). */
66 
67  u32 log2_clocks_per_second, log2_clocks_per_frequency_verify;
68 } clib_time_t;
69 
70 /* Return CPU time stamp as 64bit number. */
71 #if defined(__x86_64__) || defined(i386)
74 {
75  u32 a, d;
76  asm volatile ("rdtsc":"=a" (a), "=d" (d));
77  return (u64) a + ((u64) d << (u64) 32);
78 }
79 
80 #elif defined (__powerpc64__)
81 
83 clib_cpu_time_now (void)
84 {
85  u64 t;
86  asm volatile ("mftb %0":"=r" (t));
87  return t;
88 }
89 
90 #elif defined (__SPU__)
91 
93 clib_cpu_time_now (void)
94 {
95 #ifdef _XLC
96  return spu_rdch (0x8);
97 #else
98  return 0 /* __builtin_si_rdch (0x8) FIXME */ ;
99 #endif
100 }
101 
102 #elif defined (__powerpc__)
103 
105 clib_cpu_time_now (void)
106 {
107  u32 hi1, hi2, lo;
108  asm volatile ("1:\n"
109  "mftbu %[hi1]\n"
110  "mftb %[lo]\n"
111  "mftbu %[hi2]\n"
112  "cmpw %[hi1],%[hi2]\n"
113  "bne 1b\n":[hi1] "=r" (hi1),[hi2] "=r" (hi2),[lo] "=r" (lo));
114  return (u64) lo + ((u64) hi2 << (u64) 32);
115 }
116 
117 #elif defined (__arm__)
118 #if defined(__ARM_ARCH_8A__)
120 clib_cpu_time_now (void) /* We may run arm64 in aarch32 mode, to leverage 64bit counter */
121 {
122  u64 tsc;
123  asm volatile ("mrrc p15, 0, %Q0, %R0, c9":"=r" (tsc));
124  return tsc;
125 }
126 #elif defined(__ARM_ARCH_7A__)
128 clib_cpu_time_now (void)
129 {
130  u32 tsc;
131  asm volatile ("mrc p15, 0, %0, c9, c13, 0":"=r" (tsc));
132  return (u64) tsc;
133 }
134 #else
136 clib_cpu_time_now (void)
137 {
138  u32 lo;
139  asm volatile ("mrc p15, 0, %[lo], c15, c12, 1":[lo] "=r" (lo));
140  return (u64) lo;
141 }
142 #endif
143 
144 #elif defined (__xtensa__)
145 
146 /* Stub for now. */
148 clib_cpu_time_now (void)
149 {
150  return 0;
151 }
152 
153 #elif defined (__TMS320C6X__)
154 
156 clib_cpu_time_now (void)
157 {
158  u32 l, h;
159 
160  asm volatile (" dint\n"
161  " mvc .s2 TSCL,%0\n"
162  " mvc .s2 TSCH,%1\n" " rint\n":"=b" (l), "=b" (h));
163 
164  return ((u64) h << 32) | l;
165 }
166 
167 #elif defined (__aarch64__)
169 clib_cpu_time_now (void)
170 {
171  u64 tsc;
172 
173  /* Works on Cavium ThunderX. Other platforms: YMMV */
174  asm volatile ("mrs %0, cntvct_el0":"=r" (tsc));
175 
176  return tsc;
177 }
178 
179 #else
180 #error "don't know how to read CPU time stamp"
181 
182 #endif
183 
185 
188 {
189  u64 l = c->last_cpu_time;
190  u64 t = c->total_cpu_time;
191  t += n - l;
192  c->total_cpu_time = t;
193  c->last_cpu_time = n;
194  if (PREDICT_FALSE
195  ((c->last_cpu_time -
198  return t * c->seconds_per_clock;
199 }
200 
203 {
205 }
206 
207 always_inline void
209 {
210  u64 t_end = clib_cpu_time_now () + dt;
211  while (clib_cpu_time_now () < t_end)
212  ;
213 }
214 
215 void clib_time_init (clib_time_t * c);
216 
217 #ifdef CLIB_UNIX
218 
219 #include <time.h>
220 #include <sys/time.h>
221 #include <sys/resource.h>
222 #include <unistd.h>
223 #include <sys/syscall.h>
224 
225 /* Use 64bit floating point to represent time offset from epoch. */
228 {
229  /* clock_gettime without indirect syscall uses GLIBC wrappers which
230  we don't want. Just the bare metal, please. */
231  struct timespec ts;
232  syscall (SYS_clock_gettime, CLOCK_REALTIME, &ts);
233  return ts.tv_sec + 1e-9 * ts.tv_nsec;
234 }
235 
236 /* As above but integer number of nano-seconds. */
239 {
240  struct timespec ts;
241  syscall (SYS_clock_gettime, CLOCK_REALTIME, &ts);
242  return 1e9 * ts.tv_sec + ts.tv_nsec;
243 }
244 
245 always_inline void
247 {
248  struct timespec ts;
249  syscall (SYS_clock_gettime, CLOCK_REALTIME, &ts);
250  *sec = ts.tv_sec;
251  *nsec = ts.tv_nsec;
252 }
253 
256 {
257  struct rusage u;
258  getrusage (RUSAGE_SELF, &u);
259  return u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec
260  + u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
261 }
262 
263 always_inline void
265 {
266  struct timespec ts, tsrem;
267  ts.tv_sec = dt;
268  ts.tv_nsec = 1e9 * (dt - (f64) ts.tv_sec);
269 
270  while (nanosleep (&ts, &tsrem) < 0)
271  ts = tsrem;
272 }
273 
274 #else /* ! CLIB_UNIX */
275 
277 unix_time_now (void)
278 {
279  return 0;
280 }
281 
283 unix_time_now_nsec (void)
284 {
285  return 0;
286 }
287 
288 always_inline void
289 unix_time_now_nsec_fraction (u32 * sec, u32 * nsec)
290 {
291 }
292 
294 unix_usage_now (void)
295 {
296  return 0;
297 }
298 
299 always_inline void
300 unix_sleep (f64 dt)
301 {
302 }
303 
304 #endif
305 
306 #endif /* included_time_h */
307 
308 /*
309  * fd.io coding-style-patch-verification: ON
310  *
311  * Local Variables:
312  * eval: (c-set-style "gnu")
313  * End:
314  */
a
Definition: bitmap.h:516
static void clib_cpu_time_wait(u64 dt)
Definition: time.h:208
void clib_time_verify_frequency(clib_time_t *c)
Definition: time.c:191
f64 clocks_per_second
Definition: time.h:53
static f64 clib_time_now(clib_time_t *c)
Definition: time.h:202
static u64 clib_cpu_time_now(void)
Definition: time.h:73
u32 log2_clocks_per_second
Definition: time.h:67
u64 last_verify_cpu_time
Definition: time.h:62
static void unix_sleep(f64 dt)
Definition: time.h:264
#define always_inline
Definition: clib.h:92
static f64 unix_time_now(void)
Definition: time.h:227
unsigned long u64
Definition: types.h:89
static void unix_time_now_nsec_fraction(u32 *sec, u32 *nsec)
Definition: time.h:246
u32 log2_clocks_per_frequency_verify
Definition: time.h:67
#define PREDICT_FALSE(x)
Definition: clib.h:105
f64 seconds_per_clock
Definition: time.h:57
u64 total_cpu_time
Definition: time.h:47
vec_header_t h
Definition: buffer.c:282
static u64 unix_time_now_nsec(void)
Definition: time.h:238
static f64 unix_usage_now(void)
Definition: time.h:255
u64 last_cpu_time
Definition: time.h:50
unsigned int u32
Definition: types.h:88
f64 last_verify_reference_time
Definition: time.h:65
double f64
Definition: types.h:142
static f64 clib_time_now_internal(clib_time_t *c, u64 n)
Definition: time.h:187
u64 init_cpu_time
Definition: time.h:60
void clib_time_init(clib_time_t *c)
Definition: time.c:175