X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_compressdev.c;h=65889c242f23eadf502b05f76d0fb7a784657e01;hb=ebbac312e448;hp=e8476edd29362735187f3b67c06a96eaa66e77f4;hpb=a9de470cc7c0649221e156fc5f30a2dbdfe7c166;p=dpdk.git diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c index e8476edd29..65889c242f 100644 --- a/app/test/test_compressdev.c +++ b/app/test/test_compressdev.c @@ -1,9 +1,11 @@ /* SPDX-License-Identifier: BSD-3-Clause - * Copyright(c) 2018 Intel Corporation + * Copyright(c) 2018 - 2019 Intel Corporation */ #include #include #include +#include +#include #include #include @@ -44,6 +46,11 @@ #define OUT_OF_SPACE_BUF 1 +#define MAX_MBUF_SEGMENT_SIZE 65535 +#define MAX_DATA_MBUF_SIZE (MAX_MBUF_SEGMENT_SIZE - RTE_PKTMBUF_HEADROOM) +#define NUM_BIG_MBUFS 4 +#define BIG_DATA_TEST_SIZE (MAX_DATA_MBUF_SIZE * NUM_BIG_MBUFS / 2) + const char * huffman_type_strings[] = { [RTE_COMP_HUFFMAN_DEFAULT] = "PMD default", @@ -72,6 +79,7 @@ struct priv_op_data { struct comp_testsuite_params { struct rte_mempool *large_mbuf_pool; struct rte_mempool *small_mbuf_pool; + struct rte_mempool *big_mbuf_pool; struct rte_mempool *op_pool; struct rte_comp_xform *def_comp_xform; struct rte_comp_xform *def_decomp_xform; @@ -91,6 +99,7 @@ struct test_data_params { enum varied_buff buff_type; enum zlib_direction zlib_dir; unsigned int out_of_space; + unsigned int big_data; }; static struct comp_testsuite_params testsuite_params = { 0 }; @@ -104,11 +113,14 @@ testsuite_teardown(void) RTE_LOG(ERR, USER1, "Large mbuf pool still has unfreed bufs\n"); if (rte_mempool_in_use_count(ts_params->small_mbuf_pool)) RTE_LOG(ERR, USER1, "Small mbuf pool still has unfreed bufs\n"); + if (rte_mempool_in_use_count(ts_params->big_mbuf_pool)) + RTE_LOG(ERR, USER1, "Big mbuf pool still has unfreed bufs\n"); if (rte_mempool_in_use_count(ts_params->op_pool)) RTE_LOG(ERR, USER1, "op pool still has unfreed ops\n"); rte_mempool_free(ts_params->large_mbuf_pool); rte_mempool_free(ts_params->small_mbuf_pool); + rte_mempool_free(ts_params->big_mbuf_pool); rte_mempool_free(ts_params->op_pool); rte_free(ts_params->def_comp_xform); rte_free(ts_params->def_decomp_xform); @@ -122,8 +134,8 @@ testsuite_setup(void) unsigned int i; if (rte_compressdev_count() == 0) { - RTE_LOG(ERR, USER1, "Need at least one compress device\n"); - return TEST_FAILED; + RTE_LOG(WARNING, USER1, "Need at least one compress device\n"); + return TEST_SKIPPED; } RTE_LOG(NOTICE, USER1, "Running tests on device %s\n", @@ -161,6 +173,17 @@ testsuite_setup(void) goto exit; } + /* Create mempool with big buffers for SGL testing */ + ts_params->big_mbuf_pool = rte_pktmbuf_pool_create("big_mbuf_pool", + NUM_BIG_MBUFS + 1, + CACHE_SIZE, 0, + MAX_MBUF_SEGMENT_SIZE, + rte_socket_id()); + if (ts_params->big_mbuf_pool == NULL) { + RTE_LOG(ERR, USER1, "Big mbuf pool could not be created\n"); + goto exit; + } + ts_params->op_pool = rte_comp_op_pool_create("op_pool", NUM_OPS, 0, sizeof(struct priv_op_data), rte_socket_id()); @@ -597,10 +620,11 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, uint32_t total_data_size, struct rte_mempool *small_mbuf_pool, struct rte_mempool *large_mbuf_pool, - uint8_t limit_segs_in_sgl) + uint8_t limit_segs_in_sgl, + uint16_t seg_size) { uint32_t remaining_data = total_data_size; - uint16_t num_remaining_segs = DIV_CEIL(remaining_data, SMALL_SEG_SIZE); + uint16_t num_remaining_segs = DIV_CEIL(remaining_data, seg_size); struct rte_mempool *pool; struct rte_mbuf *next_seg; uint32_t data_size; @@ -616,10 +640,10 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, * Allocate data in the first segment (header) and * copy data if test buffer is provided */ - if (remaining_data < SMALL_SEG_SIZE) + if (remaining_data < seg_size) data_size = remaining_data; else - data_size = SMALL_SEG_SIZE; + data_size = seg_size; buf_ptr = rte_pktmbuf_append(head_buf, data_size); if (buf_ptr == NULL) { RTE_LOG(ERR, USER1, @@ -643,13 +667,13 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, if (i == (num_remaining_segs - 1)) { /* last segment */ - if (remaining_data > SMALL_SEG_SIZE) + if (remaining_data > seg_size) pool = large_mbuf_pool; else pool = small_mbuf_pool; data_size = remaining_data; } else { - data_size = SMALL_SEG_SIZE; + data_size = seg_size; pool = small_mbuf_pool; } @@ -703,6 +727,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, enum rte_comp_op_type state = test_data->state; unsigned int buff_type = test_data->buff_type; unsigned int out_of_space = test_data->out_of_space; + unsigned int big_data = test_data->big_data; enum zlib_direction zlib_dir = test_data->zlib_dir; int ret_status = -1; int ret; @@ -737,7 +762,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs); memset(priv_xforms, 0, sizeof(void *) * num_bufs); - if (buff_type == SGL_BOTH) + if (big_data) + buf_pool = ts_params->big_mbuf_pool; + else if (buff_type == SGL_BOTH) buf_pool = ts_params->small_mbuf_pool; else buf_pool = ts_params->large_mbuf_pool; @@ -756,17 +783,18 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, for (i = 0; i < num_bufs; i++) { data_size = strlen(test_bufs[i]) + 1; if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i], - data_size, - ts_params->small_mbuf_pool, - ts_params->large_mbuf_pool, - MAX_SEGS) < 0) + data_size, + big_data ? buf_pool : ts_params->small_mbuf_pool, + big_data ? buf_pool : ts_params->large_mbuf_pool, + big_data ? 0 : MAX_SEGS, + big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0) goto exit; } } else { for (i = 0; i < num_bufs; i++) { data_size = strlen(test_bufs[i]) + 1; buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size); - snprintf(buf_ptr, data_size, "%s", test_bufs[i]); + strlcpy(buf_ptr, test_bufs[i], data_size); } } @@ -788,10 +816,12 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, COMPRESS_BUF_SIZE_RATIO); if (prepare_sgl_bufs(NULL, comp_bufs[i], - data_size, - ts_params->small_mbuf_pool, - ts_params->large_mbuf_pool, - MAX_SEGS) < 0) + data_size, + big_data ? buf_pool : ts_params->small_mbuf_pool, + big_data ? buf_pool : ts_params->large_mbuf_pool, + big_data ? 0 : MAX_SEGS, + big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) + < 0) goto exit; } @@ -1016,10 +1046,12 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, strlen(test_bufs[priv_data->orig_idx]) + 1; if (prepare_sgl_bufs(NULL, uncomp_bufs[i], - data_size, - ts_params->small_mbuf_pool, - ts_params->large_mbuf_pool, - MAX_SEGS) < 0) + data_size, + big_data ? buf_pool : ts_params->small_mbuf_pool, + big_data ? buf_pool : ts_params->large_mbuf_pool, + big_data ? 0 : MAX_SEGS, + big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) + < 0) goto exit; } @@ -1319,6 +1351,7 @@ test_compressdev_deflate_stateless_fixed(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1389,6 +1422,7 @@ test_compressdev_deflate_stateless_dynamic(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1442,6 +1476,7 @@ test_compressdev_deflate_stateless_multi_op(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1491,6 +1526,7 @@ test_compressdev_deflate_stateless_multi_level(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1580,6 +1616,7 @@ test_compressdev_deflate_stateless_multi_xform(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1625,6 +1662,7 @@ test_compressdev_deflate_stateless_sgl(void) RTE_COMP_OP_STATELESS, SGL_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1732,6 +1770,7 @@ test_compressdev_deflate_stateless_checksum(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1831,7 +1870,7 @@ test_compressdev_out_of_space_buffer(void) uint16_t i; const struct rte_compressdev_capabilities *capab; - RTE_LOG(INFO, USER1, "This is a negative test errors are expected\n"); + RTE_LOG(ERR, USER1, "This is a negative test errors are expected\n"); capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); @@ -1862,7 +1901,8 @@ test_compressdev_out_of_space_buffer(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, - 1 + 1, /* run out-of-space test */ + 0 }; /* Compress with compressdev, decompress with Zlib */ test_data.zlib_dir = ZLIB_DECOMPRESS; @@ -1903,6 +1943,79 @@ exit: return ret; } +static int +test_compressdev_deflate_stateless_dynamic_big(void) +{ + struct comp_testsuite_params *ts_params = &testsuite_params; + uint16_t i = 0; + int ret = TEST_SUCCESS; + int j; + const struct rte_compressdev_capabilities *capab; + char *test_buffer = NULL; + + capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); + TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); + + if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0) + return -ENOTSUP; + + if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0) + return -ENOTSUP; + + test_buffer = rte_malloc(NULL, BIG_DATA_TEST_SIZE, 0); + if (test_buffer == NULL) { + RTE_LOG(ERR, USER1, + "Can't allocate buffer for big-data\n"); + return TEST_FAILED; + } + + struct interim_data_params int_data = { + (const char * const *)&test_buffer, + 1, + &i, + &ts_params->def_comp_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + SGL_BOTH, + ZLIB_DECOMPRESS, + 0, + 1 + }; + + ts_params->def_comp_xform->compress.deflate.huffman = + RTE_COMP_HUFFMAN_DYNAMIC; + + /* fill the buffer with data based on rand. data */ + srand(BIG_DATA_TEST_SIZE); + for (j = 0; j < BIG_DATA_TEST_SIZE - 1; ++j) + test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1; + test_buffer[BIG_DATA_TEST_SIZE-1] = 0; + + /* Compress with compressdev, decompress with Zlib */ + test_data.zlib_dir = ZLIB_DECOMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { + ret = TEST_FAILED; + goto end; + } + + /* Compress with Zlib, decompress with compressdev */ + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { + ret = TEST_FAILED; + goto end; + } + +end: + ts_params->def_comp_xform->compress.deflate.huffman = + RTE_COMP_HUFFMAN_DEFAULT; + rte_free(test_buffer); + return ret; +} + static struct unit_test_suite compressdev_testsuite = { .suite_name = "compressdev unit test suite", @@ -1915,6 +2028,8 @@ static struct unit_test_suite compressdev_testsuite = { test_compressdev_deflate_stateless_fixed), TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, test_compressdev_deflate_stateless_dynamic), + TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, + test_compressdev_deflate_stateless_dynamic_big), TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, test_compressdev_deflate_stateless_multi_op), TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,