FD.io VPP  v18.01-8-g0eacf49
Vector Packet Processing
clib.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_clib_h
39 #define included_clib_h
40 
41 /* Standalone means to not assume we are running on a Unix box. */
42 #if ! defined (CLIB_STANDALONE) && ! defined (CLIB_LINUX_KERNEL)
43 #define CLIB_UNIX
44 #endif
45 
46 #include <vppinfra/types.h>
47 
48 /* Global DEBUG flag. Setting this to 1 or 0 turns off
49  ASSERT (see vppinfra/error.h) & other debugging code. */
50 #ifndef CLIB_DEBUG
51 #define CLIB_DEBUG 0
52 #endif
53 
54 #ifndef NULL
55 #define NULL ((void *) 0)
56 #endif
57 
58 #define BITS(x) (8*sizeof(x))
59 #define ARRAY_LEN(x) (sizeof (x)/sizeof (x[0]))
60 
61 #define _STRUCT_FIELD(t,f) (((t *) 0)->f)
62 #define STRUCT_OFFSET_OF(t,f) ((uword) & _STRUCT_FIELD (t, f))
63 #define STRUCT_BIT_OFFSET_OF(t,f) (BITS(u8) * (uword) & _STRUCT_FIELD (t, f))
64 #define STRUCT_SIZE_OF(t,f) (sizeof (_STRUCT_FIELD (t, f)))
65 #define STRUCT_BITS_OF(t,f) (BITS (_STRUCT_FIELD (t, f)))
66 #define STRUCT_ARRAY_LEN(t,f) ARRAY_LEN (_STRUCT_FIELD (t, f))
67 #define STRUCT_MARK(mark) u8 mark[0]
68 #define STRUCT_MARK_PTR(v, f) &(v)->f
69 
70 /* Stride in bytes between struct array elements. */
71 #define STRUCT_STRIDE_OF(t,f) \
72  ( ((uword) & (((t *) 0)[1].f)) \
73  - ((uword) & (((t *) 0)[0].f)))
74 
75 #define STRUCT_OFFSET_OF_VAR(v,f) ((uword) (&(v)->f) - (uword) (v))
76 
77 /* Used to pack structure elements. */
78 #define CLIB_PACKED(x) x __attribute__ ((packed))
79 #define CLIB_UNUSED(x) x __attribute__ ((unused))
80 
81 /* Make a string from the macro's argument */
82 #define CLIB_STRING_MACRO(x) #x
83 
84 #define __clib_unused __attribute__ ((unused))
85 #define __clib_weak __attribute__ ((weak))
86 #define __clib_packed __attribute__ ((packed))
87 #define __clib_constructor __attribute__ ((constructor))
88 
89 #define never_inline __attribute__ ((__noinline__))
90 
91 #if CLIB_DEBUG > 0
92 #define always_inline static inline
93 #define static_always_inline static inline
94 #else
95 #define always_inline static inline __attribute__ ((__always_inline__))
96 #define static_always_inline static inline __attribute__ ((__always_inline__))
97 #endif
98 
99 
100 /* Reserved (unused) structure element with address offset between
101  from and to. */
102 #define CLIB_PAD_FROM_TO(from,to) u8 pad_##from[(to) - (from)]
103 
104 /* Hints to compiler about hot/cold code. */
105 #define PREDICT_FALSE(x) __builtin_expect((x),0)
106 #define PREDICT_TRUE(x) __builtin_expect((x),1)
107 
108 /* Full memory barrier (read and write). */
109 #define CLIB_MEMORY_BARRIER() __sync_synchronize ()
110 
111 #if __x86_64__
112 #define CLIB_MEMORY_STORE_BARRIER() __builtin_ia32_sfence ()
113 #else
114 #define CLIB_MEMORY_STORE_BARRIER() __sync_synchronize ()
115 #endif
116 
117 /* Arranges for function to be called before main. */
118 #define INIT_FUNCTION(decl) \
119  decl __attribute ((constructor)); \
120  decl
121 
122 /* Arranges for function to be called before exit. */
123 #define EXIT_FUNCTION(decl) \
124  decl __attribute ((destructor)); \
125  decl
126 
127 /* Use __builtin_clz if available. */
128 #ifdef __GNUC__
129 #include <features.h>
130 #if __GNUC_PREREQ(3, 4)
131 #if uword_bits == 64
132 #define count_leading_zeros(count,x) count = __builtin_clzll (x)
133 #define count_trailing_zeros(count,x) count = __builtin_ctzll (x)
134 #else
135 #define count_leading_zeros(count,x) count = __builtin_clzl (x)
136 #define count_trailing_zeros(count,x) count = __builtin_ctzl (x)
137 #endif
138 #endif
139 #endif
140 
141 #ifndef count_leading_zeros
142 
143 /* Misc. integer arithmetic functions. */
144 #if defined (i386)
145 #define count_leading_zeros(count, x) \
146  do { \
147  word _clz; \
148  __asm__ ("bsrl %1,%0" \
149  : "=r" (_clz) : "rm" ((word) (x)));\
150  (count) = _clz ^ 31; \
151  } while (0)
152 
153 #define count_trailing_zeros(count, x) \
154  __asm__ ("bsfl %1,%0" : "=r" (count) : "rm" ((word)(x)))
155 #endif /* i386 */
156 
157 #if defined (__alpha__) && defined (HAVE_CIX)
158 #define count_leading_zeros(count, x) \
159  __asm__ ("ctlz %1,%0" \
160  : "=r" ((word) (count)) \
161  : "r" ((word) (x)))
162 #define count_trailing_zeros(count, x) \
163  __asm__ ("cttz %1,%0" \
164  : "=r" ((word) (count)) \
165  : "r" ((word) (x)))
166 #endif /* alpha && HAVE_CIX */
167 
168 #if __mips >= 4
169 
170 /* Select between 32/64 opcodes. */
171 #if uword_bits == 32
172 #define count_leading_zeros(_count, _x) \
173  __asm__ ("clz %[count],%[x]" \
174  : [count] "=r" ((word) (_count)) \
175  : [x] "r" ((word) (_x)))
176 #else
177 #define count_leading_zeros(_count, _x) \
178  __asm__ ("dclz %[count],%[x]" \
179  : [count] "=r" ((word) (_count)) \
180  : [x] "r" ((word) (_x)))
181 #endif
182 
183 #endif /* __mips >= 4 */
184 
185 #endif /* count_leading_zeros */
186 
187 #if defined (count_leading_zeros)
189 min_log2 (uword x)
190 {
191  uword n;
192  count_leading_zeros (n, x);
193  return BITS (uword) - n - 1;
194 }
195 #else
198 {
199  uword a = x, b = BITS (uword) / 2, c = 0, r = 0;
200 
201  /* Reduce x to 4 bit result. */
202 #define _ \
203 { \
204  c = a >> b; \
205  if (c) a = c; \
206  if (c) r += b; \
207  b /= 2; \
208 }
209 
210  if (BITS (uword) > 32)
211  _;
212  _;
213  _;
214  _;
215 #undef _
216 
217  /* Do table lookup on 4 bit partial. */
218  if (BITS (uword) > 32)
219  {
220  const u64 table = 0x3333333322221104LL;
221  uword t = (table >> (4 * a)) & 0xf;
222  r = t < 4 ? r + t : ~0;
223  }
224  else
225  {
226  const u32 table = 0x22221104;
227  uword t = (a & 8) ? 3 : ((table >> (4 * a)) & 0xf);
228  r = t < 4 ? r + t : ~0;
229  }
230 
231  return r;
232 }
233 #endif
234 
237 {
238  uword l = min_log2 (x);
239  if (x > ((uword) 1 << l))
240  l++;
241  return l;
242 }
243 
246 {
247  if (BITS (uword) == 64)
248  return min_log2 (x);
249  else
250  {
251  uword l, y;
252  y = x;
253  l = 0;
254  if (y == 0)
255  {
256  l += 32;
257  x >>= 32;
258  }
259  l += min_log2 (x);
260  return l;
261  }
262 }
263 
266 {
267  return ((uword) 1 << x) - (uword) 1;
268 }
269 
272 {
273  word y = (word) 1 << min_log2 (x);
274  if (x > y)
275  y *= 2;
276  return y;
277 }
278 
281 {
282  return 0 == (x & (x - 1));
283 }
284 
287 {
288  return (x + pow2 - 1) & ~(pow2 - 1);
289 }
290 
293 {
294  return (x + pow2 - 1) & ~(pow2 - 1);
295 }
296 
299 {
300  return x & -x;
301 }
302 
305 {
306  uword result;
307 #ifdef count_trailing_zeros
308  count_trailing_zeros (result, x);
309 #else
310  result = min_log2 (first_set (x));
311 #endif
312  return result;
313 }
314 
317 {
318  return (int) x;
319 }
320 
323 {
324  return (word) (x + .5);
325 }
326 
329 {
330  return f * flt_round_nearest (x / f);
331 }
332 
333 #define clib_max(x,y) \
334 ({ \
335  __typeof__ (x) _x = (x); \
336  __typeof__ (y) _y = (y); \
337  _x > _y ? _x : _y; \
338 })
339 
340 #define clib_min(x,y) \
341 ({ \
342  __typeof__ (x) _x = (x); \
343  __typeof__ (y) _y = (y); \
344  _x < _y ? _x : _y; \
345 })
346 
347 #define clib_abs(x) \
348 ({ \
349  __typeof__ (x) _x = (x); \
350  _x < 0 ? -_x : _x; \
351 })
352 
353 /* Standard standalone-only function declarations. */
354 #ifndef CLIB_UNIX
355 void clib_standalone_init (void *memory, uword memory_bytes);
356 
357 void qsort (void *base, uword n, uword size,
358  int (*)(const void *, const void *));
359 #endif
360 
361 /* Stack backtrace. */
362 uword
363 clib_backtrace (uword * callers, uword max_callers, uword n_frames_to_skip);
364 
365 #endif /* included_clib_h */
366 
367 /*
368  * fd.io coding-style-patch-verification: ON
369  *
370  * Local Variables:
371  * eval: (c-set-style "gnu")
372  * End:
373  */
a
Definition: bitmap.h:516
static uword log2_first_set(uword x)
Definition: clib.h:304
add_epi add_epi sub_epi sub_epi adds_epu subs_epu i16x8 y
Definition: vector_sse2.h:293
static uword min_log2(uword x)
Definition: clib.h:197
vhost_user_memory_t memory
Definition: vhost-user.h:84
#define always_inline
Definition: clib.h:92
static uword pow2_mask(uword x)
Definition: clib.h:265
unsigned long u64
Definition: types.h:89
static u64 min_log2_u64(u64 x)
Definition: clib.h:245
uword clib_backtrace(uword *callers, uword max_callers, uword n_frames_to_skip)
Definition: backtrace.c:232
svmdb_client_t * c
static f64 flt_round_to_multiple(f64 x, f64 f)
Definition: clib.h:328
static uword max_pow2(uword x)
Definition: clib.h:271
static u64 round_pow2_u64(u64 x, u64 pow2)
Definition: clib.h:292
static uword round_pow2(uword x, uword pow2)
Definition: clib.h:286
static uword first_set(uword x)
Definition: clib.h:298
unsigned int u32
Definition: types.h:88
static uword is_pow2(uword x)
Definition: clib.h:280
u64 uword
Definition: types.h:112
i64 word
Definition: types.h:111
static word flt_round_nearest(f64 x)
Definition: clib.h:322
void qsort(void *base, uword n, uword size, int(*compar)(const void *, const void *))
Definition: qsort.c:56
double f64
Definition: types.h:142
static uword max_log2(uword x)
Definition: clib.h:236
static f64 flt_round_down(f64 x)
Definition: clib.h:316
#define BITS(x)
Definition: clib.h:58