Line data Source code
1 : /* SPDX-License-Identifier: Apache-2.0
2 : * Copyright(c) 2021 Cisco Systems, Inc.
3 : */
4 :
5 : #ifndef included_vector_mask_compare_h
6 : #define included_vector_mask_compare_h
7 : #include <vppinfra/clib.h>
8 : #include <vppinfra/memcpy.h>
9 :
10 : static_always_inline u64
11 12118900 : clib_mask_compare_u16_x64 (u16 v, u16 *a, u32 n_elts)
12 : {
13 12118900 : u64 mask = 0;
14 : #if defined(CLIB_HAVE_VEC512)
15 0 : u16x32 v32 = u16x32_splat (v);
16 0 : u16x32u *av = (u16x32u *) a;
17 0 : mask = ((u64) u16x32_is_equal_mask (av[0], v32) |
18 0 : (u64) u16x32_is_equal_mask (av[1], v32) << 32);
19 : #elif defined(CLIB_HAVE_VEC256)
20 12118900 : u16x16 v16 = u16x16_splat (v);
21 12118900 : u16x16u *av = (u16x16u *) a;
22 : i8x32 x;
23 :
24 12118900 : x = i8x32_pack (v16 == av[0], v16 == av[1]);
25 12118900 : mask = i8x32_msb_mask ((i8x32) u64x4_permute (x, 0, 2, 1, 3));
26 12118900 : x = i8x32_pack (v16 == av[2], v16 == av[3]);
27 12118900 : 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 0 : u16x8 v8 = u16x8_splat (v);
44 0 : u16x8u *av = (u16x8u *) a;
45 0 : mask = ((u64) i8x16_msb_mask (i8x16_pack (v8 == av[0], v8 == av[1])) |
46 0 : (u64) i8x16_msb_mask (i8x16_pack (v8 == av[2], v8 == av[3])) << 16 |
47 0 : (u64) i8x16_msb_mask (i8x16_pack (v8 == av[4], v8 == av[5])) << 32 |
48 0 : (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 12118900 : 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 :
66 : static_always_inline void
67 8364310 : clib_mask_compare_u16 (u16 v, u16 *a, u64 *mask, u32 n_elts)
68 : {
69 12535600 : while (n_elts >= 64)
70 : {
71 4171320 : mask++[0] = clib_mask_compare_u16_x64 (v, a, 64);
72 4171320 : n_elts -= 64;
73 4171320 : a += 64;
74 : }
75 :
76 8364310 : if (PREDICT_TRUE (n_elts == 0))
77 416735 : return;
78 :
79 7947580 : mask[0] = clib_mask_compare_u16_x64 (v, a, n_elts) & pow2_mask (n_elts);
80 : }
81 :
82 : static_always_inline u64
83 10 : clib_mask_compare_u32_x64 (u32 v, u32 *a, u32 n_elts)
84 : {
85 10 : u64 mask = 0;
86 : #if defined(CLIB_HAVE_VEC512)
87 0 : u32x16 v16 = u32x16_splat (v);
88 0 : u32x16u *av = (u32x16u *) a;
89 0 : mask = ((u64) u32x16_is_equal_mask (av[0], v16) |
90 0 : (u64) u32x16_is_equal_mask (av[1], v16) << 16 |
91 0 : (u64) u32x16_is_equal_mask (av[2], v16) << 32 |
92 0 : (u64) u32x16_is_equal_mask (av[3], v16) << 48);
93 : #elif defined(CLIB_HAVE_VEC256)
94 10 : u32x8 v8 = u32x8_splat (v);
95 10 : u32x8u *av = (u32x8u *) a;
96 10 : u32x8 m = { 0, 4, 1, 5, 2, 6, 3, 7 };
97 : i8x32 c;
98 :
99 10 : c = i8x32_pack (i16x16_pack ((i32x8) (v8 == av[0]), (i32x8) (v8 == av[1])),
100 10 : i16x16_pack ((i32x8) (v8 == av[2]), (i32x8) (v8 == av[3])));
101 10 : mask = i8x32_msb_mask ((i8x32) u32x8_permute ((u32x8) c, m));
102 :
103 10 : c = i8x32_pack (i16x16_pack ((i32x8) (v8 == av[4]), (i32x8) (v8 == av[5])),
104 10 : i16x16_pack ((i32x8) (v8 == av[6]), (i32x8) (v8 == av[7])));
105 10 : 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 0 : u32x4 v4 = u32x4_splat (v);
123 0 : u32x4u *av = (u32x4u *) a;
124 :
125 0 : for (int i = 0; i < 4; i++)
126 : {
127 0 : i16x8 p1 = i16x8_pack (v4 == av[0], v4 == av[1]);
128 0 : i16x8 p2 = i16x8_pack (v4 == av[2], v4 == av[3]);
129 0 : mask |= (u64) i8x16_msb_mask (i8x16_pack (p1, p2)) << (i * 16);
130 0 : 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 10 : 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 :
150 : static_always_inline void
151 10 : clib_mask_compare_u32 (u32 v, u32 *a, u64 *bitmap, u32 n_elts)
152 : {
153 10 : while (n_elts >= 64)
154 : {
155 0 : bitmap++[0] = clib_mask_compare_u32_x64 (v, a, 64);
156 0 : n_elts -= 64;
157 0 : a += 64;
158 : }
159 :
160 10 : if (PREDICT_TRUE (n_elts == 0))
161 0 : return;
162 :
163 10 : bitmap[0] = clib_mask_compare_u32_x64 (v, a, n_elts) & pow2_mask (n_elts);
164 : }
165 :
166 : static_always_inline u64
167 : clib_mask_compare_u64_x64 (u64 v, u64 *a, u32 n_elts)
168 : {
169 : u64 mask = 0;
170 : #if defined(CLIB_HAVE_VEC512)
171 : u64x8 v8 = u64x8_splat (v);
172 : u64x8u *av = (u64x8u *) a;
173 : mask = ((u64) u64x8_is_equal_mask (av[0], v8) |
174 : (u64) u64x8_is_equal_mask (av[1], v8) << 8 |
175 : (u64) u64x8_is_equal_mask (av[2], v8) << 16 |
176 : (u64) u64x8_is_equal_mask (av[3], v8) << 24 |
177 : (u64) u64x8_is_equal_mask (av[4], v8) << 32 |
178 : (u64) u64x8_is_equal_mask (av[5], v8) << 40 |
179 : (u64) u64x8_is_equal_mask (av[6], v8) << 48 |
180 : (u64) u64x8_is_equal_mask (av[7], v8) << 56);
181 :
182 : #elif defined(CLIB_HAVE_VEC256) && defined(__BMI2__)
183 : u64x4 v4 = u64x4_splat (v);
184 : u64x4u *av = (u64x4u *) a;
185 :
186 : for (int i = 0; i < 16; i += 2)
187 : {
188 : u64 l = u8x32_msb_mask (v4 == av[i]);
189 : u64 h = u8x32_msb_mask (v4 == av[i + 1]);
190 : mask |= _pext_u64 (l | h << 32, 0x0101010101010101) << (i * 4);
191 : }
192 : #else
193 : for (int i = 0; i < n_elts; i++)
194 : if (a[i] == v)
195 : mask |= 1ULL << i;
196 : #endif
197 : return mask;
198 : }
199 :
200 : /** \brief Compare 64-bit elemments with provied value and return bitmap
201 :
202 : @param v value to compare elements with
203 : @param a array of u64 elements
204 : @param mask array of u64 where reuslting mask will be stored
205 : @param n_elts number of elements in the array
206 : @return none
207 : */
208 :
209 : static_always_inline void
210 : clib_mask_compare_u64 (u64 v, u64 *a, u64 *bitmap, u32 n_elts)
211 : {
212 : while (n_elts >= 64)
213 : {
214 : bitmap++[0] = clib_mask_compare_u64_x64 (v, a, 64);
215 : n_elts -= 64;
216 : a += 64;
217 : }
218 :
219 : if (PREDICT_TRUE (n_elts == 0))
220 : return;
221 :
222 : bitmap[0] = clib_mask_compare_u64_x64 (v, a, n_elts) & pow2_mask (n_elts);
223 : }
224 :
225 : #endif
|
