From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by dpdk.space (Postfix) with ESMTP id 10364A0679 for ; Tue, 2 Apr 2019 14:17:10 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id E3E5C37A8; Tue, 2 Apr 2019 14:17:03 +0200 (CEST) Received: from mga03.intel.com (mga03.intel.com [134.134.136.65]) by dpdk.org (Postfix) with ESMTP id C20A52B99 for ; Tue, 2 Apr 2019 14:17:00 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga103.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 02 Apr 2019 05:17:00 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.60,300,1549958400"; d="scan'208";a="147349866" Received: from tcelx-mobl1.ger.corp.intel.com (HELO localhost.localdomain) ([10.103.104.47]) by orsmga002.jf.intel.com with ESMTP; 02 Apr 2019 05:16:58 -0700 From: Tomasz Cel To: dev@dpdk.org, fiona.trahe@intel.com, tomaszx.jozwiak@intel.com, tomaszx.cel@intel.com Date: Tue, 2 Apr 2019 14:16:53 +0200 Message-Id: <1554207413-19049-2-git-send-email-tomaszx.cel@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1554207413-19049-1-git-send-email-tomaszx.cel@intel.com> References: <1550223873-17119-3-git-send-email-tomaszx.jozwiak@intel.com> <1554207413-19049-1-git-send-email-tomaszx.cel@intel.com> Subject: [dpdk-dev] [PATCH v2 1/1] test/compress: add max mbuf size test case X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Content-Type: text/plain; charset="UTF-8" Message-ID: <20190402121653.oOZlqK6PIINYJC-dWy2k58GsBbqtpeMiMSt-2k4TnUM@z> From: Tomasz Jozwiak This patch adds new test case in which max. size of chain mbufs has been used to compress random data dynamically. Signed-off-by: Tomasz Jozwiak --- app/test/test_compressdev.c | 158 ++++++++++++++++++++++++++++++++++++++------ 1 file changed, 136 insertions(+), 22 deletions(-) diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c index 13cf26c..f59b3d2 100644 --- a/app/test/test_compressdev.c +++ b/app/test/test_compressdev.c @@ -1,10 +1,10 @@ /* SPDX-License-Identifier: BSD-3-Clause - * Copyright(c) 2018 Intel Corporation + * Copyright(c) 2018 - 2019 Intel Corporation */ #include #include #include -#include +#include #include #include @@ -45,6 +45,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", @@ -73,6 +78,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; @@ -92,6 +98,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 }; @@ -105,11 +112,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); @@ -162,6 +172,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()); @@ -598,10 +619,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; @@ -617,10 +639,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, @@ -644,13 +666,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; } @@ -704,6 +726,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; @@ -738,7 +761,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; @@ -757,10 +782,11 @@ 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 { @@ -789,10 +815,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; } @@ -1017,10 +1045,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; } @@ -1320,6 +1350,7 @@ test_compressdev_deflate_stateless_fixed(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1390,6 +1421,7 @@ test_compressdev_deflate_stateless_dynamic(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1443,6 +1475,7 @@ test_compressdev_deflate_stateless_multi_op(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1492,6 +1525,7 @@ test_compressdev_deflate_stateless_multi_level(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1581,6 +1615,7 @@ test_compressdev_deflate_stateless_multi_xform(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1626,6 +1661,7 @@ test_compressdev_deflate_stateless_sgl(void) RTE_COMP_OP_STATELESS, SGL_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1733,6 +1769,7 @@ test_compressdev_deflate_stateless_checksum(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, + 0, 0 }; @@ -1863,7 +1900,8 @@ test_compressdev_out_of_space_buffer(void) RTE_COMP_OP_STATELESS, LB_BOTH, ZLIB_DECOMPRESS, - 1 + 1, + 0 }; /* Compress with compressdev, decompress with Zlib */ test_data.zlib_dir = ZLIB_DECOMPRESS; @@ -1904,6 +1942,80 @@ test_compressdev_out_of_space_buffer(void) 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; + 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, + NULL, + &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 (uint32_t i = 0; i < BIG_DATA_TEST_SIZE - 1; ++i) + test_buffer[i] = (uint8_t)(rand() % ((uint8_t)-1)) | 1; + + test_buffer[BIG_DATA_TEST_SIZE-1] = 0; + int_data.buf_idx = &i; + + /* 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", @@ -1917,6 +2029,8 @@ static struct unit_test_suite compressdev_testsuite = { 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, test_compressdev_deflate_stateless_multi_level), -- 2.7.4