mbuf: remove control mbuf
[dpdk.git] / examples / ip_pipeline / hash_func.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2018 Intel Corporation
3  */
4
5 #ifndef __INCLUDE_HASH_FUNC_H__
6 #define __INCLUDE_HASH_FUNC_H__
7
8 static inline uint64_t
9 hash_xor_key8(void *key, void *mask, __rte_unused uint32_t key_size,
10         uint64_t seed)
11 {
12         uint64_t *k = key;
13         uint64_t *m = mask;
14         uint64_t xor0;
15
16         xor0 = seed ^ (k[0] & m[0]);
17
18         return (xor0 >> 32) ^ xor0;
19 }
20
21 static inline uint64_t
22 hash_xor_key16(void *key, void *mask, __rte_unused uint32_t key_size,
23         uint64_t seed)
24 {
25         uint64_t *k = key;
26         uint64_t *m = mask;
27         uint64_t xor0;
28
29         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
30
31         return (xor0 >> 32) ^ xor0;
32 }
33
34 static inline uint64_t
35 hash_xor_key24(void *key, void *mask, __rte_unused uint32_t key_size,
36         uint64_t seed)
37 {
38         uint64_t *k = key;
39         uint64_t *m = mask;
40         uint64_t xor0;
41
42         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
43
44         xor0 ^= k[2] & m[2];
45
46         return (xor0 >> 32) ^ xor0;
47 }
48
49 static inline uint64_t
50 hash_xor_key32(void *key, void *mask, __rte_unused uint32_t key_size,
51         uint64_t seed)
52 {
53         uint64_t *k = key;
54         uint64_t *m = mask;
55         uint64_t xor0, xor1;
56
57         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
58         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
59
60         xor0 ^= xor1;
61
62         return (xor0 >> 32) ^ xor0;
63 }
64
65 static inline uint64_t
66 hash_xor_key40(void *key, void *mask, __rte_unused uint32_t key_size,
67         uint64_t seed)
68 {
69         uint64_t *k = key;
70         uint64_t *m = mask;
71         uint64_t xor0, xor1;
72
73         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
74         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
75
76         xor0 ^= xor1;
77
78         xor0 ^= k[4] & m[4];
79
80         return (xor0 >> 32) ^ xor0;
81 }
82
83 static inline uint64_t
84 hash_xor_key48(void *key, void *mask, __rte_unused uint32_t key_size,
85         uint64_t seed)
86 {
87         uint64_t *k = key;
88         uint64_t *m = mask;
89         uint64_t xor0, xor1, xor2;
90
91         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
92         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
93         xor2 = (k[4] & m[4]) ^ (k[5] & m[5]);
94
95         xor0 ^= xor1;
96
97         xor0 ^= xor2;
98
99         return (xor0 >> 32) ^ xor0;
100 }
101
102 static inline uint64_t
103 hash_xor_key56(void *key, void *mask, __rte_unused uint32_t key_size,
104         uint64_t seed)
105 {
106         uint64_t *k = key;
107         uint64_t *m = mask;
108         uint64_t xor0, xor1, xor2;
109
110         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
111         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
112         xor2 = (k[4] & m[4]) ^ (k[5] & m[5]);
113
114         xor0 ^= xor1;
115         xor2 ^= k[6] & m[6];
116
117         xor0 ^= xor2;
118
119         return (xor0 >> 32) ^ xor0;
120 }
121
122 static inline uint64_t
123 hash_xor_key64(void *key, void *mask, __rte_unused uint32_t key_size,
124         uint64_t seed)
125 {
126         uint64_t *k = key;
127         uint64_t *m = mask;
128         uint64_t xor0, xor1, xor2, xor3;
129
130         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
131         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
132         xor2 = (k[4] & m[4]) ^ (k[5] & m[5]);
133         xor3 = (k[6] & m[6]) ^ (k[7] & m[7]);
134
135         xor0 ^= xor1;
136         xor2 ^= xor3;
137
138         xor0 ^= xor2;
139
140         return (xor0 >> 32) ^ xor0;
141 }
142
143 #if defined(RTE_ARCH_X86_64)
144
145 #include <x86intrin.h>
146
147 static inline uint64_t
148 hash_crc_key8(void *key, void *mask, __rte_unused uint32_t key_size,
149         uint64_t seed)
150 {
151         uint64_t *k = key;
152         uint64_t *m = mask;
153         uint64_t crc0;
154
155         crc0 = _mm_crc32_u64(seed, k[0] & m[0]);
156
157         return crc0;
158 }
159
160 static inline uint64_t
161 hash_crc_key16(void *key, void *mask, __rte_unused uint32_t key_size,
162         uint64_t seed)
163 {
164         uint64_t *k = key;
165         uint64_t *m = mask;
166         uint64_t k0, crc0, crc1;
167
168         k0 = k[0] & m[0];
169
170         crc0 = _mm_crc32_u64(k0, seed);
171         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
172
173         crc0 ^= crc1;
174
175         return crc0;
176 }
177
178 static inline uint64_t
179 hash_crc_key24(void *key, void *mask, __rte_unused uint32_t key_size,
180         uint64_t seed)
181 {
182         uint64_t *k = key;
183         uint64_t *m = mask;
184         uint64_t k0, k2, crc0, crc1;
185
186         k0 = k[0] & m[0];
187         k2 = k[2] & m[2];
188
189         crc0 = _mm_crc32_u64(k0, seed);
190         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
191
192         crc0 = _mm_crc32_u64(crc0, k2);
193
194         crc0 ^= crc1;
195
196         return crc0;
197 }
198
199 static inline uint64_t
200 hash_crc_key32(void *key, void *mask, __rte_unused uint32_t key_size,
201         uint64_t seed)
202 {
203         uint64_t *k = key;
204         uint64_t *m = mask;
205         uint64_t k0, k2, crc0, crc1, crc2, crc3;
206
207         k0 = k[0] & m[0];
208         k2 = k[2] & m[2];
209
210         crc0 = _mm_crc32_u64(k0, seed);
211         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
212
213         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
214         crc3 = k2 >> 32;
215
216         crc0 = _mm_crc32_u64(crc0, crc1);
217         crc1 = _mm_crc32_u64(crc2, crc3);
218
219         crc0 ^= crc1;
220
221         return crc0;
222 }
223
224 static inline uint64_t
225 hash_crc_key40(void *key, void *mask, __rte_unused uint32_t key_size,
226         uint64_t seed)
227 {
228         uint64_t *k = key;
229         uint64_t *m = mask;
230         uint64_t k0, k2, crc0, crc1, crc2, crc3;
231
232         k0 = k[0] & m[0];
233         k2 = k[2] & m[2];
234
235         crc0 = _mm_crc32_u64(k0, seed);
236         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
237
238         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
239         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
240
241         crc0 = _mm_crc32_u64(crc0, crc1);
242         crc1 = _mm_crc32_u64(crc2, crc3);
243
244         crc0 ^= crc1;
245
246         return crc0;
247 }
248
249 static inline uint64_t
250 hash_crc_key48(void *key, void *mask, __rte_unused uint32_t key_size,
251         uint64_t seed)
252 {
253         uint64_t *k = key;
254         uint64_t *m = mask;
255         uint64_t k0, k2, k5, crc0, crc1, crc2, crc3;
256
257         k0 = k[0] & m[0];
258         k2 = k[2] & m[2];
259         k5 = k[5] & m[5];
260
261         crc0 = _mm_crc32_u64(k0, seed);
262         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
263
264         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
265         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
266
267         crc0 = _mm_crc32_u64(crc0, (crc1 << 32) ^ crc2);
268         crc1 = _mm_crc32_u64(crc3, k5);
269
270         crc0 ^= crc1;
271
272         return crc0;
273 }
274
275 static inline uint64_t
276 hash_crc_key56(void *key, void *mask, __rte_unused uint32_t key_size,
277         uint64_t seed)
278 {
279         uint64_t *k = key;
280         uint64_t *m = mask;
281         uint64_t k0, k2, k5, crc0, crc1, crc2, crc3, crc4, crc5;
282
283         k0 = k[0] & m[0];
284         k2 = k[2] & m[2];
285         k5 = k[5] & m[5];
286
287         crc0 = _mm_crc32_u64(k0, seed);
288         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
289
290         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
291         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
292
293         crc4 = _mm_crc32_u64(k5, k[6] & m[6]);
294         crc5 = k5 >> 32;
295
296         crc0 = _mm_crc32_u64(crc0, (crc1 << 32) ^ crc2);
297         crc1 = _mm_crc32_u64(crc3, (crc4 << 32) ^ crc5);
298
299         crc0 ^= crc1;
300
301         return crc0;
302 }
303
304 static inline uint64_t
305 hash_crc_key64(void *key, void *mask, __rte_unused uint32_t key_size,
306         uint64_t seed)
307 {
308         uint64_t *k = key;
309         uint64_t *m = mask;
310         uint64_t k0, k2, k5, crc0, crc1, crc2, crc3, crc4, crc5;
311
312         k0 = k[0] & m[0];
313         k2 = k[2] & m[2];
314         k5 = k[5] & m[5];
315
316         crc0 = _mm_crc32_u64(k0, seed);
317         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
318
319         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
320         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
321
322         crc4 = _mm_crc32_u64(k5, k[6] & m[6]);
323         crc5 = _mm_crc32_u64(k5 >> 32, k[7] & m[7]);
324
325         crc0 = _mm_crc32_u64(crc0, (crc1 << 32) ^ crc2);
326         crc1 = _mm_crc32_u64(crc3, (crc4 << 32) ^ crc5);
327
328         crc0 ^= crc1;
329
330         return crc0;
331 }
332
333 #define hash_default_key8                       hash_crc_key8
334 #define hash_default_key16                      hash_crc_key16
335 #define hash_default_key24                      hash_crc_key24
336 #define hash_default_key32                      hash_crc_key32
337 #define hash_default_key40                      hash_crc_key40
338 #define hash_default_key48                      hash_crc_key48
339 #define hash_default_key56                      hash_crc_key56
340 #define hash_default_key64                      hash_crc_key64
341
342 #elif defined(RTE_ARCH_ARM64)
343 #include "hash_func_arm64.h"
344 #else
345
346 #define hash_default_key8                       hash_xor_key8
347 #define hash_default_key16                      hash_xor_key16
348 #define hash_default_key24                      hash_xor_key24
349 #define hash_default_key32                      hash_xor_key32
350 #define hash_default_key40                      hash_xor_key40
351 #define hash_default_key48                      hash_xor_key48
352 #define hash_default_key56                      hash_xor_key56
353 #define hash_default_key64                      hash_xor_key64
354
355 #endif
356
357 #endif