1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 - 2019 Intel Corporation
3 */
4 #include <string.h>
5 #include <zlib.h>
6 #include <math.h>
7 #include <stdlib.h>
8 #include <unistd.h>
9 #include <stdio.h>
10
11 #include <rte_cycles.h>
12 #include <rte_malloc.h>
13 #include <rte_mempool.h>
14 #include <rte_mbuf.h>
15 #include <rte_compressdev.h>
16 #include <rte_string_fns.h>
17
18 #include "test_compressdev_test_buffer.h"
19 #include "test.h"
20
21 #define DIV_CEIL(a, b) ((a) / (b) + ((a) % (b) != 0))
22
23 #define DEFAULT_WINDOW_SIZE 15
24 #define DEFAULT_MEM_LEVEL 8
25 #define MAX_DEQD_RETRIES 10
26 #define DEQUEUE_WAIT_TIME 10000
27
28 /*
29 * 30% extra size for compressed data compared to original data,
30 * in case data size cannot be reduced and it is actually bigger
31 * due to the compress block headers
32 */
33 #define COMPRESS_BUF_SIZE_RATIO 1.3
34 #define COMPRESS_BUF_SIZE_RATIO_DISABLED 1.0
35 #define COMPRESS_BUF_SIZE_RATIO_OVERFLOW 0.2
36 #define NUM_LARGE_MBUFS 16
37 #define SMALL_SEG_SIZE 256
38 #define MAX_SEGS 16
39 #define NUM_OPS 16
40 #define NUM_MAX_XFORMS 16
41 #define NUM_MAX_INFLIGHT_OPS 128
42 #define CACHE_SIZE 0
43
44 #define ZLIB_CRC_CHECKSUM_WINDOW_BITS 31
45 #define ZLIB_HEADER_SIZE 2
46 #define ZLIB_TRAILER_SIZE 4
47 #define GZIP_HEADER_SIZE 10
48 #define GZIP_TRAILER_SIZE 8
49
50 #define OUT_OF_SPACE_BUF 1
51
52 #define MAX_MBUF_SEGMENT_SIZE 65535
53 #define MAX_DATA_MBUF_SIZE (MAX_MBUF_SEGMENT_SIZE - RTE_PKTMBUF_HEADROOM)
54 #define NUM_BIG_MBUFS (512 + 1)
55 #define BIG_DATA_TEST_SIZE (MAX_DATA_MBUF_SIZE * 2)
56
57 /* constants for "im buffer" tests start here */
58
59 /* number of mbufs lower than number of inflight ops */
60 #define IM_BUF_NUM_MBUFS 3
61 /* above threshold (QAT_FALLBACK_THLD) and below max mbuf size */
62 #define IM_BUF_DATA_TEST_SIZE_LB 59600
63 /* data size smaller than the queue capacity */
64 #define IM_BUF_DATA_TEST_SIZE_SGL (MAX_DATA_MBUF_SIZE * IM_BUF_NUM_MBUFS)
65 /* number of mbufs bigger than number of inflight ops */
66 #define IM_BUF_NUM_MBUFS_OVER (NUM_MAX_INFLIGHT_OPS + 1)
67 /* data size bigger than the queue capacity */
68 #define IM_BUF_DATA_TEST_SIZE_OVER (MAX_DATA_MBUF_SIZE * IM_BUF_NUM_MBUFS_OVER)
69 /* number of mid-size mbufs */
70 #define IM_BUF_NUM_MBUFS_MID ((NUM_MAX_INFLIGHT_OPS / 3) + 1)
71 /* capacity of mid-size mbufs */
72 #define IM_BUF_DATA_TEST_SIZE_MID (MAX_DATA_MBUF_SIZE * IM_BUF_NUM_MBUFS_MID)
73
74
75 const char *
76 huffman_type_strings[] = {
77 [RTE_COMP_HUFFMAN_DEFAULT] = "PMD default",
78 [RTE_COMP_HUFFMAN_FIXED] = "Fixed",
79 [RTE_COMP_HUFFMAN_DYNAMIC] = "Dynamic"
80 };
81
82 enum zlib_direction {
83 ZLIB_NONE,
84 ZLIB_COMPRESS,
85 ZLIB_DECOMPRESS,
86 ZLIB_ALL
87 };
88
89 enum varied_buff {
90 LB_BOTH = 0, /* both input and output are linear*/
91 SGL_BOTH, /* both input and output are chained */
92 SGL_TO_LB, /* input buffer is chained */
93 LB_TO_SGL /* output buffer is chained */
94 };
95
96 enum overflow_test {
97 OVERFLOW_DISABLED,
98 OVERFLOW_ENABLED
99 };
100
101 enum ratio_switch {
102 RATIO_DISABLED,
103 RATIO_ENABLED
104 };
105
106 enum operation_type {
107 OPERATION_COMPRESSION,
108 OPERATION_DECOMPRESSION
109 };
110
111 struct priv_op_data {
112 uint16_t orig_idx;
113 };
114
115 struct comp_testsuite_params {
116 struct rte_mempool *large_mbuf_pool;
117 struct rte_mempool *small_mbuf_pool;
118 struct rte_mempool *big_mbuf_pool;
119 struct rte_mempool *op_pool;
120 struct rte_comp_xform *def_comp_xform;
121 struct rte_comp_xform *def_decomp_xform;
122 };
123
124 struct interim_data_params {
125 const char * const *test_bufs;
126 unsigned int num_bufs;
127 uint16_t *buf_idx;
128 struct rte_comp_xform **compress_xforms;
129 struct rte_comp_xform **decompress_xforms;
130 unsigned int num_xforms;
131 };
132
133 struct test_data_params {
134 enum rte_comp_op_type compress_state;
135 enum rte_comp_op_type decompress_state;
136 enum varied_buff buff_type;
137 enum zlib_direction zlib_dir;
138 unsigned int out_of_space;
139 unsigned int big_data;
140 /* stateful decompression specific parameters */
141 unsigned int decompress_output_block_size;
142 unsigned int decompress_steps_max;
143 /* external mbufs specific parameters */
144 unsigned int use_external_mbufs;
145 unsigned int inbuf_data_size;
146 const struct rte_memzone *inbuf_memzone;
147 const struct rte_memzone *compbuf_memzone;
148 const struct rte_memzone *uncompbuf_memzone;
149 /* overflow test activation */
150 enum overflow_test overflow;
151 enum ratio_switch ratio;
152 };
153
154 struct test_private_arrays {
155 struct rte_mbuf **uncomp_bufs;
156 struct rte_mbuf **comp_bufs;
157 struct rte_comp_op **ops;
158 struct rte_comp_op **ops_processed;
159 void **priv_xforms;
160 uint64_t *compress_checksum;
161 uint32_t *compressed_data_size;
162 void **stream;
163 char **all_decomp_data;
164 unsigned int *decomp_produced_data_size;
165 uint16_t num_priv_xforms;
166 };
167
168 static struct comp_testsuite_params testsuite_params = { 0 };
169
170
171 static void
testsuite_teardown(void)172 testsuite_teardown(void)
173 {
174 struct comp_testsuite_params *ts_params = &testsuite_params;
175
176 if (rte_mempool_in_use_count(ts_params->large_mbuf_pool))
177 RTE_LOG(ERR, USER1, "Large mbuf pool still has unfreed bufs\n");
178 if (rte_mempool_in_use_count(ts_params->small_mbuf_pool))
179 RTE_LOG(ERR, USER1, "Small mbuf pool still has unfreed bufs\n");
180 if (rte_mempool_in_use_count(ts_params->big_mbuf_pool))
181 RTE_LOG(ERR, USER1, "Big mbuf pool still has unfreed bufs\n");
182 if (rte_mempool_in_use_count(ts_params->op_pool))
183 RTE_LOG(ERR, USER1, "op pool still has unfreed ops\n");
184
185 rte_mempool_free(ts_params->large_mbuf_pool);
186 rte_mempool_free(ts_params->small_mbuf_pool);
187 rte_mempool_free(ts_params->big_mbuf_pool);
188 rte_mempool_free(ts_params->op_pool);
189 rte_free(ts_params->def_comp_xform);
190 rte_free(ts_params->def_decomp_xform);
191 }
192
193 static int
testsuite_setup(void)194 testsuite_setup(void)
195 {
196 struct comp_testsuite_params *ts_params = &testsuite_params;
197 uint32_t max_buf_size = 0;
198 unsigned int i;
199
200 if (rte_compressdev_count() == 0) {
201 RTE_LOG(WARNING, USER1, "Need at least one compress device\n");
202 return TEST_SKIPPED;
203 }
204
205 RTE_LOG(NOTICE, USER1, "Running tests on device %s\n",
206 rte_compressdev_name_get(0));
207
208 for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
209 max_buf_size = RTE_MAX(max_buf_size,
210 strlen(compress_test_bufs[i]) + 1);
211
212 /*
213 * Buffers to be used in compression and decompression.
214 * Since decompressed data might be larger than
215 * compressed data (due to block header),
216 * buffers should be big enough for both cases.
217 */
218 max_buf_size *= COMPRESS_BUF_SIZE_RATIO;
219 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create("large_mbuf_pool",
220 NUM_LARGE_MBUFS,
221 CACHE_SIZE, 0,
222 max_buf_size + RTE_PKTMBUF_HEADROOM,
223 rte_socket_id());
224 if (ts_params->large_mbuf_pool == NULL) {
225 RTE_LOG(ERR, USER1, "Large mbuf pool could not be created\n");
226 return TEST_FAILED;
227 }
228
229 /* Create mempool with smaller buffers for SGL testing */
230 ts_params->small_mbuf_pool = rte_pktmbuf_pool_create("small_mbuf_pool",
231 NUM_LARGE_MBUFS * MAX_SEGS,
232 CACHE_SIZE, 0,
233 SMALL_SEG_SIZE + RTE_PKTMBUF_HEADROOM,
234 rte_socket_id());
235 if (ts_params->small_mbuf_pool == NULL) {
236 RTE_LOG(ERR, USER1, "Small mbuf pool could not be created\n");
237 goto exit;
238 }
239
240 /* Create mempool with big buffers for SGL testing */
241 ts_params->big_mbuf_pool = rte_pktmbuf_pool_create("big_mbuf_pool",
242 NUM_BIG_MBUFS + 1,
243 CACHE_SIZE, 0,
244 MAX_MBUF_SEGMENT_SIZE,
245 rte_socket_id());
246 if (ts_params->big_mbuf_pool == NULL) {
247 RTE_LOG(ERR, USER1, "Big mbuf pool could not be created\n");
248 goto exit;
249 }
250
251 ts_params->op_pool = rte_comp_op_pool_create("op_pool", NUM_OPS,
252 0, sizeof(struct priv_op_data),
253 rte_socket_id());
254 if (ts_params->op_pool == NULL) {
255 RTE_LOG(ERR, USER1, "Operation pool could not be created\n");
256 goto exit;
257 }
258
259 ts_params->def_comp_xform =
260 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
261 if (ts_params->def_comp_xform == NULL) {
262 RTE_LOG(ERR, USER1,
263 "Default compress xform could not be created\n");
264 goto exit;
265 }
266 ts_params->def_decomp_xform =
267 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
268 if (ts_params->def_decomp_xform == NULL) {
269 RTE_LOG(ERR, USER1,
270 "Default decompress xform could not be created\n");
271 goto exit;
272 }
273
274 /* Initializes default values for compress/decompress xforms */
275 ts_params->def_comp_xform->type = RTE_COMP_COMPRESS;
276 ts_params->def_comp_xform->compress.algo = RTE_COMP_ALGO_DEFLATE,
277 ts_params->def_comp_xform->compress.deflate.huffman =
278 RTE_COMP_HUFFMAN_DEFAULT;
279 ts_params->def_comp_xform->compress.level = RTE_COMP_LEVEL_PMD_DEFAULT;
280 ts_params->def_comp_xform->compress.chksum = RTE_COMP_CHECKSUM_NONE;
281 ts_params->def_comp_xform->compress.window_size = DEFAULT_WINDOW_SIZE;
282
283 ts_params->def_decomp_xform->type = RTE_COMP_DECOMPRESS;
284 ts_params->def_decomp_xform->decompress.algo = RTE_COMP_ALGO_DEFLATE,
285 ts_params->def_decomp_xform->decompress.chksum = RTE_COMP_CHECKSUM_NONE;
286 ts_params->def_decomp_xform->decompress.window_size = DEFAULT_WINDOW_SIZE;
287
288 return TEST_SUCCESS;
289
290 exit:
291 testsuite_teardown();
292
293 return TEST_FAILED;
294 }
295
296 static int
generic_ut_setup(void)297 generic_ut_setup(void)
298 {
299 /* Configure compressdev (one device, one queue pair) */
300 struct rte_compressdev_config config = {
301 .socket_id = rte_socket_id(),
302 .nb_queue_pairs = 1,
303 .max_nb_priv_xforms = NUM_MAX_XFORMS,
304 .max_nb_streams = 1
305 };
306
307 if (rte_compressdev_configure(0, &config) < 0) {
308 RTE_LOG(ERR, USER1, "Device configuration failed\n");
309 return -1;
310 }
311
312 if (rte_compressdev_queue_pair_setup(0, 0, NUM_MAX_INFLIGHT_OPS,
313 rte_socket_id()) < 0) {
314 RTE_LOG(ERR, USER1, "Queue pair setup failed\n");
315 return -1;
316 }
317
318 if (rte_compressdev_start(0) < 0) {
319 RTE_LOG(ERR, USER1, "Device could not be started\n");
320 return -1;
321 }
322
323 return 0;
324 }
325
326 static void
generic_ut_teardown(void)327 generic_ut_teardown(void)
328 {
329 rte_compressdev_stop(0);
330 if (rte_compressdev_close(0) < 0)
331 RTE_LOG(ERR, USER1, "Device could not be closed\n");
332 }
333
334 static int
test_compressdev_invalid_configuration(void)335 test_compressdev_invalid_configuration(void)
336 {
337 struct rte_compressdev_config invalid_config;
338 struct rte_compressdev_config valid_config = {
339 .socket_id = rte_socket_id(),
340 .nb_queue_pairs = 1,
341 .max_nb_priv_xforms = NUM_MAX_XFORMS,
342 .max_nb_streams = 1
343 };
344 struct rte_compressdev_info dev_info;
345
346 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
347
348 /* Invalid configuration with 0 queue pairs */
349 memcpy(&invalid_config, &valid_config,
350 sizeof(struct rte_compressdev_config));
351 invalid_config.nb_queue_pairs = 0;
352
353 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
354 "Device configuration was successful "
355 "with no queue pairs (invalid)\n");
356
357 /*
358 * Invalid configuration with too many queue pairs
359 * (if there is an actual maximum number of queue pairs)
360 */
361 rte_compressdev_info_get(0, &dev_info);
362 if (dev_info.max_nb_queue_pairs != 0) {
363 memcpy(&invalid_config, &valid_config,
364 sizeof(struct rte_compressdev_config));
365 invalid_config.nb_queue_pairs = dev_info.max_nb_queue_pairs + 1;
366
367 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
368 "Device configuration was successful "
369 "with too many queue pairs (invalid)\n");
370 }
371
372 /* Invalid queue pair setup, with no number of queue pairs set */
373 TEST_ASSERT_FAIL(rte_compressdev_queue_pair_setup(0, 0,
374 NUM_MAX_INFLIGHT_OPS, rte_socket_id()),
375 "Queue pair setup was successful "
376 "with no queue pairs set (invalid)\n");
377
378 return TEST_SUCCESS;
379 }
380
381 static int
compare_buffers(const char * buffer1,uint32_t buffer1_len,const char * buffer2,uint32_t buffer2_len)382 compare_buffers(const char *buffer1, uint32_t buffer1_len,
383 const char *buffer2, uint32_t buffer2_len)
384 {
385 if (buffer1_len != buffer2_len) {
386 RTE_LOG(ERR, USER1, "Buffer lengths are different\n");
387 return -1;
388 }
389
390 if (memcmp(buffer1, buffer2, buffer1_len) != 0) {
391 RTE_LOG(ERR, USER1, "Buffers are different\n");
392 return -1;
393 }
394
395 return 0;
396 }
397
398 /*
399 * Maps compressdev and Zlib flush flags
400 */
401 static int
map_zlib_flush_flag(enum rte_comp_flush_flag flag)402 map_zlib_flush_flag(enum rte_comp_flush_flag flag)
403 {
404 switch (flag) {
405 case RTE_COMP_FLUSH_NONE:
406 return Z_NO_FLUSH;
407 case RTE_COMP_FLUSH_SYNC:
408 return Z_SYNC_FLUSH;
409 case RTE_COMP_FLUSH_FULL:
410 return Z_FULL_FLUSH;
411 case RTE_COMP_FLUSH_FINAL:
412 return Z_FINISH;
413 /*
414 * There should be only the values above,
415 * so this should never happen
416 */
417 default:
418 return -1;
419 }
420 }
421
422 static int
compress_zlib(struct rte_comp_op * op,const struct rte_comp_xform * xform,int mem_level)423 compress_zlib(struct rte_comp_op *op,
424 const struct rte_comp_xform *xform, int mem_level)
425 {
426 z_stream stream;
427 int zlib_flush;
428 int strategy, window_bits, comp_level;
429 int ret = TEST_FAILED;
430 uint8_t *single_src_buf = NULL;
431 uint8_t *single_dst_buf = NULL;
432
433 /* initialize zlib stream */
434 stream.zalloc = Z_NULL;
435 stream.zfree = Z_NULL;
436 stream.opaque = Z_NULL;
437
438 if (xform->compress.deflate.huffman == RTE_COMP_HUFFMAN_FIXED)
439 strategy = Z_FIXED;
440 else
441 strategy = Z_DEFAULT_STRATEGY;
442
443 /*
444 * Window bits is the base two logarithm of the window size (in bytes).
445 * When doing raw DEFLATE, this number will be negative.
446 */
447 window_bits = -(xform->compress.window_size);
448 if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32)
449 window_bits *= -1;
450 else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32)
451 window_bits = ZLIB_CRC_CHECKSUM_WINDOW_BITS;
452
453 comp_level = xform->compress.level;
454
455 if (comp_level != RTE_COMP_LEVEL_NONE)
456 ret = deflateInit2(&stream, comp_level, Z_DEFLATED,
457 window_bits, mem_level, strategy);
458 else
459 ret = deflateInit(&stream, Z_NO_COMPRESSION);
460
461 if (ret != Z_OK) {
462 printf("Zlib deflate could not be initialized\n");
463 goto exit;
464 }
465
466 /* Assuming stateless operation */
467 /* SGL Input */
468 if (op->m_src->nb_segs > 1) {
469 single_src_buf = rte_malloc(NULL,
470 rte_pktmbuf_pkt_len(op->m_src), 0);
471 if (single_src_buf == NULL) {
472 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
473 goto exit;
474 }
475
476 if (rte_pktmbuf_read(op->m_src, op->src.offset,
477 rte_pktmbuf_pkt_len(op->m_src) -
478 op->src.offset,
479 single_src_buf) == NULL) {
480 RTE_LOG(ERR, USER1,
481 "Buffer could not be read entirely\n");
482 goto exit;
483 }
484
485 stream.avail_in = op->src.length;
486 stream.next_in = single_src_buf;
487
488 } else {
489 stream.avail_in = op->src.length;
490 stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *,
491 op->src.offset);
492 }
493 /* SGL output */
494 if (op->m_dst->nb_segs > 1) {
495
496 single_dst_buf = rte_malloc(NULL,
497 rte_pktmbuf_pkt_len(op->m_dst), 0);
498 if (single_dst_buf == NULL) {
499 RTE_LOG(ERR, USER1,
500 "Buffer could not be allocated\n");
501 goto exit;
502 }
503
504 stream.avail_out = op->m_dst->pkt_len;
505 stream.next_out = single_dst_buf;
506
507 } else {/* linear output */
508 stream.avail_out = op->m_dst->data_len;
509 stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *,
510 op->dst.offset);
511 }
512
513 /* Stateless operation, all buffer will be compressed in one go */
514 zlib_flush = map_zlib_flush_flag(op->flush_flag);
515 ret = deflate(&stream, zlib_flush);
516
517 if (stream.avail_in != 0) {
518 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n");
519 goto exit;
520 }
521
522 if (ret != Z_STREAM_END)
523 goto exit;
524
525 /* Copy data to destination SGL */
526 if (op->m_dst->nb_segs > 1) {
527 uint32_t remaining_data = stream.total_out;
528 uint8_t *src_data = single_dst_buf;
529 struct rte_mbuf *dst_buf = op->m_dst;
530
531 while (remaining_data > 0) {
532 uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf,
533 uint8_t *, op->dst.offset);
534 /* Last segment */
535 if (remaining_data < dst_buf->data_len) {
536 memcpy(dst_data, src_data, remaining_data);
537 remaining_data = 0;
538 } else {
539 memcpy(dst_data, src_data, dst_buf->data_len);
540 remaining_data -= dst_buf->data_len;
541 src_data += dst_buf->data_len;
542 dst_buf = dst_buf->next;
543 }
544 }
545 }
546
547 op->consumed = stream.total_in;
548 if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) {
549 rte_pktmbuf_adj(op->m_dst, ZLIB_HEADER_SIZE);
550 rte_pktmbuf_trim(op->m_dst, ZLIB_TRAILER_SIZE);
551 op->produced = stream.total_out - (ZLIB_HEADER_SIZE +
552 ZLIB_TRAILER_SIZE);
553 } else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) {
554 rte_pktmbuf_adj(op->m_dst, GZIP_HEADER_SIZE);
555 rte_pktmbuf_trim(op->m_dst, GZIP_TRAILER_SIZE);
556 op->produced = stream.total_out - (GZIP_HEADER_SIZE +
557 GZIP_TRAILER_SIZE);
558 } else
559 op->produced = stream.total_out;
560
561 op->status = RTE_COMP_OP_STATUS_SUCCESS;
562 op->output_chksum = stream.adler;
563
564 deflateReset(&stream);
565
566 ret = 0;
567 exit:
568 deflateEnd(&stream);
569 rte_free(single_src_buf);
570 rte_free(single_dst_buf);
571
572 return ret;
573 }
574
575 static int
decompress_zlib(struct rte_comp_op * op,const struct rte_comp_xform * xform)576 decompress_zlib(struct rte_comp_op *op,
577 const struct rte_comp_xform *xform)
578 {
579 z_stream stream;
580 int window_bits;
581 int zlib_flush;
582 int ret = TEST_FAILED;
583 uint8_t *single_src_buf = NULL;
584 uint8_t *single_dst_buf = NULL;
585
586 /* initialize zlib stream */
587 stream.zalloc = Z_NULL;
588 stream.zfree = Z_NULL;
589 stream.opaque = Z_NULL;
590
591 /*
592 * Window bits is the base two logarithm of the window size (in bytes).
593 * When doing raw DEFLATE, this number will be negative.
594 */
595 window_bits = -(xform->decompress.window_size);
596 ret = inflateInit2(&stream, window_bits);
597
598 if (ret != Z_OK) {
599 printf("Zlib deflate could not be initialized\n");
600 goto exit;
601 }
602
603 /* Assuming stateless operation */
604 /* SGL */
605 if (op->m_src->nb_segs > 1) {
606 single_src_buf = rte_malloc(NULL,
607 rte_pktmbuf_pkt_len(op->m_src), 0);
608 if (single_src_buf == NULL) {
609 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
610 goto exit;
611 }
612 single_dst_buf = rte_malloc(NULL,
613 rte_pktmbuf_pkt_len(op->m_dst), 0);
614 if (single_dst_buf == NULL) {
615 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
616 goto exit;
617 }
618 if (rte_pktmbuf_read(op->m_src, 0,
619 rte_pktmbuf_pkt_len(op->m_src),
620 single_src_buf) == NULL) {
621 RTE_LOG(ERR, USER1,
622 "Buffer could not be read entirely\n");
623 goto exit;
624 }
625
626 stream.avail_in = op->src.length;
627 stream.next_in = single_src_buf;
628 stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst);
629 stream.next_out = single_dst_buf;
630
631 } else {
632 stream.avail_in = op->src.length;
633 stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
634 stream.avail_out = op->m_dst->data_len;
635 stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
636 }
637
638 /* Stateless operation, all buffer will be compressed in one go */
639 zlib_flush = map_zlib_flush_flag(op->flush_flag);
640 ret = inflate(&stream, zlib_flush);
641
642 if (stream.avail_in != 0) {
643 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n");
644 goto exit;
645 }
646
647 if (ret != Z_STREAM_END)
648 goto exit;
649
650 if (op->m_src->nb_segs > 1) {
651 uint32_t remaining_data = stream.total_out;
652 uint8_t *src_data = single_dst_buf;
653 struct rte_mbuf *dst_buf = op->m_dst;
654
655 while (remaining_data > 0) {
656 uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf,
657 uint8_t *);
658 /* Last segment */
659 if (remaining_data < dst_buf->data_len) {
660 memcpy(dst_data, src_data, remaining_data);
661 remaining_data = 0;
662 } else {
663 memcpy(dst_data, src_data, dst_buf->data_len);
664 remaining_data -= dst_buf->data_len;
665 src_data += dst_buf->data_len;
666 dst_buf = dst_buf->next;
667 }
668 }
669 }
670
671 op->consumed = stream.total_in;
672 op->produced = stream.total_out;
673 op->status = RTE_COMP_OP_STATUS_SUCCESS;
674
675 inflateReset(&stream);
676
677 ret = 0;
678 exit:
679 inflateEnd(&stream);
680
681 return ret;
682 }
683
684 static int
prepare_sgl_bufs(const char * test_buf,struct rte_mbuf * head_buf,uint32_t total_data_size,struct rte_mempool * small_mbuf_pool,struct rte_mempool * large_mbuf_pool,uint8_t limit_segs_in_sgl,uint16_t seg_size)685 prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
686 uint32_t total_data_size,
687 struct rte_mempool *small_mbuf_pool,
688 struct rte_mempool *large_mbuf_pool,
689 uint8_t limit_segs_in_sgl,
690 uint16_t seg_size)
691 {
692 uint32_t remaining_data = total_data_size;
693 uint16_t num_remaining_segs = DIV_CEIL(remaining_data, seg_size);
694 struct rte_mempool *pool;
695 struct rte_mbuf *next_seg;
696 uint32_t data_size;
697 char *buf_ptr;
698 const char *data_ptr = test_buf;
699 uint16_t i;
700 int ret;
701
702 if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl)
703 num_remaining_segs = limit_segs_in_sgl - 1;
704
705 /*
706 * Allocate data in the first segment (header) and
707 * copy data if test buffer is provided
708 */
709 if (remaining_data < seg_size)
710 data_size = remaining_data;
711 else
712 data_size = seg_size;
713
714 buf_ptr = rte_pktmbuf_append(head_buf, data_size);
715 if (buf_ptr == NULL) {
716 RTE_LOG(ERR, USER1,
717 "Not enough space in the 1st buffer\n");
718 return -1;
719 }
720
721 if (data_ptr != NULL) {
722 /* Copy characters without NULL terminator */
723 memcpy(buf_ptr, data_ptr, data_size);
724 data_ptr += data_size;
725 }
726 remaining_data -= data_size;
727 num_remaining_segs--;
728
729 /*
730 * Allocate the rest of the segments,
731 * copy the rest of the data and chain the segments.
732 */
733 for (i = 0; i < num_remaining_segs; i++) {
734
735 if (i == (num_remaining_segs - 1)) {
736 /* last segment */
737 if (remaining_data > seg_size)
738 pool = large_mbuf_pool;
739 else
740 pool = small_mbuf_pool;
741 data_size = remaining_data;
742 } else {
743 data_size = seg_size;
744 pool = small_mbuf_pool;
745 }
746
747 next_seg = rte_pktmbuf_alloc(pool);
748 if (next_seg == NULL) {
749 RTE_LOG(ERR, USER1,
750 "New segment could not be allocated "
751 "from the mempool\n");
752 return -1;
753 }
754 buf_ptr = rte_pktmbuf_append(next_seg, data_size);
755 if (buf_ptr == NULL) {
756 RTE_LOG(ERR, USER1,
757 "Not enough space in the buffer\n");
758 rte_pktmbuf_free(next_seg);
759 return -1;
760 }
761 if (data_ptr != NULL) {
762 /* Copy characters without NULL terminator */
763 memcpy(buf_ptr, data_ptr, data_size);
764 data_ptr += data_size;
765 }
766 remaining_data -= data_size;
767
768 ret = rte_pktmbuf_chain(head_buf, next_seg);
769 if (ret != 0) {
770 rte_pktmbuf_free(next_seg);
771 RTE_LOG(ERR, USER1,
772 "Segment could not chained\n");
773 return -1;
774 }
775 }
776
777 return 0;
778 }
779
780 static void
extbuf_free_callback(void * addr __rte_unused,void * opaque __rte_unused)781 extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
782 {
783 }
784
785 static int
test_run_enqueue_dequeue(struct rte_comp_op ** ops,struct rte_comp_op ** ops_processed,unsigned int num_bufs)786 test_run_enqueue_dequeue(struct rte_comp_op **ops,
787 struct rte_comp_op **ops_processed,
788 unsigned int num_bufs)
789 {
790 uint16_t num_enqd, num_deqd, num_total_deqd;
791 unsigned int deqd_retries = 0;
792 int res = 0;
793
794 /* Enqueue and dequeue all operations */
795 num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
796 if (num_enqd < num_bufs) {
797 RTE_LOG(ERR, USER1,
798 "Some operations could not be enqueued\n");
799 res = -1;
800 }
801
802 /* dequeue ops even on error (same number of ops as was enqueued) */
803
804 num_total_deqd = 0;
805 while (num_total_deqd < num_enqd) {
806 /*
807 * If retrying a dequeue call, wait for 10 ms to allow
808 * enough time to the driver to process the operations
809 */
810 if (deqd_retries != 0) {
811 /*
812 * Avoid infinite loop if not all the
813 * operations get out of the device
814 */
815 if (deqd_retries == MAX_DEQD_RETRIES) {
816 RTE_LOG(ERR, USER1,
817 "Not all operations could be dequeued\n");
818 res = -1;
819 break;
820 }
821 usleep(DEQUEUE_WAIT_TIME);
822 }
823 num_deqd = rte_compressdev_dequeue_burst(0, 0,
824 &ops_processed[num_total_deqd], num_bufs);
825 num_total_deqd += num_deqd;
826 deqd_retries++;
827
828 }
829
830 return res;
831 }
832
833 /**
834 * Arrays initialization. Input buffers preparation for compression.
835 *
836 * API that initializes all the private arrays to NULL
837 * and allocates input buffers to perform compression operations.
838 *
839 * @param int_data
840 * Interim data containing session/transformation objects.
841 * @param test_data
842 * The test parameters set by users (command line parameters).
843 * @param test_priv_data
844 * A container used for aggregation all the private test arrays.
845 * @return
846 * - 0: On success.
847 * - -1: On error.
848 */
849 static int
test_setup_com_bufs(const struct interim_data_params * int_data,const struct test_data_params * test_data,const struct test_private_arrays * test_priv_data)850 test_setup_com_bufs(const struct interim_data_params *int_data,
851 const struct test_data_params *test_data,
852 const struct test_private_arrays *test_priv_data)
853 {
854 /* local variables: */
855 unsigned int i;
856 uint32_t data_size;
857 char *buf_ptr;
858 int ret;
859 char **all_decomp_data = test_priv_data->all_decomp_data;
860
861 struct comp_testsuite_params *ts_params = &testsuite_params;
862
863 /* from int_data: */
864 const char * const *test_bufs = int_data->test_bufs;
865 unsigned int num_bufs = int_data->num_bufs;
866
867 /* from test_data: */
868 unsigned int buff_type = test_data->buff_type;
869 unsigned int big_data = test_data->big_data;
870
871 /* from test_priv_data: */
872 struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
873 struct rte_mempool *buf_pool;
874
875 static struct rte_mbuf_ext_shared_info inbuf_info;
876
877 size_t array_size = sizeof(void *) * num_bufs;
878
879 /* Initialize all arrays to NULL */
880 memset(test_priv_data->uncomp_bufs, 0, array_size);
881 memset(test_priv_data->comp_bufs, 0, array_size);
882 memset(test_priv_data->ops, 0, array_size);
883 memset(test_priv_data->ops_processed, 0, array_size);
884 memset(test_priv_data->priv_xforms, 0, array_size);
885 memset(test_priv_data->compressed_data_size,
886 0, sizeof(uint32_t) * num_bufs);
887
888 if (test_data->decompress_state == RTE_COMP_OP_STATEFUL) {
889 data_size = strlen(test_bufs[0]) + 1;
890 *all_decomp_data = rte_malloc(NULL, data_size,
891 RTE_CACHE_LINE_SIZE);
892 }
893
894 if (big_data)
895 buf_pool = ts_params->big_mbuf_pool;
896 else if (buff_type == SGL_BOTH)
897 buf_pool = ts_params->small_mbuf_pool;
898 else
899 buf_pool = ts_params->large_mbuf_pool;
900
901 /* for compression uncomp_bufs is used as a source buffer */
902 /* allocation from buf_pool (mempool type) */
903 ret = rte_pktmbuf_alloc_bulk(buf_pool,
904 uncomp_bufs, num_bufs);
905 if (ret < 0) {
906 RTE_LOG(ERR, USER1,
907 "Source mbufs could not be allocated "
908 "from the mempool\n");
909 return -1;
910 }
911
912 if (test_data->use_external_mbufs) {
913 inbuf_info.free_cb = extbuf_free_callback;
914 inbuf_info.fcb_opaque = NULL;
915 rte_mbuf_ext_refcnt_set(&inbuf_info, 1);
916 for (i = 0; i < num_bufs; i++) {
917 rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
918 test_data->inbuf_memzone->addr,
919 test_data->inbuf_memzone->iova,
920 test_data->inbuf_data_size,
921 &inbuf_info);
922 buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
923 test_data->inbuf_data_size);
924 if (buf_ptr == NULL) {
925 RTE_LOG(ERR, USER1,
926 "Append extra bytes to the source mbuf failed\n");
927 return -1;
928 }
929 }
930 } else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
931 for (i = 0; i < num_bufs; i++) {
932 data_size = strlen(test_bufs[i]) + 1;
933 if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i],
934 data_size,
935 big_data ? buf_pool : ts_params->small_mbuf_pool,
936 big_data ? buf_pool : ts_params->large_mbuf_pool,
937 big_data ? 0 : MAX_SEGS,
938 big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
939 return -1;
940 }
941 } else {
942 for (i = 0; i < num_bufs; i++) {
943 data_size = strlen(test_bufs[i]) + 1;
944
945 buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
946 if (buf_ptr == NULL) {
947 RTE_LOG(ERR, USER1,
948 "Append extra bytes to the source mbuf failed\n");
949 return -1;
950 }
951 strlcpy(buf_ptr, test_bufs[i], data_size);
952 }
953 }
954
955 return 0;
956 }
957
958 /**
959 * Data size calculation (for both compression and decompression).
960 *
961 * Calculate size of anticipated output buffer required for both
962 * compression and decompression operations based on input int_data.
963 *
964 * @param op_type
965 * Operation type: compress or decompress
966 * @param out_of_space_and_zlib
967 * Boolean value to switch into "out of space" buffer if set.
968 * To test "out-of-space" data size, zlib_decompress must be set as well.
969 * @param test_priv_data
970 * A container used for aggregation all the private test arrays.
971 * @param int_data
972 * Interim data containing session/transformation objects.
973 * @param test_data
974 * The test parameters set by users (command line parameters).
975 * @param i
976 * current buffer index
977 * @return
978 * data size
979 */
980 static inline uint32_t
test_mbufs_calculate_data_size(enum operation_type op_type,unsigned int out_of_space_and_zlib,const struct test_private_arrays * test_priv_data,const struct interim_data_params * int_data,const struct test_data_params * test_data,unsigned int i)981 test_mbufs_calculate_data_size(
982 enum operation_type op_type,
983 unsigned int out_of_space_and_zlib,
984 const struct test_private_arrays *test_priv_data,
985 const struct interim_data_params *int_data,
986 const struct test_data_params *test_data,
987 unsigned int i)
988 {
989 /* local variables: */
990 uint32_t data_size;
991 struct priv_op_data *priv_data;
992 float ratio_val;
993 enum ratio_switch ratio = test_data->ratio;
994
995 uint8_t not_zlib_compr; /* true if zlib isn't current compression dev */
996 enum overflow_test overflow = test_data->overflow;
997
998 /* from test_priv_data: */
999 struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1000
1001 /* from int_data: */
1002 const char * const *test_bufs = int_data->test_bufs;
1003
1004 if (out_of_space_and_zlib)
1005 data_size = OUT_OF_SPACE_BUF;
1006 else {
1007 if (op_type == OPERATION_COMPRESSION) {
1008 not_zlib_compr = (test_data->zlib_dir == ZLIB_DECOMPRESS
1009 || test_data->zlib_dir == ZLIB_NONE);
1010
1011 ratio_val = (ratio == RATIO_ENABLED) ?
1012 COMPRESS_BUF_SIZE_RATIO :
1013 COMPRESS_BUF_SIZE_RATIO_DISABLED;
1014
1015 ratio_val = (not_zlib_compr &&
1016 (overflow == OVERFLOW_ENABLED)) ?
1017 COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
1018 ratio_val;
1019
1020 data_size = strlen(test_bufs[i]) * ratio_val;
1021 } else {
1022 priv_data = (struct priv_op_data *)
1023 (ops_processed[i] + 1);
1024 data_size = strlen(test_bufs[priv_data->orig_idx]) + 1;
1025 }
1026 }
1027
1028 return data_size;
1029 }
1030
1031
1032 /**
1033 * Memory buffers preparation (for both compression and decompression).
1034 *
1035 * Function allocates output buffers to perform compression
1036 * or decompression operations depending on value of op_type.
1037 *
1038 * @param op_type
1039 * Operation type: compress or decompress
1040 * @param out_of_space_and_zlib
1041 * Boolean value to switch into "out of space" buffer if set.
1042 * To test "out-of-space" data size, zlib_decompress must be set as well.
1043 * @param test_priv_data
1044 * A container used for aggregation all the private test arrays.
1045 * @param int_data
1046 * Interim data containing session/transformation objects.
1047 * @param test_data
1048 * The test parameters set by users (command line parameters).
1049 * @param current_extbuf_info,
1050 * The structure containing all the information related to external mbufs
1051 * @return
1052 * - 0: On success.
1053 * - -1: On error.
1054 */
1055 static int
test_setup_output_bufs(enum operation_type op_type,unsigned int out_of_space_and_zlib,const struct test_private_arrays * test_priv_data,const struct interim_data_params * int_data,const struct test_data_params * test_data,struct rte_mbuf_ext_shared_info * current_extbuf_info)1056 test_setup_output_bufs(
1057 enum operation_type op_type,
1058 unsigned int out_of_space_and_zlib,
1059 const struct test_private_arrays *test_priv_data,
1060 const struct interim_data_params *int_data,
1061 const struct test_data_params *test_data,
1062 struct rte_mbuf_ext_shared_info *current_extbuf_info)
1063 {
1064 /* local variables: */
1065 unsigned int i;
1066 uint32_t data_size;
1067 int ret;
1068 char *buf_ptr;
1069
1070 /* from test_priv_data: */
1071 struct rte_mbuf **current_bufs;
1072
1073 /* from int_data: */
1074 unsigned int num_bufs = int_data->num_bufs;
1075
1076 /* from test_data: */
1077 unsigned int buff_type = test_data->buff_type;
1078 unsigned int big_data = test_data->big_data;
1079 const struct rte_memzone *current_memzone;
1080
1081 struct comp_testsuite_params *ts_params = &testsuite_params;
1082 struct rte_mempool *buf_pool;
1083
1084 if (big_data)
1085 buf_pool = ts_params->big_mbuf_pool;
1086 else if (buff_type == SGL_BOTH)
1087 buf_pool = ts_params->small_mbuf_pool;
1088 else
1089 buf_pool = ts_params->large_mbuf_pool;
1090
1091 if (op_type == OPERATION_COMPRESSION)
1092 current_bufs = test_priv_data->comp_bufs;
1093 else
1094 current_bufs = test_priv_data->uncomp_bufs;
1095
1096 /* the mbufs allocation*/
1097 ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
1098 if (ret < 0) {
1099 RTE_LOG(ERR, USER1,
1100 "Destination mbufs could not be allocated "
1101 "from the mempool\n");
1102 return -1;
1103 }
1104
1105 if (test_data->use_external_mbufs) {
1106 current_extbuf_info->free_cb = extbuf_free_callback;
1107 current_extbuf_info->fcb_opaque = NULL;
1108 rte_mbuf_ext_refcnt_set(current_extbuf_info, 1);
1109 if (op_type == OPERATION_COMPRESSION)
1110 current_memzone = test_data->compbuf_memzone;
1111 else
1112 current_memzone = test_data->uncompbuf_memzone;
1113
1114 for (i = 0; i < num_bufs; i++) {
1115 rte_pktmbuf_attach_extbuf(current_bufs[i],
1116 current_memzone->addr,
1117 current_memzone->iova,
1118 current_memzone->len,
1119 current_extbuf_info);
1120 rte_pktmbuf_append(current_bufs[i],
1121 current_memzone->len);
1122 }
1123 } else {
1124 for (i = 0; i < num_bufs; i++) {
1125
1126 enum rte_comp_huffman comp_huffman =
1127 ts_params->def_comp_xform->compress.deflate.huffman;
1128
1129 /* data size calculation */
1130 data_size = test_mbufs_calculate_data_size(
1131 op_type,
1132 out_of_space_and_zlib,
1133 test_priv_data,
1134 int_data,
1135 test_data,
1136 i);
1137
1138 if (comp_huffman != RTE_COMP_HUFFMAN_DYNAMIC) {
1139 if (op_type == OPERATION_DECOMPRESSION)
1140 data_size *= COMPRESS_BUF_SIZE_RATIO;
1141 }
1142
1143 /* data allocation */
1144 if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
1145 ret = prepare_sgl_bufs(NULL, current_bufs[i],
1146 data_size,
1147 big_data ? buf_pool :
1148 ts_params->small_mbuf_pool,
1149 big_data ? buf_pool :
1150 ts_params->large_mbuf_pool,
1151 big_data ? 0 : MAX_SEGS,
1152 big_data ? MAX_DATA_MBUF_SIZE :
1153 SMALL_SEG_SIZE);
1154 if (ret < 0)
1155 return -1;
1156 } else {
1157 buf_ptr = rte_pktmbuf_append(current_bufs[i],
1158 data_size);
1159 if (buf_ptr == NULL) {
1160 RTE_LOG(ERR, USER1,
1161 "Append extra bytes to the destination mbuf failed\n");
1162 return -1;
1163 }
1164 }
1165 }
1166 }
1167
1168 return 0;
1169 }
1170
1171 /**
1172 * The main compression function.
1173 *
1174 * Function performs compression operation.
1175 * Operation(s) configuration, depending on CLI parameters.
1176 * Operation(s) processing.
1177 *
1178 * @param int_data
1179 * Interim data containing session/transformation objects.
1180 * @param test_data
1181 * The test parameters set by users (command line parameters).
1182 * @param test_priv_data
1183 * A container used for aggregation all the private test arrays.
1184 * @return
1185 * - 0: On success.
1186 * - -1: On error.
1187 */
1188 static int
test_deflate_comp_run(const struct interim_data_params * int_data,const struct test_data_params * test_data,const struct test_private_arrays * test_priv_data)1189 test_deflate_comp_run(const struct interim_data_params *int_data,
1190 const struct test_data_params *test_data,
1191 const struct test_private_arrays *test_priv_data)
1192 {
1193 /* local variables: */
1194 struct priv_op_data *priv_data;
1195 unsigned int i;
1196 uint16_t num_priv_xforms = 0;
1197 int ret;
1198 int ret_status = 0;
1199 char *buf_ptr;
1200
1201 struct comp_testsuite_params *ts_params = &testsuite_params;
1202
1203 /* from test_data: */
1204 enum rte_comp_op_type operation_type = test_data->compress_state;
1205 unsigned int zlib_compress =
1206 (test_data->zlib_dir == ZLIB_ALL ||
1207 test_data->zlib_dir == ZLIB_COMPRESS);
1208
1209 /* from int_data: */
1210 struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1211 unsigned int num_xforms = int_data->num_xforms;
1212 unsigned int num_bufs = int_data->num_bufs;
1213
1214 /* from test_priv_data: */
1215 struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1216 struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1217 struct rte_comp_op **ops = test_priv_data->ops;
1218 struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1219 void **priv_xforms = test_priv_data->priv_xforms;
1220
1221 const struct rte_compressdev_capabilities *capa =
1222 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
1223
1224 /* Build the compression operations */
1225 ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
1226 if (ret < 0) {
1227 RTE_LOG(ERR, USER1,
1228 "Compress operations could not be allocated "
1229 "from the mempool\n");
1230 ret_status = -1;
1231 goto exit;
1232 }
1233
1234 for (i = 0; i < num_bufs; i++) {
1235 ops[i]->m_src = uncomp_bufs[i];
1236 ops[i]->m_dst = comp_bufs[i];
1237 ops[i]->src.offset = 0;
1238 ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]);
1239 ops[i]->dst.offset = 0;
1240
1241 RTE_LOG(DEBUG, USER1,
1242 "Uncompressed buffer length = %u compressed buffer length = %u",
1243 rte_pktmbuf_pkt_len(uncomp_bufs[i]),
1244 rte_pktmbuf_pkt_len(comp_bufs[i]));
1245
1246 if (operation_type == RTE_COMP_OP_STATELESS) {
1247 ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
1248 } else {
1249 RTE_LOG(ERR, USER1,
1250 "Compression: stateful operations are not "
1251 "supported in these tests yet\n");
1252 ret_status = -1;
1253 goto exit;
1254 }
1255 ops[i]->input_chksum = 0;
1256 /*
1257 * Store original operation index in private data,
1258 * since ordering does not have to be maintained,
1259 * when dequeuing from compressdev, so a comparison
1260 * at the end of the test can be done.
1261 */
1262 priv_data = (struct priv_op_data *) (ops[i] + 1);
1263 priv_data->orig_idx = i;
1264 }
1265
1266 /* Compress data (either with Zlib API or compressdev API */
1267 if (zlib_compress) {
1268 for (i = 0; i < num_bufs; i++) {
1269 const struct rte_comp_xform *compress_xform =
1270 compress_xforms[i % num_xforms];
1271 ret = compress_zlib(ops[i], compress_xform,
1272 DEFAULT_MEM_LEVEL);
1273 if (ret < 0) {
1274 ret_status = -1;
1275 goto exit;
1276 }
1277
1278 ops_processed[i] = ops[i];
1279 }
1280 } else {
1281 /* Create compress private xform data */
1282 for (i = 0; i < num_xforms; i++) {
1283 ret = rte_compressdev_private_xform_create(0,
1284 (const struct rte_comp_xform *)
1285 compress_xforms[i],
1286 &priv_xforms[i]);
1287 if (ret < 0) {
1288 RTE_LOG(ERR, USER1,
1289 "Compression private xform "
1290 "could not be created\n");
1291 ret_status = -1;
1292 goto exit;
1293 }
1294 num_priv_xforms++;
1295 }
1296 if (capa->comp_feature_flags &
1297 RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
1298 /* Attach shareable private xform data to ops */
1299 for (i = 0; i < num_bufs; i++)
1300 ops[i]->private_xform =
1301 priv_xforms[i % num_xforms];
1302 } else {
1303 /* Create rest of the private xforms for the other ops */
1304 for (i = num_xforms; i < num_bufs; i++) {
1305 ret = rte_compressdev_private_xform_create(0,
1306 compress_xforms[i % num_xforms],
1307 &priv_xforms[i]);
1308 if (ret < 0) {
1309 RTE_LOG(ERR, USER1,
1310 "Compression private xform "
1311 "could not be created\n");
1312 ret_status = -1;
1313 goto exit;
1314 }
1315 num_priv_xforms++;
1316 }
1317 /* Attach non shareable private xform data to ops */
1318 for (i = 0; i < num_bufs; i++)
1319 ops[i]->private_xform = priv_xforms[i];
1320 }
1321
1322 recovery_lb:
1323 ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
1324 if (ret < 0) {
1325 RTE_LOG(ERR, USER1,
1326 "Compression: enqueue/dequeue operation failed\n");
1327 ret_status = -1;
1328 goto exit;
1329 }
1330
1331 for (i = 0; i < num_bufs; i++) {
1332 test_priv_data->compressed_data_size[i] +=
1333 ops_processed[i]->produced;
1334
1335 if (ops_processed[i]->status ==
1336 RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) {
1337
1338 ops[i]->status =
1339 RTE_COMP_OP_STATUS_NOT_PROCESSED;
1340 ops[i]->src.offset +=
1341 ops_processed[i]->consumed;
1342 ops[i]->src.length -=
1343 ops_processed[i]->consumed;
1344 ops[i]->dst.offset +=
1345 ops_processed[i]->produced;
1346
1347 buf_ptr = rte_pktmbuf_append(
1348 ops[i]->m_dst,
1349 ops_processed[i]->produced);
1350
1351 if (buf_ptr == NULL) {
1352 RTE_LOG(ERR, USER1,
1353 "Data recovery: append extra bytes to the current mbuf failed\n");
1354 ret_status = -1;
1355 goto exit;
1356 }
1357 goto recovery_lb;
1358 }
1359 }
1360 }
1361
1362 exit:
1363 /* Free resources */
1364 if (ret_status < 0)
1365 for (i = 0; i < num_bufs; i++) {
1366 rte_comp_op_free(ops[i]);
1367 ops[i] = NULL;
1368 ops_processed[i] = NULL;
1369 }
1370
1371 /* Free compress private xforms */
1372 for (i = 0; i < num_priv_xforms; i++) {
1373 if (priv_xforms[i] != NULL) {
1374 rte_compressdev_private_xform_free(0, priv_xforms[i]);
1375 priv_xforms[i] = NULL;
1376 }
1377 }
1378
1379 return ret_status;
1380 }
1381
1382 /**
1383 * Prints out the test report. Memory freeing.
1384 *
1385 * Called after successful compression.
1386 * Operation(s) status validation and decompression buffers freeing.
1387
1388 * -1 returned if function fail.
1389 *
1390 * @param int_data
1391 * Interim data containing session/transformation objects.
1392 * @param test_data
1393 * The test parameters set by users (command line parameters).
1394 * @param test_priv_data
1395 * A container used for aggregation all the private test arrays.
1396 * @return
1397 * - 2: Some operation is not supported
1398 * - 1: Decompression should be skipped
1399 * - 0: On success.
1400 * - -1: On error.
1401 */
1402 static int
test_deflate_comp_finalize(const struct interim_data_params * int_data,const struct test_data_params * test_data,const struct test_private_arrays * test_priv_data)1403 test_deflate_comp_finalize(const struct interim_data_params *int_data,
1404 const struct test_data_params *test_data,
1405 const struct test_private_arrays *test_priv_data)
1406 {
1407 /* local variables: */
1408 unsigned int i;
1409 struct priv_op_data *priv_data;
1410
1411 /* from int_data: */
1412 unsigned int num_xforms = int_data->num_xforms;
1413 struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1414 unsigned int num_bufs = int_data->num_bufs;
1415
1416 /* from test_priv_data: */
1417 struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1418 uint64_t *compress_checksum = test_priv_data->compress_checksum;
1419 struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1420 struct rte_comp_op **ops = test_priv_data->ops;
1421
1422 /* from test_data: */
1423 unsigned int out_of_space = test_data->out_of_space;
1424 unsigned int zlib_compress =
1425 (test_data->zlib_dir == ZLIB_ALL ||
1426 test_data->zlib_dir == ZLIB_COMPRESS);
1427 unsigned int zlib_decompress =
1428 (test_data->zlib_dir == ZLIB_ALL ||
1429 test_data->zlib_dir == ZLIB_DECOMPRESS);
1430
1431 for (i = 0; i < num_bufs; i++) {
1432 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1433 uint16_t xform_idx = priv_data->orig_idx % num_xforms;
1434 const struct rte_comp_compress_xform *compress_xform =
1435 &compress_xforms[xform_idx]->compress;
1436 enum rte_comp_huffman huffman_type =
1437 compress_xform->deflate.huffman;
1438 char engine[] = "zlib (directly, not PMD)";
1439 if (zlib_decompress)
1440 strlcpy(engine, "PMD", sizeof(engine));
1441
1442 RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to"
1443 " %u bytes (level = %d, huffman = %s)\n",
1444 i, engine,
1445 ops_processed[i]->consumed, ops_processed[i]->produced,
1446 compress_xform->level,
1447 huffman_type_strings[huffman_type]);
1448 RTE_LOG(DEBUG, USER1, "Compression ratio = %.2f\n",
1449 ops_processed[i]->consumed == 0 ? 0 :
1450 (float)ops_processed[i]->produced /
1451 ops_processed[i]->consumed * 100);
1452 if (compress_xform->chksum != RTE_COMP_CHECKSUM_NONE)
1453 compress_checksum[i] = ops_processed[i]->output_chksum;
1454 ops[i] = NULL;
1455 }
1456
1457 /*
1458 * Check operation status and free source mbufs (destination mbuf and
1459 * compress operation information is needed for the decompression stage)
1460 */
1461 for (i = 0; i < num_bufs; i++) {
1462 if (out_of_space && !zlib_compress) {
1463 if (ops_processed[i]->status !=
1464 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1465 RTE_LOG(ERR, USER1,
1466 "Operation without expected out of "
1467 "space status error\n");
1468 return -1;
1469 } else
1470 continue;
1471 }
1472
1473 if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
1474 if (test_data->overflow == OVERFLOW_ENABLED) {
1475 if (ops_processed[i]->status ==
1476 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1477 RTE_LOG(INFO, USER1,
1478 "Out-of-space-recoverable functionality"
1479 " is not supported on this device\n");
1480 return 2;
1481 }
1482 }
1483
1484 RTE_LOG(ERR, USER1,
1485 "Comp: Some operations were not successful\n");
1486 return -1;
1487 }
1488 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1489 rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
1490 uncomp_bufs[priv_data->orig_idx] = NULL;
1491 }
1492
1493 if (out_of_space && !zlib_compress)
1494 return 1;
1495
1496 return 0;
1497 }
1498
1499 /**
1500 * The main decompression function.
1501 *
1502 * Function performs decompression operation.
1503 * Operation(s) configuration, depending on CLI parameters.
1504 * Operation(s) processing.
1505 *
1506 * @param int_data
1507 * Interim data containing session/transformation objects.
1508 * @param test_data
1509 * The test parameters set by users (command line parameters).
1510 * @param test_priv_data
1511 * A container used for aggregation all the private test arrays.
1512 * @return
1513 * - 0: On success.
1514 * - -1: On error.
1515 */
1516 static int
test_deflate_decomp_run(const struct interim_data_params * int_data,const struct test_data_params * test_data,struct test_private_arrays * test_priv_data)1517 test_deflate_decomp_run(const struct interim_data_params *int_data,
1518 const struct test_data_params *test_data,
1519 struct test_private_arrays *test_priv_data)
1520 {
1521
1522 /* local variables: */
1523 struct priv_op_data *priv_data;
1524 unsigned int i;
1525 uint16_t num_priv_xforms = 0;
1526 int ret;
1527 int ret_status = 0;
1528
1529 struct comp_testsuite_params *ts_params = &testsuite_params;
1530
1531 /* from test_data: */
1532 enum rte_comp_op_type operation_type = test_data->decompress_state;
1533 unsigned int zlib_decompress =
1534 (test_data->zlib_dir == ZLIB_ALL ||
1535 test_data->zlib_dir == ZLIB_DECOMPRESS);
1536
1537 /* from int_data: */
1538 struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
1539 unsigned int num_xforms = int_data->num_xforms;
1540 unsigned int num_bufs = int_data->num_bufs;
1541
1542 /* from test_priv_data: */
1543 struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1544 struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1545 struct rte_comp_op **ops = test_priv_data->ops;
1546 struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1547 void **priv_xforms = test_priv_data->priv_xforms;
1548 uint32_t *compressed_data_size = test_priv_data->compressed_data_size;
1549 void **stream = test_priv_data->stream;
1550
1551 const struct rte_compressdev_capabilities *capa =
1552 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
1553
1554 ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
1555 if (ret < 0) {
1556 RTE_LOG(ERR, USER1,
1557 "Decompress operations could not be allocated "
1558 "from the mempool\n");
1559 ret_status = -1;
1560 goto exit;
1561 }
1562
1563 /* Source buffer is the compressed data from the previous operations */
1564 for (i = 0; i < num_bufs; i++) {
1565 ops[i]->m_src = comp_bufs[i];
1566 ops[i]->m_dst = uncomp_bufs[i];
1567 ops[i]->src.offset = 0;
1568 /*
1569 * Set the length of the compressed data to the
1570 * number of bytes that were produced in the previous stage
1571 */
1572
1573 if (compressed_data_size[i])
1574 ops[i]->src.length = compressed_data_size[i];
1575 else
1576 ops[i]->src.length = ops_processed[i]->produced;
1577
1578 ops[i]->dst.offset = 0;
1579
1580 if (operation_type == RTE_COMP_OP_STATELESS) {
1581 ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
1582 ops[i]->op_type = RTE_COMP_OP_STATELESS;
1583 } else if (!zlib_decompress) {
1584 ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
1585 ops[i]->op_type = RTE_COMP_OP_STATEFUL;
1586 } else {
1587 RTE_LOG(ERR, USER1,
1588 "Decompression: stateful operations are"
1589 " not supported in these tests yet\n");
1590 ret_status = -1;
1591 goto exit;
1592 }
1593 ops[i]->input_chksum = 0;
1594 /*
1595 * Copy private data from previous operations,
1596 * to keep the pointer to the original buffer
1597 */
1598 memcpy(ops[i] + 1, ops_processed[i] + 1,
1599 sizeof(struct priv_op_data));
1600 }
1601
1602 /*
1603 * Free the previous compress operations,
1604 * as they are not needed anymore
1605 */
1606 rte_comp_op_bulk_free(ops_processed, num_bufs);
1607
1608 /* Decompress data (either with Zlib API or compressdev API */
1609 if (zlib_decompress) {
1610 for (i = 0; i < num_bufs; i++) {
1611 priv_data = (struct priv_op_data *)(ops[i] + 1);
1612 uint16_t xform_idx = priv_data->orig_idx % num_xforms;
1613 const struct rte_comp_xform *decompress_xform =
1614 decompress_xforms[xform_idx];
1615
1616 ret = decompress_zlib(ops[i], decompress_xform);
1617 if (ret < 0) {
1618 ret_status = -1;
1619 goto exit;
1620 }
1621
1622 ops_processed[i] = ops[i];
1623 }
1624 } else {
1625 if (operation_type == RTE_COMP_OP_STATELESS) {
1626 /* Create decompress private xform data */
1627 for (i = 0; i < num_xforms; i++) {
1628 ret = rte_compressdev_private_xform_create(0,
1629 (const struct rte_comp_xform *)
1630 decompress_xforms[i],
1631 &priv_xforms[i]);
1632 if (ret < 0) {
1633 RTE_LOG(ERR, USER1,
1634 "Decompression private xform "
1635 "could not be created\n");
1636 ret_status = -1;
1637 goto exit;
1638 }
1639 num_priv_xforms++;
1640 }
1641
1642 if (capa->comp_feature_flags &
1643 RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
1644 /* Attach shareable private xform data to ops */
1645 for (i = 0; i < num_bufs; i++) {
1646 priv_data = (struct priv_op_data *)
1647 (ops[i] + 1);
1648 uint16_t xform_idx =
1649 priv_data->orig_idx % num_xforms;
1650 ops[i]->private_xform =
1651 priv_xforms[xform_idx];
1652 }
1653 } else {
1654 /* Create rest of the private xforms */
1655 /* for the other ops */
1656 for (i = num_xforms; i < num_bufs; i++) {
1657 ret =
1658 rte_compressdev_private_xform_create(0,
1659 decompress_xforms[i % num_xforms],
1660 &priv_xforms[i]);
1661 if (ret < 0) {
1662 RTE_LOG(ERR, USER1,
1663 "Decompression private xform"
1664 " could not be created\n");
1665 ret_status = -1;
1666 goto exit;
1667 }
1668 num_priv_xforms++;
1669 }
1670
1671 /* Attach non shareable private xform data */
1672 /* to ops */
1673 for (i = 0; i < num_bufs; i++) {
1674 priv_data = (struct priv_op_data *)
1675 (ops[i] + 1);
1676 uint16_t xform_idx =
1677 priv_data->orig_idx;
1678 ops[i]->private_xform =
1679 priv_xforms[xform_idx];
1680 }
1681 }
1682 } else {
1683 /* Create a stream object for stateful decompression */
1684 ret = rte_compressdev_stream_create(0,
1685 decompress_xforms[0], stream);
1686 if (ret < 0) {
1687 RTE_LOG(ERR, USER1,
1688 "Decompression stream could not be created, error %d\n",
1689 ret);
1690 ret_status = -1;
1691 goto exit;
1692 }
1693 /* Attach stream to ops */
1694 for (i = 0; i < num_bufs; i++)
1695 ops[i]->stream = *stream;
1696 }
1697
1698 test_priv_data->num_priv_xforms = num_priv_xforms;
1699 }
1700
1701 exit:
1702 return ret_status;
1703 }
1704
1705 /**
1706 * Prints out the test report. Memory freeing.
1707 *
1708 * Called after successful decompression.
1709 * Operation(s) status validation and compression buffers freeing.
1710
1711 * -1 returned if function fail.
1712 *
1713 * @param int_data
1714 * Interim data containing session/transformation objects.
1715 * @param test_data
1716 * The test parameters set by users (command line parameters).
1717 * @param test_priv_data
1718 * A container used for aggregation all the private test arrays.
1719 * @return
1720 * - 2: Next step must be executed by the caller (stateful decompression only)
1721 * - 1: On success (caller should stop and exit)
1722 * - 0: On success.
1723 * - -1: On error.
1724 */
1725 static int
test_deflate_decomp_finalize(const struct interim_data_params * int_data,const struct test_data_params * test_data,const struct test_private_arrays * test_priv_data)1726 test_deflate_decomp_finalize(const struct interim_data_params *int_data,
1727 const struct test_data_params *test_data,
1728 const struct test_private_arrays *test_priv_data)
1729 {
1730 /* local variables: */
1731 unsigned int i;
1732 struct priv_op_data *priv_data;
1733 static unsigned int step;
1734
1735 /* from int_data: */
1736 unsigned int num_bufs = int_data->num_bufs;
1737 const char * const *test_bufs = int_data->test_bufs;
1738 struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1739
1740 /* from test_priv_data: */
1741 struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1742 struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1743 struct rte_comp_op **ops = test_priv_data->ops;
1744 uint64_t *compress_checksum = test_priv_data->compress_checksum;
1745 unsigned int *decomp_produced_data_size =
1746 test_priv_data->decomp_produced_data_size;
1747 char **all_decomp_data = test_priv_data->all_decomp_data;
1748
1749 /* from test_data: */
1750 unsigned int out_of_space = test_data->out_of_space;
1751 enum rte_comp_op_type operation_type = test_data->decompress_state;
1752
1753 unsigned int zlib_compress =
1754 (test_data->zlib_dir == ZLIB_ALL ||
1755 test_data->zlib_dir == ZLIB_COMPRESS);
1756 unsigned int zlib_decompress =
1757 (test_data->zlib_dir == ZLIB_ALL ||
1758 test_data->zlib_dir == ZLIB_DECOMPRESS);
1759
1760 for (i = 0; i < num_bufs; i++) {
1761 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1762 char engine[] = "zlib, (directly, no PMD)";
1763 if (zlib_compress)
1764 strlcpy(engine, "pmd", sizeof(engine));
1765 RTE_LOG(DEBUG, USER1,
1766 "Buffer %u decompressed by %s from %u to %u bytes\n",
1767 i, engine,
1768 ops_processed[i]->consumed, ops_processed[i]->produced);
1769 ops[i] = NULL;
1770 }
1771
1772 /*
1773 * Check operation status and free source mbuf (destination mbuf and
1774 * compress operation information is still needed)
1775 */
1776 for (i = 0; i < num_bufs; i++) {
1777 if (out_of_space && !zlib_decompress) {
1778 if (ops_processed[i]->status !=
1779 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1780
1781 RTE_LOG(ERR, USER1,
1782 "Operation without expected out of "
1783 "space status error\n");
1784 return -1;
1785 } else
1786 continue;
1787 }
1788
1789 if (operation_type == RTE_COMP_OP_STATEFUL
1790 && (ops_processed[i]->status ==
1791 RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
1792 || ops_processed[i]->status ==
1793 RTE_COMP_OP_STATUS_SUCCESS)) {
1794
1795 RTE_LOG(DEBUG, USER1,
1796 ".............RECOVERABLE\n");
1797
1798 /* collect the output into all_decomp_data */
1799 const void *ptr = rte_pktmbuf_read(
1800 ops_processed[i]->m_dst,
1801 ops_processed[i]->dst.offset,
1802 ops_processed[i]->produced,
1803 *all_decomp_data +
1804 *decomp_produced_data_size);
1805 if (ptr != *all_decomp_data +
1806 *decomp_produced_data_size)
1807 rte_memcpy(*all_decomp_data +
1808 *decomp_produced_data_size,
1809 ptr, ops_processed[i]->produced);
1810
1811 *decomp_produced_data_size +=
1812 ops_processed[i]->produced;
1813 if (ops_processed[i]->src.length >
1814 ops_processed[i]->consumed) {
1815 if (ops_processed[i]->status ==
1816 RTE_COMP_OP_STATUS_SUCCESS) {
1817 RTE_LOG(ERR, USER1,
1818 "Operation finished too early\n");
1819 return -1;
1820 }
1821 step++;
1822 if (step >= test_data->decompress_steps_max) {
1823 RTE_LOG(ERR, USER1,
1824 "Operation exceeded maximum steps\n");
1825 return -1;
1826 }
1827 ops[i] = ops_processed[i];
1828 ops[i]->status =
1829 RTE_COMP_OP_STATUS_NOT_PROCESSED;
1830 ops[i]->src.offset +=
1831 ops_processed[i]->consumed;
1832 ops[i]->src.length -=
1833 ops_processed[i]->consumed;
1834 /* repeat the operation */
1835 return 2;
1836 } else {
1837 /* Compare the original stream with the */
1838 /* decompressed stream (in size and the data) */
1839 priv_data = (struct priv_op_data *)
1840 (ops_processed[i] + 1);
1841 const char *buf1 =
1842 test_bufs[priv_data->orig_idx];
1843 const char *buf2 = *all_decomp_data;
1844
1845 if (compare_buffers(buf1, strlen(buf1) + 1,
1846 buf2, *decomp_produced_data_size) < 0)
1847 return -1;
1848 /* Test checksums */
1849 if (compress_xforms[0]->compress.chksum
1850 != RTE_COMP_CHECKSUM_NONE) {
1851 if (ops_processed[i]->output_chksum
1852 != compress_checksum[i]) {
1853 RTE_LOG(ERR, USER1,
1854 "The checksums differ\n"
1855 "Compression Checksum: %" PRIu64 "\tDecompression "
1856 "Checksum: %" PRIu64 "\n", compress_checksum[i],
1857 ops_processed[i]->output_chksum);
1858 return -1;
1859 }
1860 }
1861 }
1862 } else if (ops_processed[i]->status !=
1863 RTE_COMP_OP_STATUS_SUCCESS) {
1864 RTE_LOG(ERR, USER1,
1865 "Decomp: Some operations were not successful, status = %u\n",
1866 ops_processed[i]->status);
1867 return -1;
1868 }
1869 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1870 rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
1871 comp_bufs[priv_data->orig_idx] = NULL;
1872 }
1873
1874 if (out_of_space && !zlib_decompress)
1875 return 1;
1876
1877 return 0;
1878 }
1879
1880 /**
1881 * Validation of the output (compression/decompression) data.
1882 *
1883 * The function compares the source stream with the output stream,
1884 * after decompression, to check if compression/decompression
1885 * was correct.
1886 * -1 returned if function fail.
1887 *
1888 * @param int_data
1889 * Interim data containing session/transformation objects.
1890 * @param test_data
1891 * The test parameters set by users (command line parameters).
1892 * @param test_priv_data
1893 * A container used for aggregation all the private test arrays.
1894 * @return
1895 * - 0: On success.
1896 * - -1: On error.
1897 */
1898 static int
test_results_validation(const struct interim_data_params * int_data,const struct test_data_params * test_data,const struct test_private_arrays * test_priv_data)1899 test_results_validation(const struct interim_data_params *int_data,
1900 const struct test_data_params *test_data,
1901 const struct test_private_arrays *test_priv_data)
1902 {
1903 /* local variables: */
1904 unsigned int i;
1905 struct priv_op_data *priv_data;
1906 const char *buf1;
1907 const char *buf2;
1908 char *contig_buf = NULL;
1909 uint32_t data_size;
1910
1911 /* from int_data: */
1912 struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1913 unsigned int num_bufs = int_data->num_bufs;
1914 const char * const *test_bufs = int_data->test_bufs;
1915
1916 /* from test_priv_data: */
1917 uint64_t *compress_checksum = test_priv_data->compress_checksum;
1918 struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1919
1920 /*
1921 * Compare the original stream with the decompressed stream
1922 * (in size and the data)
1923 */
1924 for (i = 0; i < num_bufs; i++) {
1925 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1926 buf1 = test_data->use_external_mbufs ?
1927 test_data->inbuf_memzone->addr :
1928 test_bufs[priv_data->orig_idx];
1929 data_size = test_data->use_external_mbufs ?
1930 test_data->inbuf_data_size :
1931 strlen(buf1) + 1;
1932
1933 contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
1934 if (contig_buf == NULL) {
1935 RTE_LOG(ERR, USER1, "Contiguous buffer could not "
1936 "be allocated\n");
1937 goto exit;
1938 }
1939
1940 buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
1941 ops_processed[i]->produced, contig_buf);
1942 if (compare_buffers(buf1, data_size,
1943 buf2, ops_processed[i]->produced) < 0)
1944 goto exit;
1945
1946 /* Test checksums */
1947 if (compress_xforms[0]->compress.chksum !=
1948 RTE_COMP_CHECKSUM_NONE) {
1949 if (ops_processed[i]->output_chksum !=
1950 compress_checksum[i]) {
1951 RTE_LOG(ERR, USER1, "The checksums differ\n"
1952 "Compression Checksum: %" PRIu64 "\tDecompression "
1953 "Checksum: %" PRIu64 "\n", compress_checksum[i],
1954 ops_processed[i]->output_chksum);
1955 goto exit;
1956 }
1957 }
1958
1959 rte_free(contig_buf);
1960 contig_buf = NULL;
1961 }
1962 return 0;
1963
1964 exit:
1965 rte_free(contig_buf);
1966 return -1;
1967 }
1968
1969 /**
1970 * Compresses and decompresses input stream with compressdev API and Zlib API
1971 *
1972 * Basic test function. Common for all the functional tests.
1973 * -1 returned if function fail.
1974 *
1975 * @param int_data
1976 * Interim data containing session/transformation objects.
1977 * @param test_data
1978 * The test parameters set by users (command line parameters).
1979 * @return
1980 * - 1: Some operation not supported
1981 * - 0: On success.
1982 * - -1: On error.
1983 */
1984
1985 static int
test_deflate_comp_decomp(const struct interim_data_params * int_data,const struct test_data_params * test_data)1986 test_deflate_comp_decomp(const struct interim_data_params *int_data,
1987 const struct test_data_params *test_data)
1988 {
1989 unsigned int num_bufs = int_data->num_bufs;
1990 unsigned int out_of_space = test_data->out_of_space;
1991
1992 void *stream = NULL;
1993 char *all_decomp_data = NULL;
1994 unsigned int decomp_produced_data_size = 0;
1995
1996 int ret_status = -1;
1997 int ret;
1998 struct rte_mbuf *uncomp_bufs[num_bufs];
1999 struct rte_mbuf *comp_bufs[num_bufs];
2000 struct rte_comp_op *ops[num_bufs];
2001 struct rte_comp_op *ops_processed[num_bufs];
2002 void *priv_xforms[num_bufs];
2003 unsigned int i;
2004
2005 uint64_t compress_checksum[num_bufs];
2006 uint32_t compressed_data_size[num_bufs];
2007 char *contig_buf = NULL;
2008
2009 struct rte_mbuf_ext_shared_info compbuf_info;
2010 struct rte_mbuf_ext_shared_info decompbuf_info;
2011
2012 const struct rte_compressdev_capabilities *capa;
2013
2014 /* Compressing with CompressDev */
2015 unsigned int zlib_compress =
2016 (test_data->zlib_dir == ZLIB_ALL ||
2017 test_data->zlib_dir == ZLIB_COMPRESS);
2018 unsigned int zlib_decompress =
2019 (test_data->zlib_dir == ZLIB_ALL ||
2020 test_data->zlib_dir == ZLIB_DECOMPRESS);
2021
2022 struct test_private_arrays test_priv_data;
2023
2024 test_priv_data.uncomp_bufs = uncomp_bufs;
2025 test_priv_data.comp_bufs = comp_bufs;
2026 test_priv_data.ops = ops;
2027 test_priv_data.ops_processed = ops_processed;
2028 test_priv_data.priv_xforms = priv_xforms;
2029 test_priv_data.compress_checksum = compress_checksum;
2030 test_priv_data.compressed_data_size = compressed_data_size;
2031
2032 test_priv_data.stream = &stream;
2033 test_priv_data.all_decomp_data = &all_decomp_data;
2034 test_priv_data.decomp_produced_data_size = &decomp_produced_data_size;
2035
2036 test_priv_data.num_priv_xforms = 0; /* it's used for decompression only */
2037
2038 capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2039 if (capa == NULL) {
2040 RTE_LOG(ERR, USER1,
2041 "Compress device does not support DEFLATE\n");
2042 return -1;
2043 }
2044
2045 /* Prepare the source mbufs with the data */
2046 ret = test_setup_com_bufs(int_data, test_data, &test_priv_data);
2047 if (ret < 0) {
2048 ret_status = -1;
2049 goto exit;
2050 }
2051
2052 RTE_LOG(DEBUG, USER1, "<<< COMPRESSION >>>\n");
2053
2054 /* COMPRESSION */
2055
2056 /* Prepare output (destination) mbufs for compressed data */
2057 ret = test_setup_output_bufs(
2058 OPERATION_COMPRESSION,
2059 out_of_space == 1 && !zlib_compress,
2060 &test_priv_data,
2061 int_data,
2062 test_data,
2063 &compbuf_info);
2064 if (ret < 0) {
2065 ret_status = -1;
2066 goto exit;
2067 }
2068
2069 /* Run compression */
2070 ret = test_deflate_comp_run(int_data, test_data, &test_priv_data);
2071 if (ret < 0) {
2072 ret_status = -1;
2073 goto exit;
2074 }
2075
2076 ret = test_deflate_comp_finalize(int_data, test_data, &test_priv_data);
2077 if (ret < 0) {
2078 ret_status = -1;
2079 goto exit;
2080 } else if (ret == 1) {
2081 ret_status = 0;
2082 goto exit;
2083 } else if (ret == 2) {
2084 ret_status = 1; /* some operation not supported */
2085 goto exit;
2086 }
2087
2088 /* DECOMPRESSION */
2089
2090 RTE_LOG(DEBUG, USER1, "<<< DECOMPRESSION >>>\n");
2091
2092 /* Prepare output (destination) mbufs for decompressed data */
2093 ret = test_setup_output_bufs(
2094 OPERATION_DECOMPRESSION,
2095 out_of_space == 1 && !zlib_decompress,
2096 &test_priv_data,
2097 int_data,
2098 test_data,
2099 &decompbuf_info);
2100 if (ret < 0) {
2101 ret_status = -1;
2102 goto exit;
2103 }
2104
2105 /* Run decompression */
2106 ret = test_deflate_decomp_run(int_data, test_data, &test_priv_data);
2107 if (ret < 0) {
2108 ret_status = -1;
2109 goto exit;
2110 }
2111
2112 if (!zlib_decompress) {
2113 next_step: /* next step for stateful decompression only */
2114 ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
2115 if (ret < 0) {
2116 ret_status = -1;
2117 RTE_LOG(ERR, USER1,
2118 "Decompression: enqueue/dequeue operation failed\n");
2119 }
2120 }
2121
2122 ret = test_deflate_decomp_finalize(int_data, test_data, &test_priv_data);
2123 if (ret < 0) {
2124 ret_status = -1;
2125 goto exit;
2126 } else if (ret == 1) {
2127 ret_status = 0;
2128 goto exit;
2129 } else if (ret == 2) {
2130 goto next_step;
2131 }
2132
2133 /* FINAL PROCESSING */
2134
2135 ret = test_results_validation(int_data, test_data, &test_priv_data);
2136 if (ret < 0) {
2137 ret_status = -1;
2138 goto exit;
2139 }
2140 ret_status = 0;
2141
2142 exit:
2143 /* Free resources */
2144
2145 if (stream != NULL)
2146 rte_compressdev_stream_free(0, stream);
2147 rte_free(all_decomp_data);
2148
2149 /* Free compress private xforms */
2150 for (i = 0; i < test_priv_data.num_priv_xforms; i++) {
2151 if (priv_xforms[i] != NULL) {
2152 rte_compressdev_private_xform_free(0, priv_xforms[i]);
2153 priv_xforms[i] = NULL;
2154 }
2155 }
2156 for (i = 0; i < num_bufs; i++) {
2157 rte_pktmbuf_free(uncomp_bufs[i]);
2158 rte_pktmbuf_free(comp_bufs[i]);
2159 rte_comp_op_free(ops[i]);
2160 rte_comp_op_free(ops_processed[i]);
2161 }
2162 rte_free(contig_buf);
2163
2164 return ret_status;
2165 }
2166
2167 static int
test_compressdev_deflate_stateless_fixed(void)2168 test_compressdev_deflate_stateless_fixed(void)
2169 {
2170 struct comp_testsuite_params *ts_params = &testsuite_params;
2171 uint16_t i;
2172 int ret;
2173 const struct rte_compressdev_capabilities *capab;
2174
2175 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2176 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2177
2178 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
2179 return -ENOTSUP;
2180
2181 struct rte_comp_xform *compress_xform =
2182 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2183
2184 if (compress_xform == NULL) {
2185 RTE_LOG(ERR, USER1,
2186 "Compress xform could not be created\n");
2187 ret = TEST_FAILED;
2188 goto exit;
2189 }
2190
2191 memcpy(compress_xform, ts_params->def_comp_xform,
2192 sizeof(struct rte_comp_xform));
2193 compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
2194
2195 struct interim_data_params int_data = {
2196 NULL,
2197 1,
2198 NULL,
2199 &compress_xform,
2200 &ts_params->def_decomp_xform,
2201 1
2202 };
2203
2204 struct test_data_params test_data = {
2205 .compress_state = RTE_COMP_OP_STATELESS,
2206 .decompress_state = RTE_COMP_OP_STATELESS,
2207 .buff_type = LB_BOTH,
2208 .zlib_dir = ZLIB_DECOMPRESS,
2209 .out_of_space = 0,
2210 .big_data = 0,
2211 .overflow = OVERFLOW_DISABLED,
2212 .ratio = RATIO_ENABLED
2213 };
2214
2215 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2216 int_data.test_bufs = &compress_test_bufs[i];
2217 int_data.buf_idx = &i;
2218
2219 /* Compress with compressdev, decompress with Zlib */
2220 test_data.zlib_dir = ZLIB_DECOMPRESS;
2221 ret = test_deflate_comp_decomp(&int_data, &test_data);
2222 if (ret < 0)
2223 goto exit;
2224
2225 /* Compress with Zlib, decompress with compressdev */
2226 test_data.zlib_dir = ZLIB_COMPRESS;
2227 ret = test_deflate_comp_decomp(&int_data, &test_data);
2228 if (ret < 0)
2229 goto exit;
2230 }
2231
2232 ret = TEST_SUCCESS;
2233
2234 exit:
2235 rte_free(compress_xform);
2236 return ret;
2237 }
2238
2239 static int
test_compressdev_deflate_stateless_dynamic(void)2240 test_compressdev_deflate_stateless_dynamic(void)
2241 {
2242 struct comp_testsuite_params *ts_params = &testsuite_params;
2243 uint16_t i;
2244 int ret;
2245 struct rte_comp_xform *compress_xform =
2246 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2247
2248 const struct rte_compressdev_capabilities *capab;
2249
2250 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2251 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2252
2253 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
2254 return -ENOTSUP;
2255
2256 if (compress_xform == NULL) {
2257 RTE_LOG(ERR, USER1,
2258 "Compress xform could not be created\n");
2259 ret = TEST_FAILED;
2260 goto exit;
2261 }
2262
2263 memcpy(compress_xform, ts_params->def_comp_xform,
2264 sizeof(struct rte_comp_xform));
2265 compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC;
2266
2267 struct interim_data_params int_data = {
2268 NULL,
2269 1,
2270 NULL,
2271 &compress_xform,
2272 &ts_params->def_decomp_xform,
2273 1
2274 };
2275
2276 struct test_data_params test_data = {
2277 .compress_state = RTE_COMP_OP_STATELESS,
2278 .decompress_state = RTE_COMP_OP_STATELESS,
2279 .buff_type = LB_BOTH,
2280 .zlib_dir = ZLIB_DECOMPRESS,
2281 .out_of_space = 0,
2282 .big_data = 0,
2283 .overflow = OVERFLOW_DISABLED,
2284 .ratio = RATIO_ENABLED
2285 };
2286
2287 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2288 int_data.test_bufs = &compress_test_bufs[i];
2289 int_data.buf_idx = &i;
2290
2291 /* Compress with compressdev, decompress with Zlib */
2292 test_data.zlib_dir = ZLIB_DECOMPRESS;
2293 ret = test_deflate_comp_decomp(&int_data, &test_data);
2294 if (ret < 0)
2295 goto exit;
2296
2297 /* Compress with Zlib, decompress with compressdev */
2298 test_data.zlib_dir = ZLIB_COMPRESS;
2299 ret = test_deflate_comp_decomp(&int_data, &test_data);
2300 if (ret < 0)
2301 goto exit;
2302 }
2303
2304 ret = TEST_SUCCESS;
2305
2306 exit:
2307 rte_free(compress_xform);
2308 return ret;
2309 }
2310
2311 static int
test_compressdev_deflate_stateless_multi_op(void)2312 test_compressdev_deflate_stateless_multi_op(void)
2313 {
2314 struct comp_testsuite_params *ts_params = &testsuite_params;
2315 uint16_t num_bufs = RTE_DIM(compress_test_bufs);
2316 uint16_t buf_idx[num_bufs];
2317 uint16_t i;
2318 int ret;
2319
2320 for (i = 0; i < num_bufs; i++)
2321 buf_idx[i] = i;
2322
2323 struct interim_data_params int_data = {
2324 compress_test_bufs,
2325 num_bufs,
2326 buf_idx,
2327 &ts_params->def_comp_xform,
2328 &ts_params->def_decomp_xform,
2329 1
2330 };
2331
2332 struct test_data_params test_data = {
2333 .compress_state = RTE_COMP_OP_STATELESS,
2334 .decompress_state = RTE_COMP_OP_STATELESS,
2335 .buff_type = LB_BOTH,
2336 .zlib_dir = ZLIB_DECOMPRESS,
2337 .out_of_space = 0,
2338 .big_data = 0,
2339 .overflow = OVERFLOW_DISABLED,
2340 .ratio = RATIO_ENABLED
2341 };
2342
2343 /* Compress with compressdev, decompress with Zlib */
2344 test_data.zlib_dir = ZLIB_DECOMPRESS;
2345 ret = test_deflate_comp_decomp(&int_data, &test_data);
2346 if (ret < 0)
2347 return ret;
2348
2349 /* Compress with Zlib, decompress with compressdev */
2350 test_data.zlib_dir = ZLIB_COMPRESS;
2351 ret = test_deflate_comp_decomp(&int_data, &test_data);
2352 if (ret < 0)
2353 return ret;
2354
2355 return TEST_SUCCESS;
2356 }
2357
2358 static int
test_compressdev_deflate_stateless_multi_level(void)2359 test_compressdev_deflate_stateless_multi_level(void)
2360 {
2361 struct comp_testsuite_params *ts_params = &testsuite_params;
2362 unsigned int level;
2363 uint16_t i;
2364 int ret;
2365 struct rte_comp_xform *compress_xform =
2366 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2367
2368 if (compress_xform == NULL) {
2369 RTE_LOG(ERR, USER1,
2370 "Compress xform could not be created\n");
2371 ret = TEST_FAILED;
2372 goto exit;
2373 }
2374
2375 memcpy(compress_xform, ts_params->def_comp_xform,
2376 sizeof(struct rte_comp_xform));
2377
2378 struct interim_data_params int_data = {
2379 NULL,
2380 1,
2381 NULL,
2382 &compress_xform,
2383 &ts_params->def_decomp_xform,
2384 1
2385 };
2386
2387 struct test_data_params test_data = {
2388 .compress_state = RTE_COMP_OP_STATELESS,
2389 .decompress_state = RTE_COMP_OP_STATELESS,
2390 .buff_type = LB_BOTH,
2391 .zlib_dir = ZLIB_DECOMPRESS,
2392 .out_of_space = 0,
2393 .big_data = 0,
2394 .overflow = OVERFLOW_DISABLED,
2395 .ratio = RATIO_ENABLED
2396 };
2397
2398 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2399 int_data.test_bufs = &compress_test_bufs[i];
2400 int_data.buf_idx = &i;
2401
2402 for (level = RTE_COMP_LEVEL_MIN; level <= RTE_COMP_LEVEL_MAX;
2403 level++) {
2404 compress_xform->compress.level = level;
2405 /* Compress with compressdev, decompress with Zlib */
2406 test_data.zlib_dir = ZLIB_DECOMPRESS;
2407 ret = test_deflate_comp_decomp(&int_data, &test_data);
2408 if (ret < 0)
2409 goto exit;
2410 }
2411 }
2412
2413 ret = TEST_SUCCESS;
2414
2415 exit:
2416 rte_free(compress_xform);
2417 return ret;
2418 }
2419
2420 #define NUM_XFORMS 3
2421 static int
test_compressdev_deflate_stateless_multi_xform(void)2422 test_compressdev_deflate_stateless_multi_xform(void)
2423 {
2424 struct comp_testsuite_params *ts_params = &testsuite_params;
2425 uint16_t num_bufs = NUM_XFORMS;
2426 struct rte_comp_xform *compress_xforms[NUM_XFORMS] = {NULL};
2427 struct rte_comp_xform *decompress_xforms[NUM_XFORMS] = {NULL};
2428 const char *test_buffers[NUM_XFORMS];
2429 uint16_t i;
2430 unsigned int level = RTE_COMP_LEVEL_MIN;
2431 uint16_t buf_idx[num_bufs];
2432 int ret;
2433
2434 /* Create multiple xforms with various levels */
2435 for (i = 0; i < NUM_XFORMS; i++) {
2436 compress_xforms[i] = rte_malloc(NULL,
2437 sizeof(struct rte_comp_xform), 0);
2438 if (compress_xforms[i] == NULL) {
2439 RTE_LOG(ERR, USER1,
2440 "Compress xform could not be created\n");
2441 ret = TEST_FAILED;
2442 goto exit;
2443 }
2444
2445 memcpy(compress_xforms[i], ts_params->def_comp_xform,
2446 sizeof(struct rte_comp_xform));
2447 compress_xforms[i]->compress.level = level;
2448 level++;
2449
2450 decompress_xforms[i] = rte_malloc(NULL,
2451 sizeof(struct rte_comp_xform), 0);
2452 if (decompress_xforms[i] == NULL) {
2453 RTE_LOG(ERR, USER1,
2454 "Decompress xform could not be created\n");
2455 ret = TEST_FAILED;
2456 goto exit;
2457 }
2458
2459 memcpy(decompress_xforms[i], ts_params->def_decomp_xform,
2460 sizeof(struct rte_comp_xform));
2461 }
2462
2463 for (i = 0; i < NUM_XFORMS; i++) {
2464 buf_idx[i] = 0;
2465 /* Use the same buffer in all sessions */
2466 test_buffers[i] = compress_test_bufs[0];
2467 }
2468
2469 struct interim_data_params int_data = {
2470 test_buffers,
2471 num_bufs,
2472 buf_idx,
2473 compress_xforms,
2474 decompress_xforms,
2475 NUM_XFORMS
2476 };
2477
2478 struct test_data_params test_data = {
2479 .compress_state = RTE_COMP_OP_STATELESS,
2480 .decompress_state = RTE_COMP_OP_STATELESS,
2481 .buff_type = LB_BOTH,
2482 .zlib_dir = ZLIB_DECOMPRESS,
2483 .out_of_space = 0,
2484 .big_data = 0,
2485 .overflow = OVERFLOW_DISABLED,
2486 .ratio = RATIO_ENABLED
2487 };
2488
2489 /* Compress with compressdev, decompress with Zlib */
2490 ret = test_deflate_comp_decomp(&int_data, &test_data);
2491 if (ret < 0)
2492 goto exit;
2493
2494 ret = TEST_SUCCESS;
2495
2496 exit:
2497 for (i = 0; i < NUM_XFORMS; i++) {
2498 rte_free(compress_xforms[i]);
2499 rte_free(decompress_xforms[i]);
2500 }
2501
2502 return ret;
2503 }
2504
2505 static int
test_compressdev_deflate_stateless_sgl(void)2506 test_compressdev_deflate_stateless_sgl(void)
2507 {
2508 struct comp_testsuite_params *ts_params = &testsuite_params;
2509 uint16_t i;
2510 int ret;
2511 const struct rte_compressdev_capabilities *capab;
2512
2513 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2514 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2515
2516 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
2517 return -ENOTSUP;
2518
2519 struct interim_data_params int_data = {
2520 NULL,
2521 1,
2522 NULL,
2523 &ts_params->def_comp_xform,
2524 &ts_params->def_decomp_xform,
2525 1
2526 };
2527
2528 struct test_data_params test_data = {
2529 .compress_state = RTE_COMP_OP_STATELESS,
2530 .decompress_state = RTE_COMP_OP_STATELESS,
2531 .buff_type = SGL_BOTH,
2532 .zlib_dir = ZLIB_DECOMPRESS,
2533 .out_of_space = 0,
2534 .big_data = 0,
2535 .overflow = OVERFLOW_DISABLED,
2536 .ratio = RATIO_ENABLED
2537 };
2538
2539 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2540 int_data.test_bufs = &compress_test_bufs[i];
2541 int_data.buf_idx = &i;
2542
2543 /* Compress with compressdev, decompress with Zlib */
2544 test_data.zlib_dir = ZLIB_DECOMPRESS;
2545 ret = test_deflate_comp_decomp(&int_data, &test_data);
2546 if (ret < 0)
2547 return ret;
2548
2549 /* Compress with Zlib, decompress with compressdev */
2550 test_data.zlib_dir = ZLIB_COMPRESS;
2551 ret = test_deflate_comp_decomp(&int_data, &test_data);
2552 if (ret < 0)
2553 return ret;
2554
2555 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_LB_OUT) {
2556 /* Compress with compressdev, decompress with Zlib */
2557 test_data.zlib_dir = ZLIB_DECOMPRESS;
2558 test_data.buff_type = SGL_TO_LB;
2559 ret = test_deflate_comp_decomp(&int_data, &test_data);
2560 if (ret < 0)
2561 return ret;
2562
2563 /* Compress with Zlib, decompress with compressdev */
2564 test_data.zlib_dir = ZLIB_COMPRESS;
2565 test_data.buff_type = SGL_TO_LB;
2566 ret = test_deflate_comp_decomp(&int_data, &test_data);
2567 if (ret < 0)
2568 return ret;
2569 }
2570
2571 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_LB_IN_SGL_OUT) {
2572 /* Compress with compressdev, decompress with Zlib */
2573 test_data.zlib_dir = ZLIB_DECOMPRESS;
2574 test_data.buff_type = LB_TO_SGL;
2575 ret = test_deflate_comp_decomp(&int_data, &test_data);
2576 if (ret < 0)
2577 return ret;
2578
2579 /* Compress with Zlib, decompress with compressdev */
2580 test_data.zlib_dir = ZLIB_COMPRESS;
2581 test_data.buff_type = LB_TO_SGL;
2582 ret = test_deflate_comp_decomp(&int_data, &test_data);
2583 if (ret < 0)
2584 return ret;
2585 }
2586 }
2587
2588 return TEST_SUCCESS;
2589 }
2590
2591 static int
test_compressdev_deflate_stateless_checksum(void)2592 test_compressdev_deflate_stateless_checksum(void)
2593 {
2594 struct comp_testsuite_params *ts_params = &testsuite_params;
2595 uint16_t i;
2596 int ret;
2597 const struct rte_compressdev_capabilities *capab;
2598
2599 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2600 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2601
2602 /* Check if driver supports any checksum */
2603 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) == 0 &&
2604 (capab->comp_feature_flags &
2605 RTE_COMP_FF_ADLER32_CHECKSUM) == 0 &&
2606 (capab->comp_feature_flags &
2607 RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) == 0)
2608 return -ENOTSUP;
2609
2610 struct rte_comp_xform *compress_xform =
2611 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2612 if (compress_xform == NULL) {
2613 RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
2614 return TEST_FAILED;
2615 }
2616
2617 memcpy(compress_xform, ts_params->def_comp_xform,
2618 sizeof(struct rte_comp_xform));
2619
2620 struct rte_comp_xform *decompress_xform =
2621 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2622 if (decompress_xform == NULL) {
2623 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
2624 rte_free(compress_xform);
2625 return TEST_FAILED;
2626 }
2627
2628 memcpy(decompress_xform, ts_params->def_decomp_xform,
2629 sizeof(struct rte_comp_xform));
2630
2631 struct interim_data_params int_data = {
2632 NULL,
2633 1,
2634 NULL,
2635 &compress_xform,
2636 &decompress_xform,
2637 1
2638 };
2639
2640 struct test_data_params test_data = {
2641 .compress_state = RTE_COMP_OP_STATELESS,
2642 .decompress_state = RTE_COMP_OP_STATELESS,
2643 .buff_type = LB_BOTH,
2644 .zlib_dir = ZLIB_DECOMPRESS,
2645 .out_of_space = 0,
2646 .big_data = 0,
2647 .overflow = OVERFLOW_DISABLED,
2648 .ratio = RATIO_ENABLED
2649 };
2650
2651 /* Check if driver supports crc32 checksum and test */
2652 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM)) {
2653 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32;
2654 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32;
2655
2656 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2657 /* Compress with compressdev, decompress with Zlib */
2658 int_data.test_bufs = &compress_test_bufs[i];
2659 int_data.buf_idx = &i;
2660
2661 /* Generate zlib checksum and test against selected
2662 * drivers decompression checksum
2663 */
2664 test_data.zlib_dir = ZLIB_COMPRESS;
2665 ret = test_deflate_comp_decomp(&int_data, &test_data);
2666 if (ret < 0)
2667 goto exit;
2668
2669 /* Generate compression and decompression
2670 * checksum of selected driver
2671 */
2672 test_data.zlib_dir = ZLIB_NONE;
2673 ret = test_deflate_comp_decomp(&int_data, &test_data);
2674 if (ret < 0)
2675 goto exit;
2676 }
2677 }
2678
2679 /* Check if driver supports adler32 checksum and test */
2680 if ((capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM)) {
2681 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2682 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2683
2684 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2685 int_data.test_bufs = &compress_test_bufs[i];
2686 int_data.buf_idx = &i;
2687
2688 /* Generate zlib checksum and test against selected
2689 * drivers decompression checksum
2690 */
2691 test_data.zlib_dir = ZLIB_COMPRESS;
2692 ret = test_deflate_comp_decomp(&int_data, &test_data);
2693 if (ret < 0)
2694 goto exit;
2695 /* Generate compression and decompression
2696 * checksum of selected driver
2697 */
2698 test_data.zlib_dir = ZLIB_NONE;
2699 ret = test_deflate_comp_decomp(&int_data, &test_data);
2700 if (ret < 0)
2701 goto exit;
2702 }
2703 }
2704
2705 /* Check if driver supports combined crc and adler checksum and test */
2706 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)) {
2707 compress_xform->compress.chksum =
2708 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2709 decompress_xform->decompress.chksum =
2710 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2711
2712 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2713 int_data.test_bufs = &compress_test_bufs[i];
2714 int_data.buf_idx = &i;
2715
2716 /* Generate compression and decompression
2717 * checksum of selected driver
2718 */
2719 test_data.zlib_dir = ZLIB_NONE;
2720 ret = test_deflate_comp_decomp(&int_data, &test_data);
2721 if (ret < 0)
2722 goto exit;
2723 }
2724 }
2725
2726 ret = TEST_SUCCESS;
2727
2728 exit:
2729 rte_free(compress_xform);
2730 rte_free(decompress_xform);
2731 return ret;
2732 }
2733
2734 static int
test_compressdev_out_of_space_buffer(void)2735 test_compressdev_out_of_space_buffer(void)
2736 {
2737 struct comp_testsuite_params *ts_params = &testsuite_params;
2738 int ret;
2739 uint16_t i;
2740 const struct rte_compressdev_capabilities *capab;
2741
2742 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
2743
2744 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2745 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2746
2747 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
2748 return -ENOTSUP;
2749
2750 struct interim_data_params int_data = {
2751 &compress_test_bufs[0],
2752 1,
2753 &i,
2754 &ts_params->def_comp_xform,
2755 &ts_params->def_decomp_xform,
2756 1
2757 };
2758
2759 struct test_data_params test_data = {
2760 .compress_state = RTE_COMP_OP_STATELESS,
2761 .decompress_state = RTE_COMP_OP_STATELESS,
2762 .buff_type = LB_BOTH,
2763 .zlib_dir = ZLIB_DECOMPRESS,
2764 .out_of_space = 1, /* run out-of-space test */
2765 .big_data = 0,
2766 .overflow = OVERFLOW_DISABLED,
2767 .ratio = RATIO_ENABLED
2768 };
2769 /* Compress with compressdev, decompress with Zlib */
2770 test_data.zlib_dir = ZLIB_DECOMPRESS;
2771 ret = test_deflate_comp_decomp(&int_data, &test_data);
2772 if (ret < 0)
2773 goto exit;
2774
2775 /* Compress with Zlib, decompress with compressdev */
2776 test_data.zlib_dir = ZLIB_COMPRESS;
2777 ret = test_deflate_comp_decomp(&int_data, &test_data);
2778 if (ret < 0)
2779 goto exit;
2780
2781 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2782 /* Compress with compressdev, decompress with Zlib */
2783 test_data.zlib_dir = ZLIB_DECOMPRESS;
2784 test_data.buff_type = SGL_BOTH;
2785 ret = test_deflate_comp_decomp(&int_data, &test_data);
2786 if (ret < 0)
2787 goto exit;
2788
2789 /* Compress with Zlib, decompress with compressdev */
2790 test_data.zlib_dir = ZLIB_COMPRESS;
2791 test_data.buff_type = SGL_BOTH;
2792 ret = test_deflate_comp_decomp(&int_data, &test_data);
2793 if (ret < 0)
2794 goto exit;
2795 }
2796
2797 ret = TEST_SUCCESS;
2798
2799 exit:
2800 return ret;
2801 }
2802
2803 static int
test_compressdev_deflate_stateless_dynamic_big(void)2804 test_compressdev_deflate_stateless_dynamic_big(void)
2805 {
2806 struct comp_testsuite_params *ts_params = &testsuite_params;
2807 uint16_t i = 0;
2808 int ret;
2809 unsigned int j;
2810 const struct rte_compressdev_capabilities *capab;
2811 char *test_buffer = NULL;
2812
2813 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2814 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2815
2816 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
2817 return -ENOTSUP;
2818
2819 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
2820 return -ENOTSUP;
2821
2822 test_buffer = rte_malloc(NULL, BIG_DATA_TEST_SIZE, 0);
2823 if (test_buffer == NULL) {
2824 RTE_LOG(ERR, USER1,
2825 "Can't allocate buffer for big-data\n");
2826 return TEST_FAILED;
2827 }
2828
2829 struct interim_data_params int_data = {
2830 (const char * const *)&test_buffer,
2831 1,
2832 &i,
2833 &ts_params->def_comp_xform,
2834 &ts_params->def_decomp_xform,
2835 1
2836 };
2837
2838 struct test_data_params test_data = {
2839 .compress_state = RTE_COMP_OP_STATELESS,
2840 .decompress_state = RTE_COMP_OP_STATELESS,
2841 .buff_type = SGL_BOTH,
2842 .zlib_dir = ZLIB_DECOMPRESS,
2843 .out_of_space = 0,
2844 .big_data = 1,
2845 .overflow = OVERFLOW_DISABLED,
2846 .ratio = RATIO_DISABLED
2847 };
2848
2849 ts_params->def_comp_xform->compress.deflate.huffman =
2850 RTE_COMP_HUFFMAN_DYNAMIC;
2851
2852 /* fill the buffer with data based on rand. data */
2853 srand(BIG_DATA_TEST_SIZE);
2854 for (j = 0; j < BIG_DATA_TEST_SIZE - 1; ++j)
2855 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
2856 test_buffer[BIG_DATA_TEST_SIZE - 1] = 0;
2857
2858 /* Compress with compressdev, decompress with Zlib */
2859 test_data.zlib_dir = ZLIB_DECOMPRESS;
2860 ret = test_deflate_comp_decomp(&int_data, &test_data);
2861 if (ret < 0)
2862 goto exit;
2863
2864 /* Compress with Zlib, decompress with compressdev */
2865 test_data.zlib_dir = ZLIB_COMPRESS;
2866 ret = test_deflate_comp_decomp(&int_data, &test_data);
2867 if (ret < 0)
2868 goto exit;
2869
2870 ret = TEST_SUCCESS;
2871
2872 exit:
2873 ts_params->def_comp_xform->compress.deflate.huffman =
2874 RTE_COMP_HUFFMAN_DEFAULT;
2875 rte_free(test_buffer);
2876 return ret;
2877 }
2878
2879 static int
test_compressdev_deflate_stateful_decomp(void)2880 test_compressdev_deflate_stateful_decomp(void)
2881 {
2882 struct comp_testsuite_params *ts_params = &testsuite_params;
2883 int ret;
2884 uint16_t i;
2885 const struct rte_compressdev_capabilities *capab;
2886
2887 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2888 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2889
2890 if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION))
2891 return -ENOTSUP;
2892
2893 struct interim_data_params int_data = {
2894 &compress_test_bufs[0],
2895 1,
2896 &i,
2897 &ts_params->def_comp_xform,
2898 &ts_params->def_decomp_xform,
2899 1
2900 };
2901
2902 struct test_data_params test_data = {
2903 .compress_state = RTE_COMP_OP_STATELESS,
2904 .decompress_state = RTE_COMP_OP_STATEFUL,
2905 .buff_type = LB_BOTH,
2906 .zlib_dir = ZLIB_COMPRESS,
2907 .out_of_space = 0,
2908 .big_data = 0,
2909 .decompress_output_block_size = 2000,
2910 .decompress_steps_max = 4,
2911 .overflow = OVERFLOW_DISABLED,
2912 .ratio = RATIO_ENABLED
2913 };
2914
2915 /* Compress with Zlib, decompress with compressdev */
2916 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2917 ret = TEST_FAILED;
2918 goto exit;
2919 }
2920
2921 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2922 /* Now test with SGL buffers */
2923 test_data.buff_type = SGL_BOTH;
2924 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2925 ret = TEST_FAILED;
2926 goto exit;
2927 }
2928 }
2929
2930 ret = TEST_SUCCESS;
2931
2932 exit:
2933 return ret;
2934 }
2935
2936 static int
test_compressdev_deflate_stateful_decomp_checksum(void)2937 test_compressdev_deflate_stateful_decomp_checksum(void)
2938 {
2939 struct comp_testsuite_params *ts_params = &testsuite_params;
2940 int ret;
2941 uint16_t i;
2942 const struct rte_compressdev_capabilities *capab;
2943
2944 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2945 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2946
2947 if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION))
2948 return -ENOTSUP;
2949
2950 /* Check if driver supports any checksum */
2951 if (!(capab->comp_feature_flags &
2952 (RTE_COMP_FF_CRC32_CHECKSUM | RTE_COMP_FF_ADLER32_CHECKSUM |
2953 RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)))
2954 return -ENOTSUP;
2955
2956 struct rte_comp_xform *compress_xform =
2957 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2958 if (compress_xform == NULL) {
2959 RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
2960 return TEST_FAILED;
2961 }
2962
2963 memcpy(compress_xform, ts_params->def_comp_xform,
2964 sizeof(struct rte_comp_xform));
2965
2966 struct rte_comp_xform *decompress_xform =
2967 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2968 if (decompress_xform == NULL) {
2969 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
2970 rte_free(compress_xform);
2971 return TEST_FAILED;
2972 }
2973
2974 memcpy(decompress_xform, ts_params->def_decomp_xform,
2975 sizeof(struct rte_comp_xform));
2976
2977 struct interim_data_params int_data = {
2978 &compress_test_bufs[0],
2979 1,
2980 &i,
2981 &compress_xform,
2982 &decompress_xform,
2983 1
2984 };
2985
2986 struct test_data_params test_data = {
2987 .compress_state = RTE_COMP_OP_STATELESS,
2988 .decompress_state = RTE_COMP_OP_STATEFUL,
2989 .buff_type = LB_BOTH,
2990 .zlib_dir = ZLIB_COMPRESS,
2991 .out_of_space = 0,
2992 .big_data = 0,
2993 .decompress_output_block_size = 2000,
2994 .decompress_steps_max = 4,
2995 .overflow = OVERFLOW_DISABLED,
2996 .ratio = RATIO_ENABLED
2997 };
2998
2999 /* Check if driver supports crc32 checksum and test */
3000 if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) {
3001 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32;
3002 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32;
3003 /* Compress with Zlib, decompress with compressdev */
3004 test_data.buff_type = LB_BOTH;
3005 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3006 ret = TEST_FAILED;
3007 goto exit;
3008 }
3009 if (capab->comp_feature_flags &
3010 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
3011 /* Now test with SGL buffers */
3012 test_data.buff_type = SGL_BOTH;
3013 if (test_deflate_comp_decomp(&int_data,
3014 &test_data) < 0) {
3015 ret = TEST_FAILED;
3016 goto exit;
3017 }
3018 }
3019 }
3020
3021 /* Check if driver supports adler32 checksum and test */
3022 if (capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM) {
3023 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32;
3024 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32;
3025 /* Compress with Zlib, decompress with compressdev */
3026 test_data.buff_type = LB_BOTH;
3027 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3028 ret = TEST_FAILED;
3029 goto exit;
3030 }
3031 if (capab->comp_feature_flags &
3032 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
3033 /* Now test with SGL buffers */
3034 test_data.buff_type = SGL_BOTH;
3035 if (test_deflate_comp_decomp(&int_data,
3036 &test_data) < 0) {
3037 ret = TEST_FAILED;
3038 goto exit;
3039 }
3040 }
3041 }
3042
3043 /* Check if driver supports combined crc and adler checksum and test */
3044 if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) {
3045 compress_xform->compress.chksum =
3046 RTE_COMP_CHECKSUM_CRC32_ADLER32;
3047 decompress_xform->decompress.chksum =
3048 RTE_COMP_CHECKSUM_CRC32_ADLER32;
3049 /* Zlib doesn't support combined checksum */
3050 test_data.zlib_dir = ZLIB_NONE;
3051 /* Compress stateless, decompress stateful with compressdev */
3052 test_data.buff_type = LB_BOTH;
3053 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3054 ret = TEST_FAILED;
3055 goto exit;
3056 }
3057 if (capab->comp_feature_flags &
3058 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
3059 /* Now test with SGL buffers */
3060 test_data.buff_type = SGL_BOTH;
3061 if (test_deflate_comp_decomp(&int_data,
3062 &test_data) < 0) {
3063 ret = TEST_FAILED;
3064 goto exit;
3065 }
3066 }
3067 }
3068
3069 ret = TEST_SUCCESS;
3070
3071 exit:
3072 rte_free(compress_xform);
3073 rte_free(decompress_xform);
3074 return ret;
3075 }
3076
3077 static const struct rte_memzone *
make_memzone(const char * name,size_t size)3078 make_memzone(const char *name, size_t size)
3079 {
3080 unsigned int socket_id = rte_socket_id();
3081 char mz_name[RTE_MEMZONE_NAMESIZE];
3082 const struct rte_memzone *memzone;
3083
3084 snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_%u", name, socket_id);
3085 memzone = rte_memzone_lookup(mz_name);
3086 if (memzone != NULL && memzone->len != size) {
3087 rte_memzone_free(memzone);
3088 memzone = NULL;
3089 }
3090 if (memzone == NULL) {
3091 memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
3092 RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
3093 if (memzone == NULL)
3094 RTE_LOG(ERR, USER1, "Can't allocate memory zone %s",
3095 mz_name);
3096 }
3097 return memzone;
3098 }
3099
3100 static int
test_compressdev_external_mbufs(void)3101 test_compressdev_external_mbufs(void)
3102 {
3103 struct comp_testsuite_params *ts_params = &testsuite_params;
3104 size_t data_len = 0;
3105 uint16_t i;
3106 int ret = TEST_FAILED;
3107
3108 for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
3109 data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1);
3110
3111 struct interim_data_params int_data = {
3112 NULL,
3113 1,
3114 NULL,
3115 &ts_params->def_comp_xform,
3116 &ts_params->def_decomp_xform,
3117 1
3118 };
3119
3120 struct test_data_params test_data = {
3121 .compress_state = RTE_COMP_OP_STATELESS,
3122 .decompress_state = RTE_COMP_OP_STATELESS,
3123 .buff_type = LB_BOTH,
3124 .zlib_dir = ZLIB_DECOMPRESS,
3125 .out_of_space = 0,
3126 .big_data = 0,
3127 .use_external_mbufs = 1,
3128 .inbuf_data_size = data_len,
3129 .inbuf_memzone = make_memzone("inbuf", data_len),
3130 .compbuf_memzone = make_memzone("compbuf", data_len *
3131 COMPRESS_BUF_SIZE_RATIO),
3132 .uncompbuf_memzone = make_memzone("decompbuf", data_len),
3133 .overflow = OVERFLOW_DISABLED
3134 };
3135
3136 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
3137 /* prepare input data */
3138 data_len = strlen(compress_test_bufs[i]) + 1;
3139 rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i],
3140 data_len);
3141 test_data.inbuf_data_size = data_len;
3142 int_data.buf_idx = &i;
3143
3144 /* Compress with compressdev, decompress with Zlib */
3145 test_data.zlib_dir = ZLIB_DECOMPRESS;
3146 if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
3147 goto exit;
3148
3149 /* Compress with Zlib, decompress with compressdev */
3150 test_data.zlib_dir = ZLIB_COMPRESS;
3151 if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
3152 goto exit;
3153 }
3154
3155 ret = TEST_SUCCESS;
3156
3157 exit:
3158 rte_memzone_free(test_data.inbuf_memzone);
3159 rte_memzone_free(test_data.compbuf_memzone);
3160 rte_memzone_free(test_data.uncompbuf_memzone);
3161 return ret;
3162 }
3163
3164 static int
test_compressdev_deflate_stateless_fixed_oos_recoverable(void)3165 test_compressdev_deflate_stateless_fixed_oos_recoverable(void)
3166 {
3167 struct comp_testsuite_params *ts_params = &testsuite_params;
3168 uint16_t i;
3169 int ret;
3170 int comp_result;
3171 const struct rte_compressdev_capabilities *capab;
3172
3173 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3174 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3175
3176 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
3177 return -ENOTSUP;
3178
3179 struct rte_comp_xform *compress_xform =
3180 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
3181
3182 if (compress_xform == NULL) {
3183 RTE_LOG(ERR, USER1,
3184 "Compress xform could not be created\n");
3185 ret = TEST_FAILED;
3186 goto exit;
3187 }
3188
3189 memcpy(compress_xform, ts_params->def_comp_xform,
3190 sizeof(struct rte_comp_xform));
3191 compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
3192
3193 struct interim_data_params int_data = {
3194 NULL,
3195 1,
3196 NULL,
3197 &compress_xform,
3198 &ts_params->def_decomp_xform,
3199 1
3200 };
3201
3202 struct test_data_params test_data = {
3203 .compress_state = RTE_COMP_OP_STATELESS,
3204 .decompress_state = RTE_COMP_OP_STATELESS,
3205 .buff_type = LB_BOTH,
3206 .zlib_dir = ZLIB_DECOMPRESS,
3207 .out_of_space = 0,
3208 .big_data = 0,
3209 .overflow = OVERFLOW_ENABLED,
3210 .ratio = RATIO_ENABLED
3211 };
3212
3213 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
3214 int_data.test_bufs = &compress_test_bufs[i];
3215 int_data.buf_idx = &i;
3216
3217 /* Compress with compressdev, decompress with Zlib */
3218 test_data.zlib_dir = ZLIB_DECOMPRESS;
3219 comp_result = test_deflate_comp_decomp(&int_data, &test_data);
3220 if (comp_result < 0) {
3221 ret = TEST_FAILED;
3222 goto exit;
3223 } else if (comp_result > 0) {
3224 ret = -ENOTSUP;
3225 goto exit;
3226 }
3227
3228 /* Compress with Zlib, decompress with compressdev */
3229 test_data.zlib_dir = ZLIB_COMPRESS;
3230 comp_result = test_deflate_comp_decomp(&int_data, &test_data);
3231 if (comp_result < 0) {
3232 ret = TEST_FAILED;
3233 goto exit;
3234 } else if (comp_result > 0) {
3235 ret = -ENOTSUP;
3236 goto exit;
3237 }
3238 }
3239
3240 ret = TEST_SUCCESS;
3241
3242 exit:
3243 rte_free(compress_xform);
3244 return ret;
3245 }
3246
3247 static int
test_compressdev_deflate_im_buffers_LB_1op(void)3248 test_compressdev_deflate_im_buffers_LB_1op(void)
3249 {
3250 struct comp_testsuite_params *ts_params = &testsuite_params;
3251 uint16_t i = 0;
3252 int ret = TEST_SUCCESS;
3253 int j;
3254 const struct rte_compressdev_capabilities *capab;
3255 char *test_buffer = NULL;
3256
3257 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3258 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3259
3260 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3261 return -ENOTSUP;
3262
3263 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3264 return -ENOTSUP;
3265
3266 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3267 if (test_buffer == NULL) {
3268 RTE_LOG(ERR, USER1,
3269 "Can't allocate buffer for 'im buffer' test\n");
3270 return TEST_FAILED;
3271 }
3272
3273 struct interim_data_params int_data = {
3274 (const char * const *)&test_buffer,
3275 1,
3276 &i,
3277 &ts_params->def_comp_xform,
3278 &ts_params->def_decomp_xform,
3279 1
3280 };
3281
3282 struct test_data_params test_data = {
3283 .compress_state = RTE_COMP_OP_STATELESS,
3284 .decompress_state = RTE_COMP_OP_STATELESS,
3285 /* must be LB to SGL,
3286 * input LB buffer reaches its maximum,
3287 * if ratio 1.3 than another mbuf must be
3288 * created and attached
3289 */
3290 .buff_type = LB_BOTH,
3291 .zlib_dir = ZLIB_NONE,
3292 .out_of_space = 0,
3293 .big_data = 1,
3294 .overflow = OVERFLOW_DISABLED,
3295 .ratio = RATIO_DISABLED
3296 };
3297
3298 ts_params->def_comp_xform->compress.deflate.huffman =
3299 RTE_COMP_HUFFMAN_DYNAMIC;
3300
3301 /* fill the buffer with data based on rand. data */
3302 srand(IM_BUF_DATA_TEST_SIZE_LB);
3303 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3304 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3305
3306 /* Compress with compressdev, decompress with compressdev */
3307 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3308 ret = TEST_FAILED;
3309 goto end;
3310 }
3311
3312 end:
3313 ts_params->def_comp_xform->compress.deflate.huffman =
3314 RTE_COMP_HUFFMAN_DEFAULT;
3315 rte_free(test_buffer);
3316 return ret;
3317 }
3318
3319 static int
test_compressdev_deflate_im_buffers_LB_2ops_first(void)3320 test_compressdev_deflate_im_buffers_LB_2ops_first(void)
3321 {
3322 struct comp_testsuite_params *ts_params = &testsuite_params;
3323 uint16_t i = 0;
3324 int ret = TEST_SUCCESS;
3325 int j;
3326 const struct rte_compressdev_capabilities *capab;
3327 char *test_buffer = NULL;
3328 const char *test_buffers[2];
3329
3330 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3331 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3332
3333 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3334 return -ENOTSUP;
3335
3336 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3337 return -ENOTSUP;
3338
3339 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3340 if (test_buffer == NULL) {
3341 RTE_LOG(ERR, USER1,
3342 "Can't allocate buffer for 'im buffer' test\n");
3343 return TEST_FAILED;
3344 }
3345
3346 test_buffers[0] = test_buffer;
3347 test_buffers[1] = compress_test_bufs[0];
3348
3349 struct interim_data_params int_data = {
3350 (const char * const *)test_buffers,
3351 2,
3352 &i,
3353 &ts_params->def_comp_xform,
3354 &ts_params->def_decomp_xform,
3355 1
3356 };
3357
3358 struct test_data_params test_data = {
3359 .compress_state = RTE_COMP_OP_STATELESS,
3360 .decompress_state = RTE_COMP_OP_STATELESS,
3361 .buff_type = LB_BOTH,
3362 .zlib_dir = ZLIB_NONE,
3363 .out_of_space = 0,
3364 .big_data = 1,
3365 .overflow = OVERFLOW_DISABLED,
3366 .ratio = RATIO_DISABLED
3367 };
3368
3369 ts_params->def_comp_xform->compress.deflate.huffman =
3370 RTE_COMP_HUFFMAN_DYNAMIC;
3371
3372 /* fill the buffer with data based on rand. data */
3373 srand(IM_BUF_DATA_TEST_SIZE_LB);
3374 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3375 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3376
3377 /* Compress with compressdev, decompress with compressdev */
3378 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3379 ret = TEST_FAILED;
3380 goto end;
3381 }
3382
3383 end:
3384 ts_params->def_comp_xform->compress.deflate.huffman =
3385 RTE_COMP_HUFFMAN_DEFAULT;
3386 rte_free(test_buffer);
3387 return ret;
3388 }
3389
3390 static int
test_compressdev_deflate_im_buffers_LB_2ops_second(void)3391 test_compressdev_deflate_im_buffers_LB_2ops_second(void)
3392 {
3393 struct comp_testsuite_params *ts_params = &testsuite_params;
3394 uint16_t i = 0;
3395 int ret = TEST_SUCCESS;
3396 int j;
3397 const struct rte_compressdev_capabilities *capab;
3398 char *test_buffer = NULL;
3399 const char *test_buffers[2];
3400
3401 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3402 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3403
3404 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3405 return -ENOTSUP;
3406
3407 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3408 return -ENOTSUP;
3409
3410 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3411 if (test_buffer == NULL) {
3412 RTE_LOG(ERR, USER1,
3413 "Can't allocate buffer for 'im buffer' test\n");
3414 return TEST_FAILED;
3415 }
3416
3417 test_buffers[0] = compress_test_bufs[0];
3418 test_buffers[1] = test_buffer;
3419
3420 struct interim_data_params int_data = {
3421 (const char * const *)test_buffers,
3422 2,
3423 &i,
3424 &ts_params->def_comp_xform,
3425 &ts_params->def_decomp_xform,
3426 1
3427 };
3428
3429 struct test_data_params test_data = {
3430 .compress_state = RTE_COMP_OP_STATELESS,
3431 .decompress_state = RTE_COMP_OP_STATELESS,
3432 .buff_type = LB_BOTH,
3433 .zlib_dir = ZLIB_NONE,
3434 .out_of_space = 0,
3435 .big_data = 1,
3436 .overflow = OVERFLOW_DISABLED,
3437 .ratio = RATIO_DISABLED
3438 };
3439
3440 ts_params->def_comp_xform->compress.deflate.huffman =
3441 RTE_COMP_HUFFMAN_DYNAMIC;
3442
3443 /* fill the buffer with data based on rand. data */
3444 srand(IM_BUF_DATA_TEST_SIZE_LB);
3445 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3446 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3447
3448 /* Compress with compressdev, decompress with compressdev */
3449 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3450 ret = TEST_FAILED;
3451 goto end;
3452 }
3453
3454 end:
3455 ts_params->def_comp_xform->compress.deflate.huffman =
3456 RTE_COMP_HUFFMAN_DEFAULT;
3457 rte_free(test_buffer);
3458 return ret;
3459 }
3460
3461 static int
test_compressdev_deflate_im_buffers_LB_3ops(void)3462 test_compressdev_deflate_im_buffers_LB_3ops(void)
3463 {
3464 struct comp_testsuite_params *ts_params = &testsuite_params;
3465 uint16_t i = 0;
3466 int ret = TEST_SUCCESS;
3467 int j;
3468 const struct rte_compressdev_capabilities *capab;
3469 char *test_buffer = NULL;
3470 const char *test_buffers[3];
3471
3472 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3473 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3474
3475 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3476 return -ENOTSUP;
3477
3478 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3479 return -ENOTSUP;
3480
3481 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3482 if (test_buffer == NULL) {
3483 RTE_LOG(ERR, USER1,
3484 "Can't allocate buffer for 'im buffer' test\n");
3485 return TEST_FAILED;
3486 }
3487
3488 test_buffers[0] = compress_test_bufs[0];
3489 test_buffers[1] = test_buffer;
3490 test_buffers[2] = compress_test_bufs[1];
3491
3492 struct interim_data_params int_data = {
3493 (const char * const *)test_buffers,
3494 3,
3495 &i,
3496 &ts_params->def_comp_xform,
3497 &ts_params->def_decomp_xform,
3498 1
3499 };
3500
3501 struct test_data_params test_data = {
3502 .compress_state = RTE_COMP_OP_STATELESS,
3503 .decompress_state = RTE_COMP_OP_STATELESS,
3504 .buff_type = LB_BOTH,
3505 .zlib_dir = ZLIB_NONE,
3506 .out_of_space = 0,
3507 .big_data = 1,
3508 .overflow = OVERFLOW_DISABLED,
3509 .ratio = RATIO_DISABLED
3510 };
3511
3512 ts_params->def_comp_xform->compress.deflate.huffman =
3513 RTE_COMP_HUFFMAN_DYNAMIC;
3514
3515 /* fill the buffer with data based on rand. data */
3516 srand(IM_BUF_DATA_TEST_SIZE_LB);
3517 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3518 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3519
3520 /* Compress with compressdev, decompress with compressdev */
3521 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3522 ret = TEST_FAILED;
3523 goto end;
3524 }
3525
3526 end:
3527 ts_params->def_comp_xform->compress.deflate.huffman =
3528 RTE_COMP_HUFFMAN_DEFAULT;
3529 rte_free(test_buffer);
3530 return ret;
3531 }
3532
3533 static int
test_compressdev_deflate_im_buffers_LB_4ops(void)3534 test_compressdev_deflate_im_buffers_LB_4ops(void)
3535 {
3536 struct comp_testsuite_params *ts_params = &testsuite_params;
3537 uint16_t i = 0;
3538 int ret = TEST_SUCCESS;
3539 int j;
3540 const struct rte_compressdev_capabilities *capab;
3541 char *test_buffer = NULL;
3542 const char *test_buffers[4];
3543
3544 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3545 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3546
3547 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3548 return -ENOTSUP;
3549
3550 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3551 return -ENOTSUP;
3552
3553 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3554 if (test_buffer == NULL) {
3555 RTE_LOG(ERR, USER1,
3556 "Can't allocate buffer for 'im buffer' test\n");
3557 return TEST_FAILED;
3558 }
3559
3560 test_buffers[0] = compress_test_bufs[0];
3561 test_buffers[1] = test_buffer;
3562 test_buffers[2] = compress_test_bufs[1];
3563 test_buffers[3] = test_buffer;
3564
3565 struct interim_data_params int_data = {
3566 (const char * const *)test_buffers,
3567 4,
3568 &i,
3569 &ts_params->def_comp_xform,
3570 &ts_params->def_decomp_xform,
3571 1
3572 };
3573
3574 struct test_data_params test_data = {
3575 .compress_state = RTE_COMP_OP_STATELESS,
3576 .decompress_state = RTE_COMP_OP_STATELESS,
3577 .buff_type = LB_BOTH,
3578 .zlib_dir = ZLIB_NONE,
3579 .out_of_space = 0,
3580 .big_data = 1,
3581 .overflow = OVERFLOW_DISABLED,
3582 .ratio = RATIO_DISABLED
3583 };
3584
3585 ts_params->def_comp_xform->compress.deflate.huffman =
3586 RTE_COMP_HUFFMAN_DYNAMIC;
3587
3588 /* fill the buffer with data based on rand. data */
3589 srand(IM_BUF_DATA_TEST_SIZE_LB);
3590 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3591 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3592
3593 /* Compress with compressdev, decompress with compressdev */
3594 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3595 ret = TEST_FAILED;
3596 goto end;
3597 }
3598
3599 end:
3600 ts_params->def_comp_xform->compress.deflate.huffman =
3601 RTE_COMP_HUFFMAN_DEFAULT;
3602 rte_free(test_buffer);
3603 return ret;
3604 }
3605
3606
3607 static int
test_compressdev_deflate_im_buffers_SGL_1op(void)3608 test_compressdev_deflate_im_buffers_SGL_1op(void)
3609 {
3610 struct comp_testsuite_params *ts_params = &testsuite_params;
3611 uint16_t i = 0;
3612 int ret = TEST_SUCCESS;
3613 int j;
3614 const struct rte_compressdev_capabilities *capab;
3615 char *test_buffer = NULL;
3616
3617 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3618 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3619
3620 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3621 return -ENOTSUP;
3622
3623 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3624 return -ENOTSUP;
3625
3626 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3627 if (test_buffer == NULL) {
3628 RTE_LOG(ERR, USER1,
3629 "Can't allocate buffer for big-data\n");
3630 return TEST_FAILED;
3631 }
3632
3633 struct interim_data_params int_data = {
3634 (const char * const *)&test_buffer,
3635 1,
3636 &i,
3637 &ts_params->def_comp_xform,
3638 &ts_params->def_decomp_xform,
3639 1
3640 };
3641
3642 struct test_data_params test_data = {
3643 .compress_state = RTE_COMP_OP_STATELESS,
3644 .decompress_state = RTE_COMP_OP_STATELESS,
3645 .buff_type = SGL_BOTH,
3646 .zlib_dir = ZLIB_NONE,
3647 .out_of_space = 0,
3648 .big_data = 1,
3649 .overflow = OVERFLOW_DISABLED,
3650 .ratio = RATIO_DISABLED
3651 };
3652
3653 ts_params->def_comp_xform->compress.deflate.huffman =
3654 RTE_COMP_HUFFMAN_DYNAMIC;
3655
3656 /* fill the buffer with data based on rand. data */
3657 srand(IM_BUF_DATA_TEST_SIZE_SGL);
3658 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3659 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3660
3661 /* Compress with compressdev, decompress with compressdev */
3662 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3663 ret = TEST_FAILED;
3664 goto end;
3665 }
3666
3667 end:
3668 ts_params->def_comp_xform->compress.deflate.huffman =
3669 RTE_COMP_HUFFMAN_DEFAULT;
3670 rte_free(test_buffer);
3671 return ret;
3672 }
3673
3674 static int
test_compressdev_deflate_im_buffers_SGL_2ops_first(void)3675 test_compressdev_deflate_im_buffers_SGL_2ops_first(void)
3676 {
3677 struct comp_testsuite_params *ts_params = &testsuite_params;
3678 uint16_t i = 0;
3679 int ret = TEST_SUCCESS;
3680 int j;
3681 const struct rte_compressdev_capabilities *capab;
3682 char *test_buffer = NULL;
3683 const char *test_buffers[2];
3684
3685 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3686 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3687
3688 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3689 return -ENOTSUP;
3690
3691 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3692 return -ENOTSUP;
3693
3694 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3695 if (test_buffer == NULL) {
3696 RTE_LOG(ERR, USER1,
3697 "Can't allocate buffer for big-data\n");
3698 return TEST_FAILED;
3699 }
3700
3701 test_buffers[0] = test_buffer;
3702 test_buffers[1] = compress_test_bufs[0];
3703
3704 struct interim_data_params int_data = {
3705 (const char * const *)test_buffers,
3706 2,
3707 &i,
3708 &ts_params->def_comp_xform,
3709 &ts_params->def_decomp_xform,
3710 1
3711 };
3712
3713 struct test_data_params test_data = {
3714 .compress_state = RTE_COMP_OP_STATELESS,
3715 .decompress_state = RTE_COMP_OP_STATELESS,
3716 .buff_type = SGL_BOTH,
3717 .zlib_dir = ZLIB_NONE,
3718 .out_of_space = 0,
3719 .big_data = 1,
3720 .overflow = OVERFLOW_DISABLED,
3721 .ratio = RATIO_DISABLED
3722 };
3723
3724 ts_params->def_comp_xform->compress.deflate.huffman =
3725 RTE_COMP_HUFFMAN_DYNAMIC;
3726
3727 /* fill the buffer with data based on rand. data */
3728 srand(IM_BUF_DATA_TEST_SIZE_SGL);
3729 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3730 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3731
3732 /* Compress with compressdev, decompress with compressdev */
3733 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3734 ret = TEST_FAILED;
3735 goto end;
3736 }
3737
3738 end:
3739 ts_params->def_comp_xform->compress.deflate.huffman =
3740 RTE_COMP_HUFFMAN_DEFAULT;
3741 rte_free(test_buffer);
3742 return ret;
3743 }
3744
3745 static int
test_compressdev_deflate_im_buffers_SGL_2ops_second(void)3746 test_compressdev_deflate_im_buffers_SGL_2ops_second(void)
3747 {
3748 struct comp_testsuite_params *ts_params = &testsuite_params;
3749 uint16_t i = 0;
3750 int ret = TEST_SUCCESS;
3751 int j;
3752 const struct rte_compressdev_capabilities *capab;
3753 char *test_buffer = NULL;
3754 const char *test_buffers[2];
3755
3756 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3757 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3758
3759 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3760 return -ENOTSUP;
3761
3762 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3763 return -ENOTSUP;
3764
3765 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3766 if (test_buffer == NULL) {
3767 RTE_LOG(ERR, USER1,
3768 "Can't allocate buffer for big-data\n");
3769 return TEST_FAILED;
3770 }
3771
3772 test_buffers[0] = compress_test_bufs[0];
3773 test_buffers[1] = test_buffer;
3774
3775 struct interim_data_params int_data = {
3776 (const char * const *)test_buffers,
3777 2,
3778 &i,
3779 &ts_params->def_comp_xform,
3780 &ts_params->def_decomp_xform,
3781 1
3782 };
3783
3784 struct test_data_params test_data = {
3785 .compress_state = RTE_COMP_OP_STATELESS,
3786 .decompress_state = RTE_COMP_OP_STATELESS,
3787 .buff_type = SGL_BOTH,
3788 .zlib_dir = ZLIB_NONE,
3789 .out_of_space = 0,
3790 .big_data = 1,
3791 .overflow = OVERFLOW_DISABLED,
3792 .ratio = RATIO_DISABLED
3793 };
3794
3795 ts_params->def_comp_xform->compress.deflate.huffman =
3796 RTE_COMP_HUFFMAN_DYNAMIC;
3797
3798 /* fill the buffer with data based on rand. data */
3799 srand(IM_BUF_DATA_TEST_SIZE_SGL);
3800 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3801 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3802
3803 /* Compress with compressdev, decompress with compressdev */
3804 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3805 ret = TEST_FAILED;
3806 goto end;
3807 }
3808
3809 end:
3810 ts_params->def_comp_xform->compress.deflate.huffman =
3811 RTE_COMP_HUFFMAN_DEFAULT;
3812 rte_free(test_buffer);
3813 return ret;
3814 }
3815
3816 static int
test_compressdev_deflate_im_buffers_SGL_3ops(void)3817 test_compressdev_deflate_im_buffers_SGL_3ops(void)
3818 {
3819 struct comp_testsuite_params *ts_params = &testsuite_params;
3820 uint16_t i = 0;
3821 int ret = TEST_SUCCESS;
3822 int j;
3823 const struct rte_compressdev_capabilities *capab;
3824 char *test_buffer = NULL;
3825 const char *test_buffers[3];
3826
3827 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3828 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3829
3830 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3831 return -ENOTSUP;
3832
3833 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3834 return -ENOTSUP;
3835
3836 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3837 if (test_buffer == NULL) {
3838 RTE_LOG(ERR, USER1,
3839 "Can't allocate buffer for big-data\n");
3840 return TEST_FAILED;
3841 }
3842
3843 test_buffers[0] = compress_test_bufs[0];
3844 test_buffers[1] = test_buffer;
3845 test_buffers[2] = compress_test_bufs[1];
3846
3847 struct interim_data_params int_data = {
3848 (const char * const *)test_buffers,
3849 3,
3850 &i,
3851 &ts_params->def_comp_xform,
3852 &ts_params->def_decomp_xform,
3853 1
3854 };
3855
3856 struct test_data_params test_data = {
3857 .compress_state = RTE_COMP_OP_STATELESS,
3858 .decompress_state = RTE_COMP_OP_STATELESS,
3859 .buff_type = SGL_BOTH,
3860 .zlib_dir = ZLIB_NONE,
3861 .out_of_space = 0,
3862 .big_data = 1,
3863 .overflow = OVERFLOW_DISABLED,
3864 .ratio = RATIO_DISABLED
3865 };
3866
3867 ts_params->def_comp_xform->compress.deflate.huffman =
3868 RTE_COMP_HUFFMAN_DYNAMIC;
3869
3870 /* fill the buffer with data based on rand. data */
3871 srand(IM_BUF_DATA_TEST_SIZE_SGL);
3872 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3873 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3874
3875 /* Compress with compressdev, decompress with compressdev */
3876 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3877 ret = TEST_FAILED;
3878 goto end;
3879 }
3880
3881 end:
3882 ts_params->def_comp_xform->compress.deflate.huffman =
3883 RTE_COMP_HUFFMAN_DEFAULT;
3884 rte_free(test_buffer);
3885 return ret;
3886 }
3887
3888
3889 static int
test_compressdev_deflate_im_buffers_SGL_4ops(void)3890 test_compressdev_deflate_im_buffers_SGL_4ops(void)
3891 {
3892 struct comp_testsuite_params *ts_params = &testsuite_params;
3893 uint16_t i = 0;
3894 int ret = TEST_SUCCESS;
3895 int j;
3896 const struct rte_compressdev_capabilities *capab;
3897 char *test_buffer = NULL;
3898 const char *test_buffers[4];
3899
3900 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3901 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3902
3903 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3904 return -ENOTSUP;
3905
3906 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3907 return -ENOTSUP;
3908
3909 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3910 if (test_buffer == NULL) {
3911 RTE_LOG(ERR, USER1,
3912 "Can't allocate buffer for big-data\n");
3913 return TEST_FAILED;
3914 }
3915
3916 test_buffers[0] = compress_test_bufs[0];
3917 test_buffers[1] = test_buffer;
3918 test_buffers[2] = compress_test_bufs[1];
3919 test_buffers[3] = test_buffer;
3920
3921 struct interim_data_params int_data = {
3922 (const char * const *)test_buffers,
3923 4,
3924 &i,
3925 &ts_params->def_comp_xform,
3926 &ts_params->def_decomp_xform,
3927 1
3928 };
3929
3930 struct test_data_params test_data = {
3931 .compress_state = RTE_COMP_OP_STATELESS,
3932 .decompress_state = RTE_COMP_OP_STATELESS,
3933 .buff_type = SGL_BOTH,
3934 .zlib_dir = ZLIB_NONE,
3935 .out_of_space = 0,
3936 .big_data = 1,
3937 .overflow = OVERFLOW_DISABLED,
3938 .ratio = RATIO_DISABLED
3939 };
3940
3941 ts_params->def_comp_xform->compress.deflate.huffman =
3942 RTE_COMP_HUFFMAN_DYNAMIC;
3943
3944 /* fill the buffer with data based on rand. data */
3945 srand(IM_BUF_DATA_TEST_SIZE_SGL);
3946 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3947 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3948
3949 /* Compress with compressdev, decompress with compressdev */
3950 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3951 ret = TEST_FAILED;
3952 goto end;
3953 }
3954
3955 end:
3956 ts_params->def_comp_xform->compress.deflate.huffman =
3957 RTE_COMP_HUFFMAN_DEFAULT;
3958 rte_free(test_buffer);
3959 return ret;
3960 }
3961
3962 static int
test_compressdev_deflate_im_buffers_SGL_over_1op(void)3963 test_compressdev_deflate_im_buffers_SGL_over_1op(void)
3964 {
3965 struct comp_testsuite_params *ts_params = &testsuite_params;
3966 uint16_t i = 0;
3967 int ret = TEST_SUCCESS;
3968 int j;
3969 const struct rte_compressdev_capabilities *capab;
3970 char *test_buffer = NULL;
3971
3972 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
3973
3974 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3975 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3976
3977 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3978 return -ENOTSUP;
3979
3980 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3981 return -ENOTSUP;
3982
3983 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_OVER, 0);
3984 if (test_buffer == NULL) {
3985 RTE_LOG(ERR, USER1,
3986 "Can't allocate buffer for big-data\n");
3987 return TEST_FAILED;
3988 }
3989
3990 struct interim_data_params int_data = {
3991 (const char * const *)&test_buffer,
3992 1,
3993 &i,
3994 &ts_params->def_comp_xform,
3995 &ts_params->def_decomp_xform,
3996 1
3997 };
3998
3999 struct test_data_params test_data = {
4000 .compress_state = RTE_COMP_OP_STATELESS,
4001 .decompress_state = RTE_COMP_OP_STATELESS,
4002 .buff_type = SGL_BOTH,
4003 .zlib_dir = ZLIB_NONE,
4004 .out_of_space = 0,
4005 .big_data = 1,
4006 .overflow = OVERFLOW_DISABLED,
4007 .ratio = RATIO_DISABLED
4008 };
4009
4010 ts_params->def_comp_xform->compress.deflate.huffman =
4011 RTE_COMP_HUFFMAN_DYNAMIC;
4012
4013 /* fill the buffer with data based on rand. data */
4014 srand(IM_BUF_DATA_TEST_SIZE_OVER);
4015 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_OVER - 1; ++j)
4016 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
4017
4018 /* Compress with compressdev, decompress with compressdev */
4019 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
4020 ret = TEST_SUCCESS;
4021 goto end;
4022 }
4023
4024 end:
4025 ts_params->def_comp_xform->compress.deflate.huffman =
4026 RTE_COMP_HUFFMAN_DEFAULT;
4027 rte_free(test_buffer);
4028
4029 return ret;
4030 }
4031
4032
4033 static int
test_compressdev_deflate_im_buffers_SGL_over_2ops_first(void)4034 test_compressdev_deflate_im_buffers_SGL_over_2ops_first(void)
4035 {
4036 struct comp_testsuite_params *ts_params = &testsuite_params;
4037 uint16_t i = 0;
4038 int ret = TEST_SUCCESS;
4039 int j;
4040 const struct rte_compressdev_capabilities *capab;
4041 char *test_buffer = NULL;
4042 const char *test_buffers[2];
4043
4044 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
4045
4046 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
4047 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
4048
4049 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
4050 return -ENOTSUP;
4051
4052 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
4053 return -ENOTSUP;
4054
4055 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_OVER, 0);
4056 if (test_buffer == NULL) {
4057 RTE_LOG(ERR, USER1,
4058 "Can't allocate buffer for big-data\n");
4059 return TEST_FAILED;
4060 }
4061
4062 test_buffers[0] = test_buffer;
4063 test_buffers[1] = compress_test_bufs[0];
4064
4065 struct interim_data_params int_data = {
4066 (const char * const *)test_buffers,
4067 2,
4068 &i,
4069 &ts_params->def_comp_xform,
4070 &ts_params->def_decomp_xform,
4071 1
4072 };
4073
4074 struct test_data_params test_data = {
4075 .compress_state = RTE_COMP_OP_STATELESS,
4076 .decompress_state = RTE_COMP_OP_STATELESS,
4077 .buff_type = SGL_BOTH,
4078 .zlib_dir = ZLIB_NONE,
4079 .out_of_space = 0,
4080 .big_data = 1,
4081 .overflow = OVERFLOW_DISABLED,
4082 .ratio = RATIO_DISABLED
4083 };
4084
4085 ts_params->def_comp_xform->compress.deflate.huffman =
4086 RTE_COMP_HUFFMAN_DYNAMIC;
4087
4088 /* fill the buffer with data based on rand. data */
4089 srand(IM_BUF_DATA_TEST_SIZE_OVER);
4090 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_OVER - 1; ++j)
4091 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
4092
4093 /* Compress with compressdev, decompress with compressdev */
4094 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
4095 ret = TEST_SUCCESS;
4096 goto end;
4097 }
4098
4099 end:
4100 ts_params->def_comp_xform->compress.deflate.huffman =
4101 RTE_COMP_HUFFMAN_DEFAULT;
4102 rte_free(test_buffer);
4103 return ret;
4104 }
4105
4106 static int
test_compressdev_deflate_im_buffers_SGL_over_2ops_second(void)4107 test_compressdev_deflate_im_buffers_SGL_over_2ops_second(void)
4108 {
4109 struct comp_testsuite_params *ts_params = &testsuite_params;
4110 uint16_t i = 0;
4111 int ret = TEST_SUCCESS;
4112 int j;
4113 const struct rte_compressdev_capabilities *capab;
4114 char *test_buffer = NULL;
4115 const char *test_buffers[2];
4116
4117 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
4118
4119 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
4120 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
4121
4122 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
4123 return -ENOTSUP;
4124
4125 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
4126 return -ENOTSUP;
4127
4128 test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_OVER, 0);
4129 if (test_buffer == NULL) {
4130 RTE_LOG(ERR, USER1,
4131 "Can't allocate buffer for big-data\n");
4132 return TEST_FAILED;
4133 }
4134
4135 test_buffers[0] = compress_test_bufs[0];
4136 test_buffers[1] = test_buffer;
4137
4138 struct interim_data_params int_data = {
4139 (const char * const *)test_buffers,
4140 2,
4141 &i,
4142 &ts_params->def_comp_xform,
4143 &ts_params->def_decomp_xform,
4144 1
4145 };
4146
4147 struct test_data_params test_data = {
4148 .compress_state = RTE_COMP_OP_STATELESS,
4149 .decompress_state = RTE_COMP_OP_STATELESS,
4150 .buff_type = SGL_BOTH,
4151 .zlib_dir = ZLIB_NONE,
4152 .out_of_space = 0,
4153 .big_data = 1,
4154 .overflow = OVERFLOW_DISABLED,
4155 .ratio = RATIO_DISABLED
4156 };
4157
4158 ts_params->def_comp_xform->compress.deflate.huffman =
4159 RTE_COMP_HUFFMAN_DYNAMIC;
4160
4161 /* fill the buffer with data based on rand. data */
4162 srand(IM_BUF_DATA_TEST_SIZE_OVER);
4163 for (j = 0; j < IM_BUF_DATA_TEST_SIZE_OVER - 1; ++j)
4164 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
4165
4166 /* Compress with compressdev, decompress with compressdev */
4167 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
4168 ret = TEST_SUCCESS;
4169 goto end;
4170 }
4171
4172 end:
4173 ts_params->def_comp_xform->compress.deflate.huffman =
4174 RTE_COMP_HUFFMAN_DEFAULT;
4175 rte_free(test_buffer);
4176 return ret;
4177 }
4178
4179 static struct unit_test_suite compressdev_testsuite = {
4180 .suite_name = "compressdev unit test suite",
4181 .setup = testsuite_setup,
4182 .teardown = testsuite_teardown,
4183 .unit_test_cases = {
4184 TEST_CASE_ST(NULL, NULL,
4185 test_compressdev_invalid_configuration),
4186 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4187 test_compressdev_deflate_stateless_fixed),
4188 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4189 test_compressdev_deflate_stateless_dynamic),
4190 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4191 test_compressdev_deflate_stateless_dynamic_big),
4192 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4193 test_compressdev_deflate_stateless_multi_op),
4194 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4195 test_compressdev_deflate_stateless_multi_level),
4196 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4197 test_compressdev_deflate_stateless_multi_xform),
4198 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4199 test_compressdev_deflate_stateless_sgl),
4200 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4201 test_compressdev_deflate_stateless_checksum),
4202 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4203 test_compressdev_out_of_space_buffer),
4204 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4205 test_compressdev_deflate_stateful_decomp),
4206 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4207 test_compressdev_deflate_stateful_decomp_checksum),
4208 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4209 test_compressdev_external_mbufs),
4210 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4211 test_compressdev_deflate_stateless_fixed_oos_recoverable),
4212
4213 /* Positive test cases for IM buffer handling verification */
4214 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4215 test_compressdev_deflate_im_buffers_LB_1op),
4216 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4217 test_compressdev_deflate_im_buffers_LB_2ops_first),
4218 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4219 test_compressdev_deflate_im_buffers_LB_2ops_second),
4220 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4221 test_compressdev_deflate_im_buffers_LB_3ops),
4222
4223 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4224 test_compressdev_deflate_im_buffers_LB_4ops),
4225 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4226 test_compressdev_deflate_im_buffers_SGL_1op),
4227
4228 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4229 test_compressdev_deflate_im_buffers_SGL_2ops_first),
4230 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4231 test_compressdev_deflate_im_buffers_SGL_2ops_second),
4232 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4233 test_compressdev_deflate_im_buffers_SGL_3ops),
4234 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4235 test_compressdev_deflate_im_buffers_SGL_4ops),
4236
4237 /* Negative test cases for IM buffer handling verification */
4238
4239 /* For this test huge mempool is necessary.
4240 * It tests one case:
4241 * only one op containing big amount of data, so that
4242 * number of requested descriptors higher than number
4243 * of available descriptors (128)
4244 */
4245 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4246 test_compressdev_deflate_im_buffers_SGL_over_1op),
4247
4248 /* For this test huge mempool is necessary.
4249 * 2 ops. First op contains big amount of data:
4250 * number of requested descriptors higher than number
4251 * of available descriptors (128), the second op is
4252 * relatively small. In this case both ops are rejected
4253 */
4254 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4255 test_compressdev_deflate_im_buffers_SGL_over_2ops_first),
4256
4257 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4258 test_compressdev_deflate_im_buffers_SGL_over_2ops_second),
4259
4260 TEST_CASES_END() /**< NULL terminate unit test array */
4261 }
4262 };
4263
4264 static int
test_compressdev(void)4265 test_compressdev(void)
4266 {
4267 return unit_test_suite_runner(&compressdev_testsuite);
4268 }
4269
4270 REGISTER_FAST_TEST(compressdev_autotest, false, true, test_compressdev);
4271