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 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 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 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 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 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 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 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 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 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 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 781 extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused) 782 { 783 } 784 785 static int 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 * 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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