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 10 #include <rte_cycles.h> 11 #include <rte_malloc.h> 12 #include <rte_mempool.h> 13 #include <rte_mbuf.h> 14 #include <rte_compressdev.h> 15 #include <rte_string_fns.h> 16 17 #include "test_compressdev_test_buffer.h" 18 #include "test.h" 19 20 #define DIV_CEIL(a, b) ((a) / (b) + ((a) % (b) != 0)) 21 22 #define DEFAULT_WINDOW_SIZE 15 23 #define DEFAULT_MEM_LEVEL 8 24 #define MAX_DEQD_RETRIES 10 25 #define DEQUEUE_WAIT_TIME 10000 26 27 /* 28 * 30% extra size for compressed data compared to original data, 29 * in case data size cannot be reduced and it is actually bigger 30 * due to the compress block headers 31 */ 32 #define COMPRESS_BUF_SIZE_RATIO 1.3 33 #define NUM_LARGE_MBUFS 16 34 #define SMALL_SEG_SIZE 256 35 #define MAX_SEGS 16 36 #define NUM_OPS 16 37 #define NUM_MAX_XFORMS 16 38 #define NUM_MAX_INFLIGHT_OPS 128 39 #define CACHE_SIZE 0 40 41 #define ZLIB_CRC_CHECKSUM_WINDOW_BITS 31 42 #define ZLIB_HEADER_SIZE 2 43 #define ZLIB_TRAILER_SIZE 4 44 #define GZIP_HEADER_SIZE 10 45 #define GZIP_TRAILER_SIZE 8 46 47 #define OUT_OF_SPACE_BUF 1 48 49 #define MAX_MBUF_SEGMENT_SIZE 65535 50 #define MAX_DATA_MBUF_SIZE (MAX_MBUF_SEGMENT_SIZE - RTE_PKTMBUF_HEADROOM) 51 #define NUM_BIG_MBUFS 4 52 #define BIG_DATA_TEST_SIZE (MAX_DATA_MBUF_SIZE * NUM_BIG_MBUFS / 2) 53 54 const char * 55 huffman_type_strings[] = { 56 [RTE_COMP_HUFFMAN_DEFAULT] = "PMD default", 57 [RTE_COMP_HUFFMAN_FIXED] = "Fixed", 58 [RTE_COMP_HUFFMAN_DYNAMIC] = "Dynamic" 59 }; 60 61 enum zlib_direction { 62 ZLIB_NONE, 63 ZLIB_COMPRESS, 64 ZLIB_DECOMPRESS, 65 ZLIB_ALL 66 }; 67 68 enum varied_buff { 69 LB_BOTH = 0, /* both input and output are linear*/ 70 SGL_BOTH, /* both input and output are chained */ 71 SGL_TO_LB, /* input buffer is chained */ 72 LB_TO_SGL /* output buffer is chained */ 73 }; 74 75 struct priv_op_data { 76 uint16_t orig_idx; 77 }; 78 79 struct comp_testsuite_params { 80 struct rte_mempool *large_mbuf_pool; 81 struct rte_mempool *small_mbuf_pool; 82 struct rte_mempool *big_mbuf_pool; 83 struct rte_mempool *op_pool; 84 struct rte_comp_xform *def_comp_xform; 85 struct rte_comp_xform *def_decomp_xform; 86 }; 87 88 struct interim_data_params { 89 const char * const *test_bufs; 90 unsigned int num_bufs; 91 uint16_t *buf_idx; 92 struct rte_comp_xform **compress_xforms; 93 struct rte_comp_xform **decompress_xforms; 94 unsigned int num_xforms; 95 }; 96 97 struct test_data_params { 98 enum rte_comp_op_type state; 99 enum varied_buff buff_type; 100 enum zlib_direction zlib_dir; 101 unsigned int out_of_space; 102 unsigned int big_data; 103 }; 104 105 static struct comp_testsuite_params testsuite_params = { 0 }; 106 107 static void 108 testsuite_teardown(void) 109 { 110 struct comp_testsuite_params *ts_params = &testsuite_params; 111 112 if (rte_mempool_in_use_count(ts_params->large_mbuf_pool)) 113 RTE_LOG(ERR, USER1, "Large mbuf pool still has unfreed bufs\n"); 114 if (rte_mempool_in_use_count(ts_params->small_mbuf_pool)) 115 RTE_LOG(ERR, USER1, "Small mbuf pool still has unfreed bufs\n"); 116 if (rte_mempool_in_use_count(ts_params->big_mbuf_pool)) 117 RTE_LOG(ERR, USER1, "Big mbuf pool still has unfreed bufs\n"); 118 if (rte_mempool_in_use_count(ts_params->op_pool)) 119 RTE_LOG(ERR, USER1, "op pool still has unfreed ops\n"); 120 121 rte_mempool_free(ts_params->large_mbuf_pool); 122 rte_mempool_free(ts_params->small_mbuf_pool); 123 rte_mempool_free(ts_params->big_mbuf_pool); 124 rte_mempool_free(ts_params->op_pool); 125 rte_free(ts_params->def_comp_xform); 126 rte_free(ts_params->def_decomp_xform); 127 } 128 129 static int 130 testsuite_setup(void) 131 { 132 struct comp_testsuite_params *ts_params = &testsuite_params; 133 uint32_t max_buf_size = 0; 134 unsigned int i; 135 136 if (rte_compressdev_count() == 0) { 137 RTE_LOG(WARNING, USER1, "Need at least one compress device\n"); 138 return TEST_SKIPPED; 139 } 140 141 RTE_LOG(NOTICE, USER1, "Running tests on device %s\n", 142 rte_compressdev_name_get(0)); 143 144 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) 145 max_buf_size = RTE_MAX(max_buf_size, 146 strlen(compress_test_bufs[i]) + 1); 147 148 /* 149 * Buffers to be used in compression and decompression. 150 * Since decompressed data might be larger than 151 * compressed data (due to block header), 152 * buffers should be big enough for both cases. 153 */ 154 max_buf_size *= COMPRESS_BUF_SIZE_RATIO; 155 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create("large_mbuf_pool", 156 NUM_LARGE_MBUFS, 157 CACHE_SIZE, 0, 158 max_buf_size + RTE_PKTMBUF_HEADROOM, 159 rte_socket_id()); 160 if (ts_params->large_mbuf_pool == NULL) { 161 RTE_LOG(ERR, USER1, "Large mbuf pool could not be created\n"); 162 return TEST_FAILED; 163 } 164 165 /* Create mempool with smaller buffers for SGL testing */ 166 ts_params->small_mbuf_pool = rte_pktmbuf_pool_create("small_mbuf_pool", 167 NUM_LARGE_MBUFS * MAX_SEGS, 168 CACHE_SIZE, 0, 169 SMALL_SEG_SIZE + RTE_PKTMBUF_HEADROOM, 170 rte_socket_id()); 171 if (ts_params->small_mbuf_pool == NULL) { 172 RTE_LOG(ERR, USER1, "Small mbuf pool could not be created\n"); 173 goto exit; 174 } 175 176 /* Create mempool with big buffers for SGL testing */ 177 ts_params->big_mbuf_pool = rte_pktmbuf_pool_create("big_mbuf_pool", 178 NUM_BIG_MBUFS + 1, 179 CACHE_SIZE, 0, 180 MAX_MBUF_SEGMENT_SIZE, 181 rte_socket_id()); 182 if (ts_params->big_mbuf_pool == NULL) { 183 RTE_LOG(ERR, USER1, "Big mbuf pool could not be created\n"); 184 goto exit; 185 } 186 187 ts_params->op_pool = rte_comp_op_pool_create("op_pool", NUM_OPS, 188 0, sizeof(struct priv_op_data), 189 rte_socket_id()); 190 if (ts_params->op_pool == NULL) { 191 RTE_LOG(ERR, USER1, "Operation pool could not be created\n"); 192 goto exit; 193 } 194 195 ts_params->def_comp_xform = 196 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 197 if (ts_params->def_comp_xform == NULL) { 198 RTE_LOG(ERR, USER1, 199 "Default compress xform could not be created\n"); 200 goto exit; 201 } 202 ts_params->def_decomp_xform = 203 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 204 if (ts_params->def_decomp_xform == NULL) { 205 RTE_LOG(ERR, USER1, 206 "Default decompress xform could not be created\n"); 207 goto exit; 208 } 209 210 /* Initializes default values for compress/decompress xforms */ 211 ts_params->def_comp_xform->type = RTE_COMP_COMPRESS; 212 ts_params->def_comp_xform->compress.algo = RTE_COMP_ALGO_DEFLATE, 213 ts_params->def_comp_xform->compress.deflate.huffman = 214 RTE_COMP_HUFFMAN_DEFAULT; 215 ts_params->def_comp_xform->compress.level = RTE_COMP_LEVEL_PMD_DEFAULT; 216 ts_params->def_comp_xform->compress.chksum = RTE_COMP_CHECKSUM_NONE; 217 ts_params->def_comp_xform->compress.window_size = DEFAULT_WINDOW_SIZE; 218 219 ts_params->def_decomp_xform->type = RTE_COMP_DECOMPRESS; 220 ts_params->def_decomp_xform->decompress.algo = RTE_COMP_ALGO_DEFLATE, 221 ts_params->def_decomp_xform->decompress.chksum = RTE_COMP_CHECKSUM_NONE; 222 ts_params->def_decomp_xform->decompress.window_size = DEFAULT_WINDOW_SIZE; 223 224 return TEST_SUCCESS; 225 226 exit: 227 testsuite_teardown(); 228 229 return TEST_FAILED; 230 } 231 232 static int 233 generic_ut_setup(void) 234 { 235 /* Configure compressdev (one device, one queue pair) */ 236 struct rte_compressdev_config config = { 237 .socket_id = rte_socket_id(), 238 .nb_queue_pairs = 1, 239 .max_nb_priv_xforms = NUM_MAX_XFORMS, 240 .max_nb_streams = 0 241 }; 242 243 if (rte_compressdev_configure(0, &config) < 0) { 244 RTE_LOG(ERR, USER1, "Device configuration failed\n"); 245 return -1; 246 } 247 248 if (rte_compressdev_queue_pair_setup(0, 0, NUM_MAX_INFLIGHT_OPS, 249 rte_socket_id()) < 0) { 250 RTE_LOG(ERR, USER1, "Queue pair setup failed\n"); 251 return -1; 252 } 253 254 if (rte_compressdev_start(0) < 0) { 255 RTE_LOG(ERR, USER1, "Device could not be started\n"); 256 return -1; 257 } 258 259 return 0; 260 } 261 262 static void 263 generic_ut_teardown(void) 264 { 265 rte_compressdev_stop(0); 266 if (rte_compressdev_close(0) < 0) 267 RTE_LOG(ERR, USER1, "Device could not be closed\n"); 268 } 269 270 static int 271 test_compressdev_invalid_configuration(void) 272 { 273 struct rte_compressdev_config invalid_config; 274 struct rte_compressdev_config valid_config = { 275 .socket_id = rte_socket_id(), 276 .nb_queue_pairs = 1, 277 .max_nb_priv_xforms = NUM_MAX_XFORMS, 278 .max_nb_streams = 0 279 }; 280 struct rte_compressdev_info dev_info; 281 282 /* Invalid configuration with 0 queue pairs */ 283 memcpy(&invalid_config, &valid_config, 284 sizeof(struct rte_compressdev_config)); 285 invalid_config.nb_queue_pairs = 0; 286 287 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config), 288 "Device configuration was successful " 289 "with no queue pairs (invalid)\n"); 290 291 /* 292 * Invalid configuration with too many queue pairs 293 * (if there is an actual maximum number of queue pairs) 294 */ 295 rte_compressdev_info_get(0, &dev_info); 296 if (dev_info.max_nb_queue_pairs != 0) { 297 memcpy(&invalid_config, &valid_config, 298 sizeof(struct rte_compressdev_config)); 299 invalid_config.nb_queue_pairs = dev_info.max_nb_queue_pairs + 1; 300 301 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config), 302 "Device configuration was successful " 303 "with too many queue pairs (invalid)\n"); 304 } 305 306 /* Invalid queue pair setup, with no number of queue pairs set */ 307 TEST_ASSERT_FAIL(rte_compressdev_queue_pair_setup(0, 0, 308 NUM_MAX_INFLIGHT_OPS, rte_socket_id()), 309 "Queue pair setup was successful " 310 "with no queue pairs set (invalid)\n"); 311 312 return TEST_SUCCESS; 313 } 314 315 static int 316 compare_buffers(const char *buffer1, uint32_t buffer1_len, 317 const char *buffer2, uint32_t buffer2_len) 318 { 319 if (buffer1_len != buffer2_len) { 320 RTE_LOG(ERR, USER1, "Buffer lengths are different\n"); 321 return -1; 322 } 323 324 if (memcmp(buffer1, buffer2, buffer1_len) != 0) { 325 RTE_LOG(ERR, USER1, "Buffers are different\n"); 326 return -1; 327 } 328 329 return 0; 330 } 331 332 /* 333 * Maps compressdev and Zlib flush flags 334 */ 335 static int 336 map_zlib_flush_flag(enum rte_comp_flush_flag flag) 337 { 338 switch (flag) { 339 case RTE_COMP_FLUSH_NONE: 340 return Z_NO_FLUSH; 341 case RTE_COMP_FLUSH_SYNC: 342 return Z_SYNC_FLUSH; 343 case RTE_COMP_FLUSH_FULL: 344 return Z_FULL_FLUSH; 345 case RTE_COMP_FLUSH_FINAL: 346 return Z_FINISH; 347 /* 348 * There should be only the values above, 349 * so this should never happen 350 */ 351 default: 352 return -1; 353 } 354 } 355 356 static int 357 compress_zlib(struct rte_comp_op *op, 358 const struct rte_comp_xform *xform, int mem_level) 359 { 360 z_stream stream; 361 int zlib_flush; 362 int strategy, window_bits, comp_level; 363 int ret = TEST_FAILED; 364 uint8_t *single_src_buf = NULL; 365 uint8_t *single_dst_buf = NULL; 366 367 /* initialize zlib stream */ 368 stream.zalloc = Z_NULL; 369 stream.zfree = Z_NULL; 370 stream.opaque = Z_NULL; 371 372 if (xform->compress.deflate.huffman == RTE_COMP_HUFFMAN_FIXED) 373 strategy = Z_FIXED; 374 else 375 strategy = Z_DEFAULT_STRATEGY; 376 377 /* 378 * Window bits is the base two logarithm of the window size (in bytes). 379 * When doing raw DEFLATE, this number will be negative. 380 */ 381 window_bits = -(xform->compress.window_size); 382 if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) 383 window_bits *= -1; 384 else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) 385 window_bits = ZLIB_CRC_CHECKSUM_WINDOW_BITS; 386 387 comp_level = xform->compress.level; 388 389 if (comp_level != RTE_COMP_LEVEL_NONE) 390 ret = deflateInit2(&stream, comp_level, Z_DEFLATED, 391 window_bits, mem_level, strategy); 392 else 393 ret = deflateInit(&stream, Z_NO_COMPRESSION); 394 395 if (ret != Z_OK) { 396 printf("Zlib deflate could not be initialized\n"); 397 goto exit; 398 } 399 400 /* Assuming stateless operation */ 401 /* SGL Input */ 402 if (op->m_src->nb_segs > 1) { 403 single_src_buf = rte_malloc(NULL, 404 rte_pktmbuf_pkt_len(op->m_src), 0); 405 if (single_src_buf == NULL) { 406 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); 407 goto exit; 408 } 409 410 if (rte_pktmbuf_read(op->m_src, op->src.offset, 411 rte_pktmbuf_pkt_len(op->m_src) - 412 op->src.offset, 413 single_src_buf) == NULL) { 414 RTE_LOG(ERR, USER1, 415 "Buffer could not be read entirely\n"); 416 goto exit; 417 } 418 419 stream.avail_in = op->src.length; 420 stream.next_in = single_src_buf; 421 422 } else { 423 stream.avail_in = op->src.length; 424 stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *, 425 op->src.offset); 426 } 427 /* SGL output */ 428 if (op->m_dst->nb_segs > 1) { 429 430 single_dst_buf = rte_malloc(NULL, 431 rte_pktmbuf_pkt_len(op->m_dst), 0); 432 if (single_dst_buf == NULL) { 433 RTE_LOG(ERR, USER1, 434 "Buffer could not be allocated\n"); 435 goto exit; 436 } 437 438 stream.avail_out = op->m_dst->pkt_len; 439 stream.next_out = single_dst_buf; 440 441 } else {/* linear output */ 442 stream.avail_out = op->m_dst->data_len; 443 stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *, 444 op->dst.offset); 445 } 446 447 /* Stateless operation, all buffer will be compressed in one go */ 448 zlib_flush = map_zlib_flush_flag(op->flush_flag); 449 ret = deflate(&stream, zlib_flush); 450 451 if (stream.avail_in != 0) { 452 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n"); 453 goto exit; 454 } 455 456 if (ret != Z_STREAM_END) 457 goto exit; 458 459 /* Copy data to destination SGL */ 460 if (op->m_dst->nb_segs > 1) { 461 uint32_t remaining_data = stream.total_out; 462 uint8_t *src_data = single_dst_buf; 463 struct rte_mbuf *dst_buf = op->m_dst; 464 465 while (remaining_data > 0) { 466 uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf, 467 uint8_t *, op->dst.offset); 468 /* Last segment */ 469 if (remaining_data < dst_buf->data_len) { 470 memcpy(dst_data, src_data, remaining_data); 471 remaining_data = 0; 472 } else { 473 memcpy(dst_data, src_data, dst_buf->data_len); 474 remaining_data -= dst_buf->data_len; 475 src_data += dst_buf->data_len; 476 dst_buf = dst_buf->next; 477 } 478 } 479 } 480 481 op->consumed = stream.total_in; 482 if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) { 483 rte_pktmbuf_adj(op->m_dst, ZLIB_HEADER_SIZE); 484 rte_pktmbuf_trim(op->m_dst, ZLIB_TRAILER_SIZE); 485 op->produced = stream.total_out - (ZLIB_HEADER_SIZE + 486 ZLIB_TRAILER_SIZE); 487 } else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) { 488 rte_pktmbuf_adj(op->m_dst, GZIP_HEADER_SIZE); 489 rte_pktmbuf_trim(op->m_dst, GZIP_TRAILER_SIZE); 490 op->produced = stream.total_out - (GZIP_HEADER_SIZE + 491 GZIP_TRAILER_SIZE); 492 } else 493 op->produced = stream.total_out; 494 495 op->status = RTE_COMP_OP_STATUS_SUCCESS; 496 op->output_chksum = stream.adler; 497 498 deflateReset(&stream); 499 500 ret = 0; 501 exit: 502 deflateEnd(&stream); 503 rte_free(single_src_buf); 504 rte_free(single_dst_buf); 505 506 return ret; 507 } 508 509 static int 510 decompress_zlib(struct rte_comp_op *op, 511 const struct rte_comp_xform *xform) 512 { 513 z_stream stream; 514 int window_bits; 515 int zlib_flush; 516 int ret = TEST_FAILED; 517 uint8_t *single_src_buf = NULL; 518 uint8_t *single_dst_buf = NULL; 519 520 /* initialize zlib stream */ 521 stream.zalloc = Z_NULL; 522 stream.zfree = Z_NULL; 523 stream.opaque = Z_NULL; 524 525 /* 526 * Window bits is the base two logarithm of the window size (in bytes). 527 * When doing raw DEFLATE, this number will be negative. 528 */ 529 window_bits = -(xform->decompress.window_size); 530 ret = inflateInit2(&stream, window_bits); 531 532 if (ret != Z_OK) { 533 printf("Zlib deflate could not be initialized\n"); 534 goto exit; 535 } 536 537 /* Assuming stateless operation */ 538 /* SGL */ 539 if (op->m_src->nb_segs > 1) { 540 single_src_buf = rte_malloc(NULL, 541 rte_pktmbuf_pkt_len(op->m_src), 0); 542 if (single_src_buf == NULL) { 543 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); 544 goto exit; 545 } 546 single_dst_buf = rte_malloc(NULL, 547 rte_pktmbuf_pkt_len(op->m_dst), 0); 548 if (single_dst_buf == NULL) { 549 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); 550 goto exit; 551 } 552 if (rte_pktmbuf_read(op->m_src, 0, 553 rte_pktmbuf_pkt_len(op->m_src), 554 single_src_buf) == NULL) { 555 RTE_LOG(ERR, USER1, 556 "Buffer could not be read entirely\n"); 557 goto exit; 558 } 559 560 stream.avail_in = op->src.length; 561 stream.next_in = single_src_buf; 562 stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst); 563 stream.next_out = single_dst_buf; 564 565 } else { 566 stream.avail_in = op->src.length; 567 stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *); 568 stream.avail_out = op->m_dst->data_len; 569 stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *); 570 } 571 572 /* Stateless operation, all buffer will be compressed in one go */ 573 zlib_flush = map_zlib_flush_flag(op->flush_flag); 574 ret = inflate(&stream, zlib_flush); 575 576 if (stream.avail_in != 0) { 577 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n"); 578 goto exit; 579 } 580 581 if (ret != Z_STREAM_END) 582 goto exit; 583 584 if (op->m_src->nb_segs > 1) { 585 uint32_t remaining_data = stream.total_out; 586 uint8_t *src_data = single_dst_buf; 587 struct rte_mbuf *dst_buf = op->m_dst; 588 589 while (remaining_data > 0) { 590 uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf, 591 uint8_t *); 592 /* Last segment */ 593 if (remaining_data < dst_buf->data_len) { 594 memcpy(dst_data, src_data, remaining_data); 595 remaining_data = 0; 596 } else { 597 memcpy(dst_data, src_data, dst_buf->data_len); 598 remaining_data -= dst_buf->data_len; 599 src_data += dst_buf->data_len; 600 dst_buf = dst_buf->next; 601 } 602 } 603 } 604 605 op->consumed = stream.total_in; 606 op->produced = stream.total_out; 607 op->status = RTE_COMP_OP_STATUS_SUCCESS; 608 609 inflateReset(&stream); 610 611 ret = 0; 612 exit: 613 inflateEnd(&stream); 614 615 return ret; 616 } 617 618 static int 619 prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, 620 uint32_t total_data_size, 621 struct rte_mempool *small_mbuf_pool, 622 struct rte_mempool *large_mbuf_pool, 623 uint8_t limit_segs_in_sgl, 624 uint16_t seg_size) 625 { 626 uint32_t remaining_data = total_data_size; 627 uint16_t num_remaining_segs = DIV_CEIL(remaining_data, seg_size); 628 struct rte_mempool *pool; 629 struct rte_mbuf *next_seg; 630 uint32_t data_size; 631 char *buf_ptr; 632 const char *data_ptr = test_buf; 633 uint16_t i; 634 int ret; 635 636 if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl) 637 num_remaining_segs = limit_segs_in_sgl - 1; 638 639 /* 640 * Allocate data in the first segment (header) and 641 * copy data if test buffer is provided 642 */ 643 if (remaining_data < seg_size) 644 data_size = remaining_data; 645 else 646 data_size = seg_size; 647 buf_ptr = rte_pktmbuf_append(head_buf, data_size); 648 if (buf_ptr == NULL) { 649 RTE_LOG(ERR, USER1, 650 "Not enough space in the 1st buffer\n"); 651 return -1; 652 } 653 654 if (data_ptr != NULL) { 655 /* Copy characters without NULL terminator */ 656 strncpy(buf_ptr, data_ptr, data_size); 657 data_ptr += data_size; 658 } 659 remaining_data -= data_size; 660 num_remaining_segs--; 661 662 /* 663 * Allocate the rest of the segments, 664 * copy the rest of the data and chain the segments. 665 */ 666 for (i = 0; i < num_remaining_segs; i++) { 667 668 if (i == (num_remaining_segs - 1)) { 669 /* last segment */ 670 if (remaining_data > seg_size) 671 pool = large_mbuf_pool; 672 else 673 pool = small_mbuf_pool; 674 data_size = remaining_data; 675 } else { 676 data_size = seg_size; 677 pool = small_mbuf_pool; 678 } 679 680 next_seg = rte_pktmbuf_alloc(pool); 681 if (next_seg == NULL) { 682 RTE_LOG(ERR, USER1, 683 "New segment could not be allocated " 684 "from the mempool\n"); 685 return -1; 686 } 687 buf_ptr = rte_pktmbuf_append(next_seg, data_size); 688 if (buf_ptr == NULL) { 689 RTE_LOG(ERR, USER1, 690 "Not enough space in the buffer\n"); 691 rte_pktmbuf_free(next_seg); 692 return -1; 693 } 694 if (data_ptr != NULL) { 695 /* Copy characters without NULL terminator */ 696 strncpy(buf_ptr, data_ptr, data_size); 697 data_ptr += data_size; 698 } 699 remaining_data -= data_size; 700 701 ret = rte_pktmbuf_chain(head_buf, next_seg); 702 if (ret != 0) { 703 rte_pktmbuf_free(next_seg); 704 RTE_LOG(ERR, USER1, 705 "Segment could not chained\n"); 706 return -1; 707 } 708 } 709 710 return 0; 711 } 712 713 /* 714 * Compresses and decompresses buffer with compressdev API and Zlib API 715 */ 716 static int 717 test_deflate_comp_decomp(const struct interim_data_params *int_data, 718 const struct test_data_params *test_data) 719 { 720 struct comp_testsuite_params *ts_params = &testsuite_params; 721 const char * const *test_bufs = int_data->test_bufs; 722 unsigned int num_bufs = int_data->num_bufs; 723 uint16_t *buf_idx = int_data->buf_idx; 724 struct rte_comp_xform **compress_xforms = int_data->compress_xforms; 725 struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms; 726 unsigned int num_xforms = int_data->num_xforms; 727 enum rte_comp_op_type state = test_data->state; 728 unsigned int buff_type = test_data->buff_type; 729 unsigned int out_of_space = test_data->out_of_space; 730 unsigned int big_data = test_data->big_data; 731 enum zlib_direction zlib_dir = test_data->zlib_dir; 732 int ret_status = -1; 733 int ret; 734 struct rte_mbuf *uncomp_bufs[num_bufs]; 735 struct rte_mbuf *comp_bufs[num_bufs]; 736 struct rte_comp_op *ops[num_bufs]; 737 struct rte_comp_op *ops_processed[num_bufs]; 738 void *priv_xforms[num_bufs]; 739 uint16_t num_enqd, num_deqd, num_total_deqd; 740 uint16_t num_priv_xforms = 0; 741 unsigned int deqd_retries = 0; 742 struct priv_op_data *priv_data; 743 char *buf_ptr; 744 unsigned int i; 745 struct rte_mempool *buf_pool; 746 uint32_t data_size; 747 /* Compressing with CompressDev */ 748 unsigned int oos_zlib_decompress = 749 (zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_DECOMPRESS); 750 /* Decompressing with CompressDev */ 751 unsigned int oos_zlib_compress = 752 (zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_COMPRESS); 753 const struct rte_compressdev_capabilities *capa = 754 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 755 char *contig_buf = NULL; 756 uint64_t compress_checksum[num_bufs]; 757 758 if (capa == NULL) { 759 RTE_LOG(ERR, USER1, 760 "Compress device does not support DEFLATE\n"); 761 return -1; 762 } 763 764 /* Initialize all arrays to NULL */ 765 memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs); 766 memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs); 767 memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs); 768 memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs); 769 memset(priv_xforms, 0, sizeof(void *) * num_bufs); 770 771 if (big_data) 772 buf_pool = ts_params->big_mbuf_pool; 773 else if (buff_type == SGL_BOTH) 774 buf_pool = ts_params->small_mbuf_pool; 775 else 776 buf_pool = ts_params->large_mbuf_pool; 777 778 /* Prepare the source mbufs with the data */ 779 ret = rte_pktmbuf_alloc_bulk(buf_pool, 780 uncomp_bufs, num_bufs); 781 if (ret < 0) { 782 RTE_LOG(ERR, USER1, 783 "Source mbufs could not be allocated " 784 "from the mempool\n"); 785 goto exit; 786 } 787 788 if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) { 789 for (i = 0; i < num_bufs; i++) { 790 data_size = strlen(test_bufs[i]) + 1; 791 if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i], 792 data_size, 793 big_data ? buf_pool : ts_params->small_mbuf_pool, 794 big_data ? buf_pool : ts_params->large_mbuf_pool, 795 big_data ? 0 : MAX_SEGS, 796 big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0) 797 goto exit; 798 } 799 } else { 800 for (i = 0; i < num_bufs; i++) { 801 data_size = strlen(test_bufs[i]) + 1; 802 buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size); 803 strlcpy(buf_ptr, test_bufs[i], data_size); 804 } 805 } 806 807 /* Prepare the destination mbufs */ 808 ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs); 809 if (ret < 0) { 810 RTE_LOG(ERR, USER1, 811 "Destination mbufs could not be allocated " 812 "from the mempool\n"); 813 goto exit; 814 } 815 816 if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { 817 for (i = 0; i < num_bufs; i++) { 818 if (out_of_space == 1 && oos_zlib_decompress) 819 data_size = OUT_OF_SPACE_BUF; 820 else 821 (data_size = strlen(test_bufs[i]) * 822 COMPRESS_BUF_SIZE_RATIO); 823 824 if (prepare_sgl_bufs(NULL, comp_bufs[i], 825 data_size, 826 big_data ? buf_pool : ts_params->small_mbuf_pool, 827 big_data ? buf_pool : ts_params->large_mbuf_pool, 828 big_data ? 0 : MAX_SEGS, 829 big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) 830 < 0) 831 goto exit; 832 } 833 834 } else { 835 for (i = 0; i < num_bufs; i++) { 836 if (out_of_space == 1 && oos_zlib_decompress) 837 data_size = OUT_OF_SPACE_BUF; 838 else 839 (data_size = strlen(test_bufs[i]) * 840 COMPRESS_BUF_SIZE_RATIO); 841 842 rte_pktmbuf_append(comp_bufs[i], data_size); 843 } 844 } 845 846 /* Build the compression operations */ 847 ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs); 848 if (ret < 0) { 849 RTE_LOG(ERR, USER1, 850 "Compress operations could not be allocated " 851 "from the mempool\n"); 852 goto exit; 853 } 854 855 856 for (i = 0; i < num_bufs; i++) { 857 ops[i]->m_src = uncomp_bufs[i]; 858 ops[i]->m_dst = comp_bufs[i]; 859 ops[i]->src.offset = 0; 860 ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]); 861 ops[i]->dst.offset = 0; 862 if (state == RTE_COMP_OP_STATELESS) { 863 ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL; 864 } else { 865 RTE_LOG(ERR, USER1, 866 "Stateful operations are not supported " 867 "in these tests yet\n"); 868 goto exit; 869 } 870 ops[i]->input_chksum = 0; 871 /* 872 * Store original operation index in private data, 873 * since ordering does not have to be maintained, 874 * when dequeueing from compressdev, so a comparison 875 * at the end of the test can be done. 876 */ 877 priv_data = (struct priv_op_data *) (ops[i] + 1); 878 priv_data->orig_idx = i; 879 } 880 881 /* Compress data (either with Zlib API or compressdev API */ 882 if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) { 883 for (i = 0; i < num_bufs; i++) { 884 const struct rte_comp_xform *compress_xform = 885 compress_xforms[i % num_xforms]; 886 ret = compress_zlib(ops[i], compress_xform, 887 DEFAULT_MEM_LEVEL); 888 if (ret < 0) 889 goto exit; 890 891 ops_processed[i] = ops[i]; 892 } 893 } else { 894 /* Create compress private xform data */ 895 for (i = 0; i < num_xforms; i++) { 896 ret = rte_compressdev_private_xform_create(0, 897 (const struct rte_comp_xform *)compress_xforms[i], 898 &priv_xforms[i]); 899 if (ret < 0) { 900 RTE_LOG(ERR, USER1, 901 "Compression private xform " 902 "could not be created\n"); 903 goto exit; 904 } 905 num_priv_xforms++; 906 } 907 908 if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) { 909 /* Attach shareable private xform data to ops */ 910 for (i = 0; i < num_bufs; i++) 911 ops[i]->private_xform = priv_xforms[i % num_xforms]; 912 } else { 913 /* Create rest of the private xforms for the other ops */ 914 for (i = num_xforms; i < num_bufs; i++) { 915 ret = rte_compressdev_private_xform_create(0, 916 compress_xforms[i % num_xforms], 917 &priv_xforms[i]); 918 if (ret < 0) { 919 RTE_LOG(ERR, USER1, 920 "Compression private xform " 921 "could not be created\n"); 922 goto exit; 923 } 924 num_priv_xforms++; 925 } 926 927 /* Attach non shareable private xform data to ops */ 928 for (i = 0; i < num_bufs; i++) 929 ops[i]->private_xform = priv_xforms[i]; 930 } 931 932 /* Enqueue and dequeue all operations */ 933 num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs); 934 if (num_enqd < num_bufs) { 935 RTE_LOG(ERR, USER1, 936 "The operations could not be enqueued\n"); 937 goto exit; 938 } 939 940 num_total_deqd = 0; 941 do { 942 /* 943 * If retrying a dequeue call, wait for 10 ms to allow 944 * enough time to the driver to process the operations 945 */ 946 if (deqd_retries != 0) { 947 /* 948 * Avoid infinite loop if not all the 949 * operations get out of the device 950 */ 951 if (deqd_retries == MAX_DEQD_RETRIES) { 952 RTE_LOG(ERR, USER1, 953 "Not all operations could be " 954 "dequeued\n"); 955 goto exit; 956 } 957 usleep(DEQUEUE_WAIT_TIME); 958 } 959 num_deqd = rte_compressdev_dequeue_burst(0, 0, 960 &ops_processed[num_total_deqd], num_bufs); 961 num_total_deqd += num_deqd; 962 deqd_retries++; 963 964 } while (num_total_deqd < num_enqd); 965 966 deqd_retries = 0; 967 968 /* Free compress private xforms */ 969 for (i = 0; i < num_priv_xforms; i++) { 970 rte_compressdev_private_xform_free(0, priv_xforms[i]); 971 priv_xforms[i] = NULL; 972 } 973 num_priv_xforms = 0; 974 } 975 976 for (i = 0; i < num_bufs; i++) { 977 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 978 uint16_t xform_idx = priv_data->orig_idx % num_xforms; 979 const struct rte_comp_compress_xform *compress_xform = 980 &compress_xforms[xform_idx]->compress; 981 enum rte_comp_huffman huffman_type = 982 compress_xform->deflate.huffman; 983 char engine[] = "zlib (directly, not PMD)"; 984 if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL) 985 strlcpy(engine, "PMD", sizeof(engine)); 986 987 RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to" 988 " %u bytes (level = %d, huffman = %s)\n", 989 buf_idx[priv_data->orig_idx], engine, 990 ops_processed[i]->consumed, ops_processed[i]->produced, 991 compress_xform->level, 992 huffman_type_strings[huffman_type]); 993 RTE_LOG(DEBUG, USER1, "Compression ratio = %.2f\n", 994 ops_processed[i]->consumed == 0 ? 0 : 995 (float)ops_processed[i]->produced / 996 ops_processed[i]->consumed * 100); 997 if (compress_xform->chksum != RTE_COMP_CHECKSUM_NONE) 998 compress_checksum[i] = ops_processed[i]->output_chksum; 999 ops[i] = NULL; 1000 } 1001 1002 /* 1003 * Check operation status and free source mbufs (destination mbuf and 1004 * compress operation information is needed for the decompression stage) 1005 */ 1006 for (i = 0; i < num_bufs; i++) { 1007 if (out_of_space && oos_zlib_decompress) { 1008 if (ops_processed[i]->status != 1009 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) { 1010 ret_status = -1; 1011 1012 RTE_LOG(ERR, USER1, 1013 "Operation without expected out of " 1014 "space status error\n"); 1015 goto exit; 1016 } else 1017 continue; 1018 } 1019 1020 if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) { 1021 RTE_LOG(ERR, USER1, 1022 "Some operations were not successful\n"); 1023 goto exit; 1024 } 1025 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1026 rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]); 1027 uncomp_bufs[priv_data->orig_idx] = NULL; 1028 } 1029 1030 if (out_of_space && oos_zlib_decompress) { 1031 ret_status = 0; 1032 goto exit; 1033 } 1034 1035 /* Allocate buffers for decompressed data */ 1036 ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs); 1037 if (ret < 0) { 1038 RTE_LOG(ERR, USER1, 1039 "Destination mbufs could not be allocated " 1040 "from the mempool\n"); 1041 goto exit; 1042 } 1043 1044 if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { 1045 for (i = 0; i < num_bufs; i++) { 1046 priv_data = (struct priv_op_data *) 1047 (ops_processed[i] + 1); 1048 if (out_of_space == 1 && oos_zlib_compress) 1049 data_size = OUT_OF_SPACE_BUF; 1050 else 1051 data_size = 1052 strlen(test_bufs[priv_data->orig_idx]) + 1; 1053 1054 if (prepare_sgl_bufs(NULL, uncomp_bufs[i], 1055 data_size, 1056 big_data ? buf_pool : ts_params->small_mbuf_pool, 1057 big_data ? buf_pool : ts_params->large_mbuf_pool, 1058 big_data ? 0 : MAX_SEGS, 1059 big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) 1060 < 0) 1061 goto exit; 1062 } 1063 1064 } else { 1065 for (i = 0; i < num_bufs; i++) { 1066 priv_data = (struct priv_op_data *) 1067 (ops_processed[i] + 1); 1068 if (out_of_space == 1 && oos_zlib_compress) 1069 data_size = OUT_OF_SPACE_BUF; 1070 else 1071 data_size = 1072 strlen(test_bufs[priv_data->orig_idx]) + 1; 1073 1074 rte_pktmbuf_append(uncomp_bufs[i], data_size); 1075 } 1076 } 1077 1078 /* Build the decompression operations */ 1079 ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs); 1080 if (ret < 0) { 1081 RTE_LOG(ERR, USER1, 1082 "Decompress operations could not be allocated " 1083 "from the mempool\n"); 1084 goto exit; 1085 } 1086 1087 /* Source buffer is the compressed data from the previous operations */ 1088 for (i = 0; i < num_bufs; i++) { 1089 ops[i]->m_src = ops_processed[i]->m_dst; 1090 ops[i]->m_dst = uncomp_bufs[i]; 1091 ops[i]->src.offset = 0; 1092 /* 1093 * Set the length of the compressed data to the 1094 * number of bytes that were produced in the previous stage 1095 */ 1096 ops[i]->src.length = ops_processed[i]->produced; 1097 ops[i]->dst.offset = 0; 1098 if (state == RTE_COMP_OP_STATELESS) { 1099 ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL; 1100 } else { 1101 RTE_LOG(ERR, USER1, 1102 "Stateful operations are not supported " 1103 "in these tests yet\n"); 1104 goto exit; 1105 } 1106 ops[i]->input_chksum = 0; 1107 /* 1108 * Copy private data from previous operations, 1109 * to keep the pointer to the original buffer 1110 */ 1111 memcpy(ops[i] + 1, ops_processed[i] + 1, 1112 sizeof(struct priv_op_data)); 1113 } 1114 1115 /* 1116 * Free the previous compress operations, 1117 * as they are not needed anymore 1118 */ 1119 rte_comp_op_bulk_free(ops_processed, num_bufs); 1120 1121 /* Decompress data (either with Zlib API or compressdev API */ 1122 if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) { 1123 for (i = 0; i < num_bufs; i++) { 1124 priv_data = (struct priv_op_data *)(ops[i] + 1); 1125 uint16_t xform_idx = priv_data->orig_idx % num_xforms; 1126 const struct rte_comp_xform *decompress_xform = 1127 decompress_xforms[xform_idx]; 1128 1129 ret = decompress_zlib(ops[i], decompress_xform); 1130 if (ret < 0) 1131 goto exit; 1132 1133 ops_processed[i] = ops[i]; 1134 } 1135 } else { 1136 /* Create decompress private xform data */ 1137 for (i = 0; i < num_xforms; i++) { 1138 ret = rte_compressdev_private_xform_create(0, 1139 (const struct rte_comp_xform *)decompress_xforms[i], 1140 &priv_xforms[i]); 1141 if (ret < 0) { 1142 RTE_LOG(ERR, USER1, 1143 "Decompression private xform " 1144 "could not be created\n"); 1145 goto exit; 1146 } 1147 num_priv_xforms++; 1148 } 1149 1150 if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) { 1151 /* Attach shareable private xform data to ops */ 1152 for (i = 0; i < num_bufs; i++) { 1153 priv_data = (struct priv_op_data *)(ops[i] + 1); 1154 uint16_t xform_idx = priv_data->orig_idx % 1155 num_xforms; 1156 ops[i]->private_xform = priv_xforms[xform_idx]; 1157 } 1158 } else { 1159 /* Create rest of the private xforms for the other ops */ 1160 for (i = num_xforms; i < num_bufs; i++) { 1161 ret = rte_compressdev_private_xform_create(0, 1162 decompress_xforms[i % num_xforms], 1163 &priv_xforms[i]); 1164 if (ret < 0) { 1165 RTE_LOG(ERR, USER1, 1166 "Decompression private xform " 1167 "could not be created\n"); 1168 goto exit; 1169 } 1170 num_priv_xforms++; 1171 } 1172 1173 /* Attach non shareable private xform data to ops */ 1174 for (i = 0; i < num_bufs; i++) { 1175 priv_data = (struct priv_op_data *)(ops[i] + 1); 1176 uint16_t xform_idx = priv_data->orig_idx; 1177 ops[i]->private_xform = priv_xforms[xform_idx]; 1178 } 1179 } 1180 1181 /* Enqueue and dequeue all operations */ 1182 num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs); 1183 if (num_enqd < num_bufs) { 1184 RTE_LOG(ERR, USER1, 1185 "The operations could not be enqueued\n"); 1186 goto exit; 1187 } 1188 1189 num_total_deqd = 0; 1190 do { 1191 /* 1192 * If retrying a dequeue call, wait for 10 ms to allow 1193 * enough time to the driver to process the operations 1194 */ 1195 if (deqd_retries != 0) { 1196 /* 1197 * Avoid infinite loop if not all the 1198 * operations get out of the device 1199 */ 1200 if (deqd_retries == MAX_DEQD_RETRIES) { 1201 RTE_LOG(ERR, USER1, 1202 "Not all operations could be " 1203 "dequeued\n"); 1204 goto exit; 1205 } 1206 usleep(DEQUEUE_WAIT_TIME); 1207 } 1208 num_deqd = rte_compressdev_dequeue_burst(0, 0, 1209 &ops_processed[num_total_deqd], num_bufs); 1210 num_total_deqd += num_deqd; 1211 deqd_retries++; 1212 } while (num_total_deqd < num_enqd); 1213 1214 deqd_retries = 0; 1215 } 1216 1217 for (i = 0; i < num_bufs; i++) { 1218 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1219 char engine[] = "zlib, (directly, no PMD)"; 1220 if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL) 1221 strlcpy(engine, "pmd", sizeof(engine)); 1222 RTE_LOG(DEBUG, USER1, 1223 "Buffer %u decompressed by %s from %u to %u bytes\n", 1224 buf_idx[priv_data->orig_idx], engine, 1225 ops_processed[i]->consumed, ops_processed[i]->produced); 1226 ops[i] = NULL; 1227 } 1228 1229 /* 1230 * Check operation status and free source mbuf (destination mbuf and 1231 * compress operation information is still needed) 1232 */ 1233 for (i = 0; i < num_bufs; i++) { 1234 if (out_of_space && oos_zlib_compress) { 1235 if (ops_processed[i]->status != 1236 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) { 1237 ret_status = -1; 1238 1239 RTE_LOG(ERR, USER1, 1240 "Operation without expected out of " 1241 "space status error\n"); 1242 goto exit; 1243 } else 1244 continue; 1245 } 1246 1247 if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) { 1248 RTE_LOG(ERR, USER1, 1249 "Some operations were not successful\n"); 1250 goto exit; 1251 } 1252 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1253 rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]); 1254 comp_bufs[priv_data->orig_idx] = NULL; 1255 } 1256 1257 if (out_of_space && oos_zlib_compress) { 1258 ret_status = 0; 1259 goto exit; 1260 } 1261 1262 /* 1263 * Compare the original stream with the decompressed stream 1264 * (in size and the data) 1265 */ 1266 for (i = 0; i < num_bufs; i++) { 1267 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1268 const char *buf1 = test_bufs[priv_data->orig_idx]; 1269 const char *buf2; 1270 contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0); 1271 if (contig_buf == NULL) { 1272 RTE_LOG(ERR, USER1, "Contiguous buffer could not " 1273 "be allocated\n"); 1274 goto exit; 1275 } 1276 1277 buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0, 1278 ops_processed[i]->produced, contig_buf); 1279 if (compare_buffers(buf1, strlen(buf1) + 1, 1280 buf2, ops_processed[i]->produced) < 0) 1281 goto exit; 1282 1283 /* Test checksums */ 1284 if (compress_xforms[0]->compress.chksum != 1285 RTE_COMP_CHECKSUM_NONE) { 1286 if (ops_processed[i]->output_chksum != 1287 compress_checksum[i]) { 1288 RTE_LOG(ERR, USER1, "The checksums differ\n" 1289 "Compression Checksum: %" PRIu64 "\tDecompression " 1290 "Checksum: %" PRIu64 "\n", compress_checksum[i], 1291 ops_processed[i]->output_chksum); 1292 goto exit; 1293 } 1294 } 1295 1296 rte_free(contig_buf); 1297 contig_buf = NULL; 1298 } 1299 1300 ret_status = 0; 1301 1302 exit: 1303 /* Free resources */ 1304 for (i = 0; i < num_bufs; i++) { 1305 rte_pktmbuf_free(uncomp_bufs[i]); 1306 rte_pktmbuf_free(comp_bufs[i]); 1307 rte_comp_op_free(ops[i]); 1308 rte_comp_op_free(ops_processed[i]); 1309 } 1310 for (i = 0; i < num_priv_xforms; i++) { 1311 if (priv_xforms[i] != NULL) 1312 rte_compressdev_private_xform_free(0, priv_xforms[i]); 1313 } 1314 rte_free(contig_buf); 1315 1316 return ret_status; 1317 } 1318 1319 static int 1320 test_compressdev_deflate_stateless_fixed(void) 1321 { 1322 struct comp_testsuite_params *ts_params = &testsuite_params; 1323 uint16_t i; 1324 int ret; 1325 const struct rte_compressdev_capabilities *capab; 1326 1327 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1328 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1329 1330 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0) 1331 return -ENOTSUP; 1332 1333 struct rte_comp_xform *compress_xform = 1334 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1335 1336 if (compress_xform == NULL) { 1337 RTE_LOG(ERR, USER1, 1338 "Compress xform could not be created\n"); 1339 ret = TEST_FAILED; 1340 goto exit; 1341 } 1342 1343 memcpy(compress_xform, ts_params->def_comp_xform, 1344 sizeof(struct rte_comp_xform)); 1345 compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED; 1346 1347 struct interim_data_params int_data = { 1348 NULL, 1349 1, 1350 NULL, 1351 &compress_xform, 1352 &ts_params->def_decomp_xform, 1353 1 1354 }; 1355 1356 struct test_data_params test_data = { 1357 RTE_COMP_OP_STATELESS, 1358 LB_BOTH, 1359 ZLIB_DECOMPRESS, 1360 0, 1361 0 1362 }; 1363 1364 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1365 int_data.test_bufs = &compress_test_bufs[i]; 1366 int_data.buf_idx = &i; 1367 1368 /* Compress with compressdev, decompress with Zlib */ 1369 test_data.zlib_dir = ZLIB_DECOMPRESS; 1370 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1371 ret = TEST_FAILED; 1372 goto exit; 1373 } 1374 1375 /* Compress with Zlib, decompress with compressdev */ 1376 test_data.zlib_dir = ZLIB_COMPRESS; 1377 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1378 ret = TEST_FAILED; 1379 goto exit; 1380 } 1381 } 1382 1383 ret = TEST_SUCCESS; 1384 1385 exit: 1386 rte_free(compress_xform); 1387 return ret; 1388 } 1389 1390 static int 1391 test_compressdev_deflate_stateless_dynamic(void) 1392 { 1393 struct comp_testsuite_params *ts_params = &testsuite_params; 1394 uint16_t i; 1395 int ret; 1396 struct rte_comp_xform *compress_xform = 1397 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1398 1399 const struct rte_compressdev_capabilities *capab; 1400 1401 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1402 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1403 1404 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0) 1405 return -ENOTSUP; 1406 1407 if (compress_xform == NULL) { 1408 RTE_LOG(ERR, USER1, 1409 "Compress xform could not be created\n"); 1410 ret = TEST_FAILED; 1411 goto exit; 1412 } 1413 1414 memcpy(compress_xform, ts_params->def_comp_xform, 1415 sizeof(struct rte_comp_xform)); 1416 compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC; 1417 1418 struct interim_data_params int_data = { 1419 NULL, 1420 1, 1421 NULL, 1422 &compress_xform, 1423 &ts_params->def_decomp_xform, 1424 1 1425 }; 1426 1427 struct test_data_params test_data = { 1428 RTE_COMP_OP_STATELESS, 1429 LB_BOTH, 1430 ZLIB_DECOMPRESS, 1431 0, 1432 0 1433 }; 1434 1435 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1436 int_data.test_bufs = &compress_test_bufs[i]; 1437 int_data.buf_idx = &i; 1438 1439 /* Compress with compressdev, decompress with Zlib */ 1440 test_data.zlib_dir = ZLIB_DECOMPRESS; 1441 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1442 ret = TEST_FAILED; 1443 goto exit; 1444 } 1445 1446 /* Compress with Zlib, decompress with compressdev */ 1447 test_data.zlib_dir = ZLIB_COMPRESS; 1448 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1449 ret = TEST_FAILED; 1450 goto exit; 1451 } 1452 } 1453 1454 ret = TEST_SUCCESS; 1455 1456 exit: 1457 rte_free(compress_xform); 1458 return ret; 1459 } 1460 1461 static int 1462 test_compressdev_deflate_stateless_multi_op(void) 1463 { 1464 struct comp_testsuite_params *ts_params = &testsuite_params; 1465 uint16_t num_bufs = RTE_DIM(compress_test_bufs); 1466 uint16_t buf_idx[num_bufs]; 1467 uint16_t i; 1468 1469 for (i = 0; i < num_bufs; i++) 1470 buf_idx[i] = i; 1471 1472 struct interim_data_params int_data = { 1473 compress_test_bufs, 1474 num_bufs, 1475 buf_idx, 1476 &ts_params->def_comp_xform, 1477 &ts_params->def_decomp_xform, 1478 1 1479 }; 1480 1481 struct test_data_params test_data = { 1482 RTE_COMP_OP_STATELESS, 1483 LB_BOTH, 1484 ZLIB_DECOMPRESS, 1485 0, 1486 0 1487 }; 1488 1489 /* Compress with compressdev, decompress with Zlib */ 1490 test_data.zlib_dir = ZLIB_DECOMPRESS; 1491 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1492 return TEST_FAILED; 1493 1494 /* Compress with Zlib, decompress with compressdev */ 1495 test_data.zlib_dir = ZLIB_COMPRESS; 1496 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1497 return TEST_FAILED; 1498 1499 return TEST_SUCCESS; 1500 } 1501 1502 static int 1503 test_compressdev_deflate_stateless_multi_level(void) 1504 { 1505 struct comp_testsuite_params *ts_params = &testsuite_params; 1506 unsigned int level; 1507 uint16_t i; 1508 int ret; 1509 struct rte_comp_xform *compress_xform = 1510 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1511 1512 if (compress_xform == NULL) { 1513 RTE_LOG(ERR, USER1, 1514 "Compress xform could not be created\n"); 1515 ret = TEST_FAILED; 1516 goto exit; 1517 } 1518 1519 memcpy(compress_xform, ts_params->def_comp_xform, 1520 sizeof(struct rte_comp_xform)); 1521 1522 struct interim_data_params int_data = { 1523 NULL, 1524 1, 1525 NULL, 1526 &compress_xform, 1527 &ts_params->def_decomp_xform, 1528 1 1529 }; 1530 1531 struct test_data_params test_data = { 1532 RTE_COMP_OP_STATELESS, 1533 LB_BOTH, 1534 ZLIB_DECOMPRESS, 1535 0, 1536 0 1537 }; 1538 1539 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1540 int_data.test_bufs = &compress_test_bufs[i]; 1541 int_data.buf_idx = &i; 1542 1543 for (level = RTE_COMP_LEVEL_MIN; level <= RTE_COMP_LEVEL_MAX; 1544 level++) { 1545 compress_xform->compress.level = level; 1546 /* Compress with compressdev, decompress with Zlib */ 1547 test_data.zlib_dir = ZLIB_DECOMPRESS; 1548 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1549 ret = TEST_FAILED; 1550 goto exit; 1551 } 1552 } 1553 } 1554 1555 ret = TEST_SUCCESS; 1556 1557 exit: 1558 rte_free(compress_xform); 1559 return ret; 1560 } 1561 1562 #define NUM_XFORMS 3 1563 static int 1564 test_compressdev_deflate_stateless_multi_xform(void) 1565 { 1566 struct comp_testsuite_params *ts_params = &testsuite_params; 1567 uint16_t num_bufs = NUM_XFORMS; 1568 struct rte_comp_xform *compress_xforms[NUM_XFORMS] = {NULL}; 1569 struct rte_comp_xform *decompress_xforms[NUM_XFORMS] = {NULL}; 1570 const char *test_buffers[NUM_XFORMS]; 1571 uint16_t i; 1572 unsigned int level = RTE_COMP_LEVEL_MIN; 1573 uint16_t buf_idx[num_bufs]; 1574 1575 int ret; 1576 1577 /* Create multiple xforms with various levels */ 1578 for (i = 0; i < NUM_XFORMS; i++) { 1579 compress_xforms[i] = rte_malloc(NULL, 1580 sizeof(struct rte_comp_xform), 0); 1581 if (compress_xforms[i] == NULL) { 1582 RTE_LOG(ERR, USER1, 1583 "Compress xform could not be created\n"); 1584 ret = TEST_FAILED; 1585 goto exit; 1586 } 1587 1588 memcpy(compress_xforms[i], ts_params->def_comp_xform, 1589 sizeof(struct rte_comp_xform)); 1590 compress_xforms[i]->compress.level = level; 1591 level++; 1592 1593 decompress_xforms[i] = rte_malloc(NULL, 1594 sizeof(struct rte_comp_xform), 0); 1595 if (decompress_xforms[i] == NULL) { 1596 RTE_LOG(ERR, USER1, 1597 "Decompress xform could not be created\n"); 1598 ret = TEST_FAILED; 1599 goto exit; 1600 } 1601 1602 memcpy(decompress_xforms[i], ts_params->def_decomp_xform, 1603 sizeof(struct rte_comp_xform)); 1604 } 1605 1606 for (i = 0; i < NUM_XFORMS; i++) { 1607 buf_idx[i] = 0; 1608 /* Use the same buffer in all sessions */ 1609 test_buffers[i] = compress_test_bufs[0]; 1610 } 1611 1612 struct interim_data_params int_data = { 1613 test_buffers, 1614 num_bufs, 1615 buf_idx, 1616 compress_xforms, 1617 decompress_xforms, 1618 NUM_XFORMS 1619 }; 1620 1621 struct test_data_params test_data = { 1622 RTE_COMP_OP_STATELESS, 1623 LB_BOTH, 1624 ZLIB_DECOMPRESS, 1625 0, 1626 0 1627 }; 1628 1629 /* Compress with compressdev, decompress with Zlib */ 1630 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1631 ret = TEST_FAILED; 1632 goto exit; 1633 } 1634 1635 ret = TEST_SUCCESS; 1636 exit: 1637 for (i = 0; i < NUM_XFORMS; i++) { 1638 rte_free(compress_xforms[i]); 1639 rte_free(decompress_xforms[i]); 1640 } 1641 1642 return ret; 1643 } 1644 1645 static int 1646 test_compressdev_deflate_stateless_sgl(void) 1647 { 1648 struct comp_testsuite_params *ts_params = &testsuite_params; 1649 uint16_t i; 1650 const struct rte_compressdev_capabilities *capab; 1651 1652 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1653 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1654 1655 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0) 1656 return -ENOTSUP; 1657 1658 struct interim_data_params int_data = { 1659 NULL, 1660 1, 1661 NULL, 1662 &ts_params->def_comp_xform, 1663 &ts_params->def_decomp_xform, 1664 1 1665 }; 1666 1667 struct test_data_params test_data = { 1668 RTE_COMP_OP_STATELESS, 1669 SGL_BOTH, 1670 ZLIB_DECOMPRESS, 1671 0, 1672 0 1673 }; 1674 1675 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1676 int_data.test_bufs = &compress_test_bufs[i]; 1677 int_data.buf_idx = &i; 1678 1679 /* Compress with compressdev, decompress with Zlib */ 1680 test_data.zlib_dir = ZLIB_DECOMPRESS; 1681 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1682 return TEST_FAILED; 1683 1684 /* Compress with Zlib, decompress with compressdev */ 1685 test_data.zlib_dir = ZLIB_COMPRESS; 1686 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1687 return TEST_FAILED; 1688 1689 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_LB_OUT) { 1690 /* Compress with compressdev, decompress with Zlib */ 1691 test_data.zlib_dir = ZLIB_DECOMPRESS; 1692 test_data.buff_type = SGL_TO_LB; 1693 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1694 return TEST_FAILED; 1695 1696 /* Compress with Zlib, decompress with compressdev */ 1697 test_data.zlib_dir = ZLIB_COMPRESS; 1698 test_data.buff_type = SGL_TO_LB; 1699 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1700 return TEST_FAILED; 1701 } 1702 1703 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_LB_IN_SGL_OUT) { 1704 /* Compress with compressdev, decompress with Zlib */ 1705 test_data.zlib_dir = ZLIB_DECOMPRESS; 1706 test_data.buff_type = LB_TO_SGL; 1707 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1708 return TEST_FAILED; 1709 1710 /* Compress with Zlib, decompress with compressdev */ 1711 test_data.zlib_dir = ZLIB_COMPRESS; 1712 test_data.buff_type = LB_TO_SGL; 1713 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 1714 return TEST_FAILED; 1715 } 1716 1717 1718 } 1719 1720 return TEST_SUCCESS; 1721 1722 } 1723 1724 static int 1725 test_compressdev_deflate_stateless_checksum(void) 1726 { 1727 struct comp_testsuite_params *ts_params = &testsuite_params; 1728 uint16_t i; 1729 int ret; 1730 const struct rte_compressdev_capabilities *capab; 1731 1732 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1733 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1734 1735 /* Check if driver supports any checksum */ 1736 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) == 0 && 1737 (capab->comp_feature_flags & 1738 RTE_COMP_FF_ADLER32_CHECKSUM) == 0 && 1739 (capab->comp_feature_flags & 1740 RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) == 0) 1741 return -ENOTSUP; 1742 1743 struct rte_comp_xform *compress_xform = 1744 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1745 if (compress_xform == NULL) { 1746 RTE_LOG(ERR, USER1, "Compress xform could not be created\n"); 1747 ret = TEST_FAILED; 1748 return ret; 1749 } 1750 1751 memcpy(compress_xform, ts_params->def_comp_xform, 1752 sizeof(struct rte_comp_xform)); 1753 1754 struct rte_comp_xform *decompress_xform = 1755 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1756 if (decompress_xform == NULL) { 1757 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n"); 1758 rte_free(compress_xform); 1759 ret = TEST_FAILED; 1760 return ret; 1761 } 1762 1763 memcpy(decompress_xform, ts_params->def_decomp_xform, 1764 sizeof(struct rte_comp_xform)); 1765 1766 struct interim_data_params int_data = { 1767 NULL, 1768 1, 1769 NULL, 1770 &compress_xform, 1771 &decompress_xform, 1772 1 1773 }; 1774 1775 struct test_data_params test_data = { 1776 RTE_COMP_OP_STATELESS, 1777 LB_BOTH, 1778 ZLIB_DECOMPRESS, 1779 0, 1780 0 1781 }; 1782 1783 /* Check if driver supports crc32 checksum and test */ 1784 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM)) { 1785 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32; 1786 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32; 1787 1788 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1789 /* Compress with compressdev, decompress with Zlib */ 1790 int_data.test_bufs = &compress_test_bufs[i]; 1791 int_data.buf_idx = &i; 1792 1793 /* Generate zlib checksum and test against selected 1794 * drivers decompression checksum 1795 */ 1796 test_data.zlib_dir = ZLIB_COMPRESS; 1797 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1798 ret = TEST_FAILED; 1799 goto exit; 1800 } 1801 1802 /* Generate compression and decompression 1803 * checksum of selected driver 1804 */ 1805 test_data.zlib_dir = ZLIB_NONE; 1806 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1807 ret = TEST_FAILED; 1808 goto exit; 1809 } 1810 } 1811 } 1812 1813 /* Check if driver supports adler32 checksum and test */ 1814 if ((capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM)) { 1815 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32; 1816 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32; 1817 1818 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1819 int_data.test_bufs = &compress_test_bufs[i]; 1820 int_data.buf_idx = &i; 1821 1822 /* Generate zlib checksum and test against selected 1823 * drivers decompression checksum 1824 */ 1825 test_data.zlib_dir = ZLIB_COMPRESS; 1826 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1827 ret = TEST_FAILED; 1828 goto exit; 1829 } 1830 /* Generate compression and decompression 1831 * checksum of selected driver 1832 */ 1833 test_data.zlib_dir = ZLIB_NONE; 1834 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1835 ret = TEST_FAILED; 1836 goto exit; 1837 } 1838 } 1839 } 1840 1841 /* Check if driver supports combined crc and adler checksum and test */ 1842 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)) { 1843 compress_xform->compress.chksum = 1844 RTE_COMP_CHECKSUM_CRC32_ADLER32; 1845 decompress_xform->decompress.chksum = 1846 RTE_COMP_CHECKSUM_CRC32_ADLER32; 1847 1848 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1849 int_data.test_bufs = &compress_test_bufs[i]; 1850 int_data.buf_idx = &i; 1851 1852 /* Generate compression and decompression 1853 * checksum of selected driver 1854 */ 1855 test_data.zlib_dir = ZLIB_NONE; 1856 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1857 ret = TEST_FAILED; 1858 goto exit; 1859 } 1860 } 1861 } 1862 1863 ret = TEST_SUCCESS; 1864 1865 exit: 1866 rte_free(compress_xform); 1867 rte_free(decompress_xform); 1868 return ret; 1869 } 1870 1871 static int 1872 test_compressdev_out_of_space_buffer(void) 1873 { 1874 struct comp_testsuite_params *ts_params = &testsuite_params; 1875 int ret; 1876 uint16_t i; 1877 const struct rte_compressdev_capabilities *capab; 1878 1879 RTE_LOG(ERR, USER1, "This is a negative test errors are expected\n"); 1880 1881 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1882 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1883 1884 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0) 1885 return -ENOTSUP; 1886 1887 struct rte_comp_xform *compress_xform = 1888 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1889 1890 if (compress_xform == NULL) { 1891 RTE_LOG(ERR, USER1, 1892 "Compress xform could not be created\n"); 1893 ret = TEST_FAILED; 1894 goto exit; 1895 } 1896 1897 struct interim_data_params int_data = { 1898 &compress_test_bufs[0], 1899 1, 1900 &i, 1901 &ts_params->def_comp_xform, 1902 &ts_params->def_decomp_xform, 1903 1 1904 }; 1905 1906 struct test_data_params test_data = { 1907 RTE_COMP_OP_STATELESS, 1908 LB_BOTH, 1909 ZLIB_DECOMPRESS, 1910 1, /* run out-of-space test */ 1911 0 1912 }; 1913 /* Compress with compressdev, decompress with Zlib */ 1914 test_data.zlib_dir = ZLIB_DECOMPRESS; 1915 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1916 ret = TEST_FAILED; 1917 goto exit; 1918 } 1919 1920 /* Compress with Zlib, decompress with compressdev */ 1921 test_data.zlib_dir = ZLIB_COMPRESS; 1922 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1923 ret = TEST_FAILED; 1924 goto exit; 1925 } 1926 1927 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { 1928 /* Compress with compressdev, decompress with Zlib */ 1929 test_data.zlib_dir = ZLIB_DECOMPRESS; 1930 test_data.buff_type = SGL_BOTH; 1931 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1932 ret = TEST_FAILED; 1933 goto exit; 1934 } 1935 1936 /* Compress with Zlib, decompress with compressdev */ 1937 test_data.zlib_dir = ZLIB_COMPRESS; 1938 test_data.buff_type = SGL_BOTH; 1939 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 1940 ret = TEST_FAILED; 1941 goto exit; 1942 } 1943 } 1944 1945 ret = TEST_SUCCESS; 1946 1947 exit: 1948 rte_free(compress_xform); 1949 return ret; 1950 } 1951 1952 static int 1953 test_compressdev_deflate_stateless_dynamic_big(void) 1954 { 1955 struct comp_testsuite_params *ts_params = &testsuite_params; 1956 uint16_t i = 0; 1957 int ret = TEST_SUCCESS; 1958 int j; 1959 const struct rte_compressdev_capabilities *capab; 1960 char *test_buffer = NULL; 1961 1962 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1963 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1964 1965 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0) 1966 return -ENOTSUP; 1967 1968 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0) 1969 return -ENOTSUP; 1970 1971 test_buffer = rte_malloc(NULL, BIG_DATA_TEST_SIZE, 0); 1972 if (test_buffer == NULL) { 1973 RTE_LOG(ERR, USER1, 1974 "Can't allocate buffer for big-data\n"); 1975 return TEST_FAILED; 1976 } 1977 1978 struct interim_data_params int_data = { 1979 (const char * const *)&test_buffer, 1980 1, 1981 &i, 1982 &ts_params->def_comp_xform, 1983 &ts_params->def_decomp_xform, 1984 1 1985 }; 1986 1987 struct test_data_params test_data = { 1988 RTE_COMP_OP_STATELESS, 1989 SGL_BOTH, 1990 ZLIB_DECOMPRESS, 1991 0, 1992 1 1993 }; 1994 1995 ts_params->def_comp_xform->compress.deflate.huffman = 1996 RTE_COMP_HUFFMAN_DYNAMIC; 1997 1998 /* fill the buffer with data based on rand. data */ 1999 srand(BIG_DATA_TEST_SIZE); 2000 for (j = 0; j < BIG_DATA_TEST_SIZE - 1; ++j) 2001 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1; 2002 test_buffer[BIG_DATA_TEST_SIZE-1] = 0; 2003 2004 /* Compress with compressdev, decompress with Zlib */ 2005 test_data.zlib_dir = ZLIB_DECOMPRESS; 2006 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 2007 ret = TEST_FAILED; 2008 goto end; 2009 } 2010 2011 /* Compress with Zlib, decompress with compressdev */ 2012 test_data.zlib_dir = ZLIB_COMPRESS; 2013 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 2014 ret = TEST_FAILED; 2015 goto end; 2016 } 2017 2018 end: 2019 ts_params->def_comp_xform->compress.deflate.huffman = 2020 RTE_COMP_HUFFMAN_DEFAULT; 2021 rte_free(test_buffer); 2022 return ret; 2023 } 2024 2025 2026 static struct unit_test_suite compressdev_testsuite = { 2027 .suite_name = "compressdev unit test suite", 2028 .setup = testsuite_setup, 2029 .teardown = testsuite_teardown, 2030 .unit_test_cases = { 2031 TEST_CASE_ST(NULL, NULL, 2032 test_compressdev_invalid_configuration), 2033 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2034 test_compressdev_deflate_stateless_fixed), 2035 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2036 test_compressdev_deflate_stateless_dynamic), 2037 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2038 test_compressdev_deflate_stateless_dynamic_big), 2039 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2040 test_compressdev_deflate_stateless_multi_op), 2041 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2042 test_compressdev_deflate_stateless_multi_level), 2043 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2044 test_compressdev_deflate_stateless_multi_xform), 2045 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2046 test_compressdev_deflate_stateless_sgl), 2047 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2048 test_compressdev_deflate_stateless_checksum), 2049 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2050 test_compressdev_out_of_space_buffer), 2051 TEST_CASES_END() /**< NULL terminate unit test array */ 2052 } 2053 }; 2054 2055 static int 2056 test_compressdev(void) 2057 { 2058 return unit_test_suite_runner(&compressdev_testsuite); 2059 } 2060 2061 REGISTER_TEST_COMMAND(compressdev_autotest, test_compressdev); 2062