FD.io VPP  v21.06-3-gbb25fbf28
Vector Packet Processing
vector_funcs.h
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0
2  * Copyright(c) 2021 Cisco Systems, Inc.
3  */
4 
5 #ifndef included_vector_funcs_h
6 #define included_vector_funcs_h
7 #include <vppinfra/clib.h>
8 #include <vppinfra/memcpy.h>
9 
12 {
13  u64 mask = 0;
14 #if defined(CLIB_HAVE_VEC512)
15  u16x32 v32 = u16x32_splat (v);
16  u16x32u *av = (u16x32u *) a;
17  mask = ((u64) u16x32_is_equal_mask (av[0], v32) |
18  (u64) u16x32_is_equal_mask (av[1], v32) << 32);
19 #elif defined(CLIB_HAVE_VEC256)
20  u16x16 v16 = u16x16_splat (v);
21  u16x16u *av = (u16x16u *) a;
22  i8x32 x;
23 
24  x = i8x32_pack (v16 == av[0], v16 == av[1]);
25  mask = i8x32_msb_mask ((i8x32) u64x4_permute (x, 0, 2, 1, 3));
26  x = i8x32_pack (v16 == av[2], v16 == av[3]);
27  mask |= (u64) i8x32_msb_mask ((i8x32) u64x4_permute (x, 0, 2, 1, 3)) << 32;
28 #elif defined(CLIB_HAVE_VEC128) && defined(__ARM_NEON)
29  u16x8 v8 = u16x8_splat (v);
30  u16x8 m = { 1, 2, 4, 8, 16, 32, 64, 128 };
31  u16x8u *av = (u16x8u *) a;
32 
33  /* compare each u16 elemment with v8, result gives 0xffff in each element
34  of the resulting vector if comparison result is true.
35  Bitwise AND with m will give us one bit set for true result and offset
36  of that bit represend element index. Finally vaddvq_u16() gives us sum
37  of all elements of the vector which will give us u8 bitmap. */
38 
39  for (int i = 0; i < 8; i++)
40  mask |= (u64) vaddvq_u16 ((av[i] == v8) & m) << (i * 8);
41 
42 #elif defined(CLIB_HAVE_VEC128) && defined(CLIB_HAVE_VEC128_MSB_MASK)
43  u16x8 v8 = u16x8_splat (v);
44  u16x8u *av = (u16x8u *) a;
45  mask = ((u64) i8x16_msb_mask (i8x16_pack (v8 == av[0], v8 == av[1])) |
46  (u64) i8x16_msb_mask (i8x16_pack (v8 == av[2], v8 == av[3])) << 16 |
47  (u64) i8x16_msb_mask (i8x16_pack (v8 == av[4], v8 == av[5])) << 32 |
48  (u64) i8x16_msb_mask (i8x16_pack (v8 == av[6], v8 == av[7])) << 48);
49 #else
50  for (int i = 0; i < n_elts; i++)
51  if (a[i] == v)
52  mask |= 1ULL << i;
53 #endif
54  return mask;
55 }
56 
57 /** \brief Compare 16-bit elemments with provied value and return bitmap
58 
59  @param v value to compare elements with
60  @param a array of u16 elements
61  @param mask array of u64 where reuslting mask will be stored
62  @param n_elts number of elements in the array
63  @return none
64 */
65 
68 {
69  while (n_elts >= 64)
70  {
71  mask++[0] = clib_mask_compare_u16_x64 (v, a, 64);
72  n_elts -= 64;
73  a += 64;
74  }
75 
76  if (PREDICT_TRUE (n_elts == 0))
77  return;
78 
79  mask[0] = clib_mask_compare_u16_x64 (v, a, n_elts) & pow2_mask (n_elts);
80 }
81 
84 {
85  u64 mask = 0;
86 #if defined(CLIB_HAVE_VEC512)
87  u32x16 v16 = u32x16_splat (v);
88  u32x16u *av = (u32x16u *) a;
89  mask = ((u64) u32x16_is_equal_mask (av[0], v16) |
90  (u64) u32x16_is_equal_mask (av[1], v16) << 16 |
91  (u64) u32x16_is_equal_mask (av[2], v16) << 32 |
92  (u64) u32x16_is_equal_mask (av[3], v16) << 48);
93 #elif defined(CLIB_HAVE_VEC256)
94  u32x8 v8 = u32x8_splat (v);
95  u32x8u *av = (u32x8u *) a;
96  u32x8 m = { 0, 4, 1, 5, 2, 6, 3, 7 };
97  i8x32 c;
98 
99  c = i8x32_pack (i16x16_pack ((i32x8) (v8 == av[0]), (i32x8) (v8 == av[1])),
100  i16x16_pack ((i32x8) (v8 == av[2]), (i32x8) (v8 == av[3])));
101  mask = i8x32_msb_mask ((i8x32) u32x8_permute ((u32x8) c, m));
102 
103  c = i8x32_pack (i16x16_pack ((i32x8) (v8 == av[4]), (i32x8) (v8 == av[5])),
104  i16x16_pack ((i32x8) (v8 == av[6]), (i32x8) (v8 == av[7])));
105  mask |= (u64) i8x32_msb_mask ((i8x32) u32x8_permute ((u32x8) c, m)) << 32;
106 
107 #elif defined(CLIB_HAVE_VEC128) && defined(__ARM_NEON)
108  u32x4 v4 = u32x4_splat (v);
109  u32x4 m = { 1, 2, 4, 8 };
110  u32x4u *av = (u32x4u *) a;
111 
112  /* compare each u32 elemment with v4, result gives -1 in each element
113  of the resulting vector if comparison result is true.
114  Bitwise AND with m will give us one bit set for true result and offset
115  of that bit represend element index. Finally vaddvq_u32() gives us sum
116  of all elements of the vector which will give us u8 bitmap. */
117 
118  for (int i = 0; i < 16; i++)
119  mask |= (u64) vaddvq_u32 ((av[i] == v4) & m) << (i * 4);
120 
121 #elif defined(CLIB_HAVE_VEC128) && defined(CLIB_HAVE_VEC128_MSB_MASK)
122  u32x4 v4 = u32x4_splat (v);
123  u32x4u *av = (u32x4u *) a;
124 
125  for (int i = 0; i < 4; i++)
126  {
127  i16x8 p1 = i16x8_pack (v4 == av[0], v4 == av[1]);
128  i16x8 p2 = i16x8_pack (v4 == av[2], v4 == av[3]);
129  mask |= (u64) i8x16_msb_mask (i8x16_pack (p1, p2)) << (i * 16);
130  av += 4;
131  }
132 
133 #else
134  for (int i = 0; i < n_elts; i++)
135  if (a[i] == v)
136  mask |= 1ULL << i;
137 #endif
138  return mask;
139 }
140 
141 /** \brief Compare 32-bit elemments with provied value and return bitmap
142 
143  @param v value to compare elements with
144  @param a array of u32 elements
145  @param mask array of u64 where reuslting mask will be stored
146  @param n_elts number of elements in the array
147  @return none
148 */
149 
151 clib_mask_compare_u32 (u32 v, u32 *a, u64 *bitmap, u32 n_elts)
152 {
153  while (n_elts >= 64)
154  {
155  bitmap++[0] = clib_mask_compare_u32_x64 (v, a, 64);
156  n_elts -= 64;
157  a += 64;
158  }
159 
160  if (PREDICT_TRUE (n_elts == 0))
161  return;
162 
163  bitmap[0] = clib_mask_compare_u32_x64 (v, a, n_elts) & pow2_mask (n_elts);
164 }
165 
168 {
169 #if defined(CLIB_HAVE_VEC512_COMPRESS)
170  u32x16u *sv = (u32x16u *) src;
171  for (int i = 0; i < 4; i++)
172  {
173  int cnt = _popcnt32 ((u16) mask);
174  u32x16_compress_store (sv[i], mask, dst);
175  dst += cnt;
176  mask >>= 16;
177  }
178 
179 #elif defined(CLIB_HAVE_VEC256_COMPRESS)
180  u32x8u *sv = (u32x8u *) src;
181  for (int i = 0; i < 8; i++)
182  {
183  int cnt = _popcnt32 ((u8) mask);
184  u32x8_compress_store (sv[i], mask, dst);
185  dst += cnt;
186  mask >>= 8;
187  }
188 #else
189  while (mask)
190  {
191  u16 bit = count_trailing_zeros (mask);
193  dst++[0] = src[bit];
194  }
195 #endif
196  return dst;
197 }
198 
199 /** \brief Compare array of 32-bit elemments into destination array based on
200  * mask
201 
202  @param dst destination array of u32 elements
203  @param src source array of u32 elements
204  @param mask array of u64 values representing compress mask
205  @param n_elts number of elements in the source array
206  @return number of elements stored in destionation array
207 */
208 
211 {
212  u32 *dst0 = dst;
213  while (n_elts >= 64)
214  {
215  if (mask[0] == ~0ULL)
216  {
217  clib_memcpy_u32 (dst, src, 64);
218  dst += 64;
219  }
220  else
222 
223  mask++;
224  src += 64;
225  n_elts -= 64;
226  }
227 
228  if (PREDICT_TRUE (n_elts == 0))
229  return dst - dst0;
230 
231  return clib_compress_u32_x64 (dst, src, mask[0] & pow2_mask (n_elts)) - dst0;
232 }
233 
234 #endif
count_trailing_zeros
#define count_trailing_zeros(x)
Definition: clib.h:161
u32x8_permute
foreach_avx2_vec256i static foreach_avx2_vec256u u32x8 u32x8_permute(u32x8 v, u32x8 idx)
Definition: vector_avx2.h:73
clib_compress_u32_x64
static_always_inline u32 * clib_compress_u32_x64(u32 *dst, u32 *src, u64 mask)
Definition: vector_funcs.h:167
pow2_mask
static uword pow2_mask(uword x)
Definition: clib.h:252
clib.h
memcpy.h
u16
unsigned short u16
Definition: types.h:57
clib_mask_compare_u16
static_always_inline void clib_mask_compare_u16(u16 v, u16 *a, u64 *mask, u32 n_elts)
Compare 16-bit elemments with provied value and return bitmap.
Definition: vector_funcs.h:67
clib_memcpy_u32
static_always_inline void clib_memcpy_u32(u32 *dst, u32 *src, u32 n_left)
Definition: memcpy.h:43
u64x4_permute
#define u64x4_permute(v, m0, m1, m2, m3)
Definition: vector_avx2.h:78
u16x32
_mm512_packus_epi16 u16x32
Definition: vector_avx512.h:98
v8
u8 v8
Definition: ikev2.h:33
c
svmdb_client_t * c
Definition: vpp_get_metrics.c:48
static_always_inline
#define static_always_inline
Definition: clib.h:112
i
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
mask
vl_api_pnat_mask_t mask
Definition: pnat.api:45
src
vl_api_address_t src
Definition: gre.api:54
clib_mask_compare_u32
static_always_inline void clib_mask_compare_u32(u32 v, u32 *a, u64 *bitmap, u32 n_elts)
Compare 32-bit elemments with provied value and return bitmap.
Definition: vector_funcs.h:151
i8x32_msb_mask
static_always_inline u32 i8x32_msb_mask(i8x32 v)
Definition: vector_avx2.h:129
clib_mask_compare_u32_x64
static_always_inline u64 clib_mask_compare_u32_x64(u32 v, u32 *a, u32 n_elts)
Definition: vector_funcs.h:83
u16x8
_mm_packus_epi16 u16x8
Definition: vector_sse42.h:196
u64
unsigned long u64
Definition: types.h:89
u32
unsigned int u32
Definition: types.h:88
i8x16_msb_mask
static_always_inline u16 i8x16_msb_mask(i8x16 v)
Definition: vector_sse42.h:561
dst
vl_api_ip4_address_t dst
Definition: pnat.api:41
u32x4
unsigned long long u32x4
Definition: ixge.c:28
clear_lowest_set_bit
static uword clear_lowest_set_bit(uword x)
Definition: clib.h:166
i16x8
vmrglw i16x8
Definition: vector_altivec.h:97
u8
unsigned char u8
Definition: types.h:56
a
a
Definition: bitmap.h:544
PREDICT_TRUE
#define PREDICT_TRUE(x)
Definition: clib.h:125
u16x16
_mm256_packus_epi16 u16x16
Definition: vector_avx2.h:118
clib_compress_u32
static_always_inline u32 clib_compress_u32(u32 *dst, u32 *src, u64 *mask, u32 n_elts)
Compare array of 32-bit elemments into destination array based on mask.
Definition: vector_funcs.h:210
clib_mask_compare_u16_x64
static_always_inline u64 clib_mask_compare_u16_x64(u16 v, u16 *a, u32 n_elts)
Definition: vector_funcs.h:11