Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2017-2020 Intel Corporation
3 : : */
4 : :
5 : : #include <stddef.h>
6 : : #include <stdint.h>
7 : :
8 : : #include <rte_cpuflags.h>
9 : : #include <rte_common.h>
10 : : #include <rte_net_crc.h>
11 : : #include <rte_log.h>
12 : : #include <rte_vect.h>
13 : : #include <rte_function_versioning.h>
14 : : #include <rte_malloc.h>
15 : :
16 : : #include "net_crc.h"
17 : :
18 : : /** CRC polynomials */
19 : : #define CRC32_ETH_POLYNOMIAL 0x04c11db7UL
20 : : #define CRC16_CCITT_POLYNOMIAL 0x1021U
21 : :
22 : : #define CRC_LUT_SIZE 256
23 : :
24 : : /* crc tables */
25 : : static uint32_t crc32_eth_lut[CRC_LUT_SIZE];
26 : : static uint32_t crc16_ccitt_lut[CRC_LUT_SIZE];
27 : :
28 : : static uint32_t
29 : : rte_crc16_ccitt_default_handler(const uint8_t *data, uint32_t data_len);
30 : :
31 : : static uint32_t
32 : : rte_crc32_eth_default_handler(const uint8_t *data, uint32_t data_len);
33 : :
34 : : static uint32_t
35 : : rte_crc16_ccitt_handler(const uint8_t *data, uint32_t data_len);
36 : :
37 : : static uint32_t
38 : : rte_crc32_eth_handler(const uint8_t *data, uint32_t data_len);
39 : :
40 : : typedef uint32_t
41 : : (*rte_net_crc_handler)(const uint8_t *data, uint32_t data_len);
42 : :
43 : : struct rte_net_crc {
44 : : enum rte_net_crc_alg alg;
45 : : enum rte_net_crc_type type;
46 : : };
47 : :
48 : : static rte_net_crc_handler handlers_default[] = {
49 : : [RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_default_handler,
50 : : [RTE_NET_CRC32_ETH] = rte_crc32_eth_default_handler,
51 : : };
52 : :
53 : : static struct {
54 : : rte_net_crc_handler f[RTE_NET_CRC_REQS];
55 : : } handlers_dpdk26[RTE_NET_CRC_AVX512 + 1];
56 : :
57 : : static const rte_net_crc_handler *handlers = handlers_default;
58 : :
59 : : static const rte_net_crc_handler handlers_scalar[] = {
60 : : [RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_handler,
61 : : [RTE_NET_CRC32_ETH] = rte_crc32_eth_handler,
62 : : };
63 : : #ifdef CC_X86_64_AVX512_VPCLMULQDQ_SUPPORT
64 : : static const rte_net_crc_handler handlers_avx512[] = {
65 : : [RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_avx512_handler,
66 : : [RTE_NET_CRC32_ETH] = rte_crc32_eth_avx512_handler,
67 : : };
68 : : #endif
69 : : #ifdef CC_X86_64_SSE42_PCLMULQDQ_SUPPORT
70 : : static const rte_net_crc_handler handlers_sse42[] = {
71 : : [RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_sse42_handler,
72 : : [RTE_NET_CRC32_ETH] = rte_crc32_eth_sse42_handler,
73 : : };
74 : : #endif
75 : : #ifdef CC_ARM64_NEON_PMULL_SUPPORT
76 : : static const rte_net_crc_handler handlers_neon[] = {
77 : : [RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_neon_handler,
78 : : [RTE_NET_CRC32_ETH] = rte_crc32_eth_neon_handler,
79 : : };
80 : : #endif
81 : :
82 : : static uint16_t max_simd_bitwidth;
83 : :
84 [ - + ]: 252 : RTE_LOG_REGISTER_DEFAULT(libnet_logtype, INFO);
85 : : #define RTE_LOGTYPE_NET libnet_logtype
86 : :
87 : : #define NET_LOG(level, ...) \
88 : : RTE_LOG_LINE_PREFIX(level, NET, "%s(): ", __func__, __VA_ARGS__)
89 : :
90 : : /* Scalar handling */
91 : :
92 : : /**
93 : : * Reflect the bits about the middle
94 : : *
95 : : * @param val
96 : : * value to be reflected
97 : : *
98 : : * @return
99 : : * reflected value
100 : : */
101 : : static uint32_t
102 : : reflect_32bits(uint32_t val)
103 : : {
104 : : uint32_t i, res = 0;
105 : :
106 [ + + + + ]: 8515584 : for (i = 0; i < 32; i++)
107 [ + + + + ]: 8257536 : if ((val & (1U << i)) != 0)
108 : 2064384 : res |= (uint32_t)(1U << (31 - i));
109 : :
110 : : return res;
111 : : }
112 : :
113 : : static void
114 : 504 : crc32_eth_init_lut(uint32_t poly,
115 : : uint32_t *lut)
116 : : {
117 : : uint32_t i, j;
118 : :
119 [ + + ]: 129528 : for (i = 0; i < CRC_LUT_SIZE; i++) {
120 : : uint32_t crc = reflect_32bits(i);
121 : :
122 [ + + ]: 1161216 : for (j = 0; j < 8; j++) {
123 [ + + ]: 1032192 : if (crc & 0x80000000L)
124 : 516096 : crc = (crc << 1) ^ poly;
125 : : else
126 : 516096 : crc <<= 1;
127 : : }
128 : 258048 : lut[i] = reflect_32bits(crc);
129 : : }
130 : 504 : }
131 : :
132 : : static __rte_always_inline uint32_t
133 : : crc32_eth_calc_lut(const uint8_t *data,
134 : : uint32_t data_len,
135 : : uint32_t crc,
136 : : const uint32_t *lut)
137 : : {
138 [ + + + + ]: 3888 : while (data_len--)
139 : 3876 : crc = lut[(crc ^ *data++) & 0xffL] ^ (crc >> 8);
140 : :
141 : : return crc;
142 : : }
143 : :
144 : : static void
145 : 252 : rte_net_crc_scalar_init(void)
146 : : {
147 : : /* 32-bit crc init */
148 : 252 : crc32_eth_init_lut(CRC32_ETH_POLYNOMIAL, crc32_eth_lut);
149 : :
150 : : /* 16-bit CRC init */
151 : 252 : crc32_eth_init_lut(CRC16_CCITT_POLYNOMIAL << 16, crc16_ccitt_lut);
152 : 252 : }
153 : :
154 : : static inline uint32_t
155 : 6 : rte_crc16_ccitt_handler(const uint8_t *data, uint32_t data_len)
156 : : {
157 : : /* return 16-bit CRC value */
158 : 6 : return (uint16_t)~crc32_eth_calc_lut(data,
159 : : data_len,
160 : : 0xffff,
161 : : crc16_ccitt_lut);
162 : : }
163 : :
164 : : static inline uint32_t
165 : 6 : rte_crc32_eth_handler(const uint8_t *data, uint32_t data_len)
166 : : {
167 : : /* return 32-bit CRC value */
168 : 6 : return ~crc32_eth_calc_lut(data,
169 : : data_len,
170 : : 0xffffffffUL,
171 : : crc32_eth_lut);
172 : : }
173 : :
174 : : /* AVX512/VPCLMULQDQ handling */
175 : :
176 : : #define AVX512_VPCLMULQDQ_CPU_SUPPORTED ( \
177 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512F) && \
178 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512BW) && \
179 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512DQ) && \
180 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512VL) && \
181 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_PCLMULQDQ) && \
182 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_VPCLMULQDQ) \
183 : : )
184 : :
185 : : static const rte_net_crc_handler *
186 : 0 : avx512_vpclmulqdq_get_handlers(void)
187 : : {
188 : : #ifdef CC_X86_64_AVX512_VPCLMULQDQ_SUPPORT
189 [ # # # # : 0 : if (AVX512_VPCLMULQDQ_CPU_SUPPORTED &&
# # # # #
# # # ]
190 [ # # ]: 0 : max_simd_bitwidth >= RTE_VECT_SIMD_512)
191 : : return handlers_avx512;
192 : : #endif
193 : 0 : NET_LOG(INFO, "Requirements not met, can't use AVX512");
194 : 0 : return NULL;
195 : : }
196 : :
197 : : static void
198 : 252 : avx512_vpclmulqdq_init(void)
199 : : {
200 : : #ifdef CC_X86_64_AVX512_VPCLMULQDQ_SUPPORT
201 [ + - + - : 252 : if (AVX512_VPCLMULQDQ_CPU_SUPPORTED)
+ - + - +
- - + ]
202 : 0 : rte_net_crc_avx512_init();
203 : : #endif
204 : 252 : }
205 : :
206 : : /* SSE4.2/PCLMULQDQ handling */
207 : :
208 : : #define SSE42_PCLMULQDQ_CPU_SUPPORTED \
209 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_PCLMULQDQ)
210 : :
211 : : static const rte_net_crc_handler *
212 : 0 : sse42_pclmulqdq_get_handlers(void)
213 : : {
214 : : #ifdef CC_X86_64_SSE42_PCLMULQDQ_SUPPORT
215 [ # # ]: 0 : if (SSE42_PCLMULQDQ_CPU_SUPPORTED &&
216 [ # # ]: 0 : max_simd_bitwidth >= RTE_VECT_SIMD_128)
217 : : return handlers_sse42;
218 : : #endif
219 : 0 : NET_LOG(INFO, "Requirements not met, can't use SSE");
220 : 0 : return NULL;
221 : : }
222 : :
223 : : static void
224 : 252 : sse42_pclmulqdq_init(void)
225 : : {
226 : : #ifdef CC_X86_64_SSE42_PCLMULQDQ_SUPPORT
227 [ + - ]: 252 : if (SSE42_PCLMULQDQ_CPU_SUPPORTED)
228 : 252 : rte_net_crc_sse42_init();
229 : : #endif
230 : 252 : }
231 : :
232 : : /* NEON/PMULL handling */
233 : :
234 : : #define NEON_PMULL_CPU_SUPPORTED \
235 : : rte_cpu_get_flag_enabled(RTE_CPUFLAG_PMULL)
236 : :
237 : : static const rte_net_crc_handler *
238 : 0 : neon_pmull_get_handlers(void)
239 : : {
240 : : #ifdef CC_ARM64_NEON_PMULL_SUPPORT
241 : : if (NEON_PMULL_CPU_SUPPORTED &&
242 : : max_simd_bitwidth >= RTE_VECT_SIMD_128)
243 : : return handlers_neon;
244 : : #endif
245 : 0 : NET_LOG(INFO, "Requirements not met, can't use NEON");
246 : 0 : return NULL;
247 : : }
248 : :
249 : : static void
250 : : neon_pmull_init(void)
251 : : {
252 : : #ifdef CC_ARM64_NEON_PMULL_SUPPORT
253 : : if (NEON_PMULL_CPU_SUPPORTED)
254 : : rte_net_crc_neon_init();
255 : : #endif
256 : : }
257 : :
258 : : /* Default handling */
259 : :
260 : : static uint32_t
261 : 0 : rte_crc16_ccitt_default_handler(const uint8_t *data, uint32_t data_len)
262 : : {
263 : 0 : handlers = NULL;
264 [ # # ]: 0 : if (max_simd_bitwidth == 0)
265 : 0 : max_simd_bitwidth = rte_vect_get_max_simd_bitwidth();
266 : :
267 : 0 : handlers = avx512_vpclmulqdq_get_handlers();
268 [ # # ]: 0 : if (handlers != NULL)
269 : 0 : return handlers[RTE_NET_CRC16_CCITT](data, data_len);
270 : 0 : handlers = sse42_pclmulqdq_get_handlers();
271 [ # # ]: 0 : if (handlers != NULL)
272 : 0 : return handlers[RTE_NET_CRC16_CCITT](data, data_len);
273 : 0 : handlers = neon_pmull_get_handlers();
274 [ # # ]: 0 : if (handlers != NULL)
275 : 0 : return handlers[RTE_NET_CRC16_CCITT](data, data_len);
276 : 0 : handlers = handlers_scalar;
277 : 0 : return handlers[RTE_NET_CRC16_CCITT](data, data_len);
278 : : }
279 : :
280 : : static uint32_t
281 : 0 : rte_crc32_eth_default_handler(const uint8_t *data, uint32_t data_len)
282 : : {
283 : 0 : handlers = NULL;
284 [ # # ]: 0 : if (max_simd_bitwidth == 0)
285 : 0 : max_simd_bitwidth = rte_vect_get_max_simd_bitwidth();
286 : :
287 : 0 : handlers = avx512_vpclmulqdq_get_handlers();
288 [ # # ]: 0 : if (handlers != NULL)
289 : 0 : return handlers[RTE_NET_CRC32_ETH](data, data_len);
290 : 0 : handlers = sse42_pclmulqdq_get_handlers();
291 [ # # ]: 0 : if (handlers != NULL)
292 : 0 : return handlers[RTE_NET_CRC32_ETH](data, data_len);
293 : 0 : handlers = neon_pmull_get_handlers();
294 [ # # ]: 0 : if (handlers != NULL)
295 : 0 : return handlers[RTE_NET_CRC32_ETH](data, data_len);
296 : 0 : handlers = handlers_scalar;
297 : 0 : return handlers[RTE_NET_CRC32_ETH](data, data_len);
298 : : }
299 : :
300 : : static void
301 : 504 : handlers_init(enum rte_net_crc_alg alg)
302 : : {
303 : 756 : handlers_dpdk26[alg].f[RTE_NET_CRC16_CCITT] = rte_crc16_ccitt_handler;
304 : 756 : handlers_dpdk26[alg].f[RTE_NET_CRC32_ETH] = rte_crc32_eth_handler;
305 : :
306 [ + + - ]: 504 : switch (alg) {
307 : 252 : case RTE_NET_CRC_AVX512:
308 : : #ifdef CC_X86_64_AVX512_VPCLMULQDQ_SUPPORT
309 [ + - + - : 252 : if (AVX512_VPCLMULQDQ_CPU_SUPPORTED) {
+ - + - +
- - + ]
310 : 0 : handlers_dpdk26[alg].f[RTE_NET_CRC16_CCITT] =
311 : : rte_crc16_ccitt_avx512_handler;
312 : 0 : handlers_dpdk26[alg].f[RTE_NET_CRC32_ETH] =
313 : : rte_crc32_eth_avx512_handler;
314 : 0 : break;
315 : : }
316 : : #endif
317 : : /* fall-through */
318 : : case RTE_NET_CRC_SSE42:
319 : : #ifdef CC_X86_64_SSE42_PCLMULQDQ_SUPPORT
320 [ + - ]: 504 : if (SSE42_PCLMULQDQ_CPU_SUPPORTED) {
321 : 504 : handlers_dpdk26[alg].f[RTE_NET_CRC16_CCITT] =
322 : : rte_crc16_ccitt_sse42_handler;
323 : 504 : handlers_dpdk26[alg].f[RTE_NET_CRC32_ETH] =
324 : : rte_crc32_eth_sse42_handler;
325 : : }
326 : : #endif
327 : : break;
328 : : case RTE_NET_CRC_NEON:
329 : : #ifdef CC_ARM64_NEON_PMULL_SUPPORT
330 : : if (NEON_PMULL_CPU_SUPPORTED) {
331 : : handlers_dpdk26[alg].f[RTE_NET_CRC16_CCITT] =
332 : : rte_crc16_ccitt_neon_handler;
333 : : handlers_dpdk26[alg].f[RTE_NET_CRC32_ETH] =
334 : : rte_crc32_eth_neon_handler;
335 : : break;
336 : : }
337 : : #endif
338 : : /* fall-through */
339 : : case RTE_NET_CRC_SCALAR:
340 : : /* fall-through */
341 : : default:
342 : : break;
343 : : }
344 : 504 : }
345 : :
346 : : /* Public API */
347 : :
348 : : void
349 : 0 : rte_net_crc_set_alg_v25(enum rte_net_crc_alg alg)
350 : : {
351 : 0 : handlers = NULL;
352 [ # # ]: 0 : if (max_simd_bitwidth == 0)
353 : 0 : max_simd_bitwidth = rte_vect_get_max_simd_bitwidth();
354 : :
355 [ # # # # ]: 0 : switch (alg) {
356 : 0 : case RTE_NET_CRC_AVX512:
357 : 0 : handlers = avx512_vpclmulqdq_get_handlers();
358 [ # # ]: 0 : if (handlers != NULL)
359 : : break;
360 : : /* fall-through */
361 : : case RTE_NET_CRC_SSE42:
362 : 0 : handlers = sse42_pclmulqdq_get_handlers();
363 : 0 : break; /* for x86, always break here */
364 : 0 : case RTE_NET_CRC_NEON:
365 : 0 : handlers = neon_pmull_get_handlers();
366 : : /* fall-through */
367 : : case RTE_NET_CRC_SCALAR:
368 : : /* fall-through */
369 : : default:
370 : : break;
371 : : }
372 : :
373 [ # # ]: 0 : if (handlers == NULL)
374 : 0 : handlers = handlers_scalar;
375 : 0 : }
376 : : VERSION_SYMBOL(rte_net_crc_set_alg, _v25, 25);
377 : :
378 : 24 : struct rte_net_crc *rte_net_crc_set_alg_v26(enum rte_net_crc_alg alg,
379 : : enum rte_net_crc_type type)
380 : : {
381 : : uint16_t max_simd_bitwidth;
382 : : struct rte_net_crc *crc;
383 : :
384 : 24 : crc = rte_zmalloc(NULL, sizeof(struct rte_net_crc), 0);
385 [ + - ]: 24 : if (crc == NULL)
386 : : return NULL;
387 : 24 : max_simd_bitwidth = rte_vect_get_max_simd_bitwidth();
388 : 24 : crc->type = type;
389 : 24 : crc->alg = RTE_NET_CRC_SCALAR;
390 : :
391 [ + + + + ]: 24 : switch (alg) {
392 : 6 : case RTE_NET_CRC_AVX512:
393 [ - + ]: 6 : if (max_simd_bitwidth >= RTE_VECT_SIMD_512) {
394 : 0 : crc->alg = RTE_NET_CRC_AVX512;
395 : 0 : return crc;
396 : : }
397 : : /* fall-through */
398 : : case RTE_NET_CRC_SSE42:
399 [ + - ]: 12 : if (max_simd_bitwidth >= RTE_VECT_SIMD_128) {
400 : 12 : crc->alg = RTE_NET_CRC_SSE42;
401 : 12 : return crc;
402 : : }
403 : : break;
404 : 6 : case RTE_NET_CRC_NEON:
405 [ + - ]: 6 : if (max_simd_bitwidth >= RTE_VECT_SIMD_128) {
406 : 6 : crc->alg = RTE_NET_CRC_NEON;
407 : 6 : return crc;
408 : : }
409 : : break;
410 : : case RTE_NET_CRC_SCALAR:
411 : : /* fall-through */
412 : : default:
413 : : break;
414 : : }
415 : : return crc;
416 : : }
417 : : BIND_DEFAULT_SYMBOL(rte_net_crc_set_alg, _v26, 26);
418 : : MAP_STATIC_SYMBOL(struct rte_net_crc *rte_net_crc_set_alg(
419 : : enum rte_net_crc_alg alg, enum rte_net_crc_type type),
420 : : rte_net_crc_set_alg_v26);
421 : :
422 : 24 : void rte_net_crc_free(struct rte_net_crc *crc)
423 : : {
424 : 24 : rte_free(crc);
425 : 24 : }
426 : :
427 : : uint32_t
428 : 0 : rte_net_crc_calc_v25(const void *data,
429 : : uint32_t data_len,
430 : : enum rte_net_crc_type type)
431 : : {
432 : : uint32_t ret;
433 : : rte_net_crc_handler f_handle;
434 : :
435 : 0 : f_handle = handlers[type];
436 : 0 : ret = f_handle(data, data_len);
437 : :
438 : 0 : return ret;
439 : : }
440 : : VERSION_SYMBOL(rte_net_crc_calc, _v25, 25);
441 : :
442 : : uint32_t
443 : 24 : rte_net_crc_calc_v26(const struct rte_net_crc *ctx,
444 : : const void *data, const uint32_t data_len)
445 : : {
446 : 24 : return handlers_dpdk26[ctx->alg].f[ctx->type](data, data_len);
447 : : }
448 : : BIND_DEFAULT_SYMBOL(rte_net_crc_calc, _v26, 26);
449 : : MAP_STATIC_SYMBOL(uint32_t rte_net_crc_calc(const struct rte_net_crc *ctx,
450 : : const void *data, const uint32_t data_len),
451 : : rte_net_crc_calc_v26);
452 : :
453 : : /* Call initialisation helpers for all crc algorithm handlers */
454 : 252 : RTE_INIT(rte_net_crc_init)
455 : : {
456 : 252 : rte_net_crc_scalar_init();
457 : 252 : sse42_pclmulqdq_init();
458 : 252 : avx512_vpclmulqdq_init();
459 : : neon_pmull_init();
460 : : handlers_init(RTE_NET_CRC_SCALAR);
461 : : handlers_init(RTE_NET_CRC_NEON);
462 : 252 : handlers_init(RTE_NET_CRC_SSE42);
463 : 252 : handlers_init(RTE_NET_CRC_AVX512);
464 : 252 : }
|
