From patchwork Fri Jan 11 15:08:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Kovacevic, Marko" X-Patchwork-Id: 49728 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id C14A31B997; Fri, 11 Jan 2019 16:09:10 +0100 (CET) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by dpdk.org (Postfix) with ESMTP id 37E221B645 for ; Fri, 11 Jan 2019 16:09:08 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga106.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 11 Jan 2019 07:09:07 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,466,1539673200"; d="scan'208";a="125284329" Received: from silpixa00399502.ir.intel.com (HELO silpixa00399502.ger.corp.intel.com) ([10.237.222.111]) by orsmga002.jf.intel.com with ESMTP; 11 Jan 2019 07:09:06 -0800 From: "Kovacevic, Marko" To: dev@dpdk.org Cc: akhil.goyal@nxp.com, pablo.de.lara.guarch@intel.com Date: Fri, 11 Jan 2019 15:08:58 +0000 Message-Id: <20190111150900.11429-2-marko.kovacevic@intel.com> X-Mailer: git-send-email 2.9.5 In-Reply-To: <20190111150900.11429-1-marko.kovacevic@intel.com> References: <20181220145824.37223-1-marko.kovacevic@intel.com> <20190111150900.11429-1-marko.kovacevic@intel.com> Subject: [dpdk-dev] [PATCH v3 1/3] test/compress: refactor main test function 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" From: Pablo de Lara Since the start of the compression tests, the main test function, test_deflate_comp_decomp, has increased its parameter with each new test added. In order to make the code cleaner, and more scalable, these parameters have been divided into two structures, which are now passed as the sole arguments of the function. Signed-off-by: Pablo de Lara --- test/test/test_compressdev.c | 319 ++++++++++++++++++++++++------------------- 1 file changed, 178 insertions(+), 141 deletions(-) diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c index 6a2a341..20895fc 100644 --- a/test/test/test_compressdev.c +++ b/test/test/test_compressdev.c @@ -68,6 +68,21 @@ struct comp_testsuite_params { struct rte_comp_xform *def_decomp_xform; }; +struct interim_data_params { + const char * const *test_bufs; + unsigned int num_bufs; + uint16_t *buf_idx; + struct rte_comp_xform **compress_xforms; + struct rte_comp_xform **decompress_xforms; + unsigned int num_xforms; +}; + +struct test_data_params { + enum rte_comp_op_type state; + unsigned int sgl; + enum zlib_direction zlib_dir; +}; + static struct comp_testsuite_params testsuite_params = { 0 }; static void @@ -650,17 +665,19 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, * Compresses and decompresses buffer with compressdev API and Zlib API */ static int -test_deflate_comp_decomp(const char * const test_bufs[], - unsigned int num_bufs, - uint16_t buf_idx[], - struct rte_comp_xform *compress_xforms[], - struct rte_comp_xform *decompress_xforms[], - unsigned int num_xforms, - enum rte_comp_op_type state, - unsigned int sgl, - enum zlib_direction zlib_dir) +test_deflate_comp_decomp(const struct interim_data_params *int_data, + const struct test_data_params *test_data) { struct comp_testsuite_params *ts_params = &testsuite_params; + const char * const *test_bufs = int_data->test_bufs; + unsigned int num_bufs = int_data->num_bufs; + uint16_t *buf_idx = int_data->buf_idx; + struct rte_comp_xform **compress_xforms = int_data->compress_xforms; + struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms; + unsigned int num_xforms = int_data->num_xforms; + enum rte_comp_op_type state = test_data->state; + unsigned int sgl = test_data->sgl; + enum zlib_direction zlib_dir = test_data->zlib_dir; int ret_status = -1; int ret; struct rte_mbuf *uncomp_bufs[num_bufs]; @@ -1179,7 +1196,6 @@ static int test_compressdev_deflate_stateless_fixed(void) { struct comp_testsuite_params *ts_params = &testsuite_params; - const char *test_buffer; uint16_t i; int ret; const struct rte_compressdev_capabilities *capab; @@ -1204,31 +1220,35 @@ test_compressdev_deflate_stateless_fixed(void) sizeof(struct rte_comp_xform)); compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED; + struct interim_data_params int_data = { + NULL, + 1, + NULL, + &compress_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 0, + ZLIB_DECOMPRESS + }; + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { - test_buffer = compress_test_bufs[i]; + int_data.test_bufs = &compress_test_bufs[i]; + int_data.buf_idx = &i; /* Compress with compressdev, decompress with Zlib */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_DECOMPRESS) < 0) { + test_data.zlib_dir = ZLIB_DECOMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } /* Compress with Zlib, decompress with compressdev */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_COMPRESS) < 0) { + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } @@ -1245,7 +1265,6 @@ static int test_compressdev_deflate_stateless_dynamic(void) { struct comp_testsuite_params *ts_params = &testsuite_params; - const char *test_buffer; uint16_t i; int ret; struct rte_comp_xform *compress_xform = @@ -1270,31 +1289,35 @@ test_compressdev_deflate_stateless_dynamic(void) sizeof(struct rte_comp_xform)); compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC; + struct interim_data_params int_data = { + NULL, + 1, + NULL, + &compress_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 0, + ZLIB_DECOMPRESS + }; + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { - test_buffer = compress_test_bufs[i]; + int_data.test_bufs = &compress_test_bufs[i]; + int_data.buf_idx = &i; /* Compress with compressdev, decompress with Zlib */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_DECOMPRESS) < 0) { + test_data.zlib_dir = ZLIB_DECOMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } /* Compress with Zlib, decompress with compressdev */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_COMPRESS) < 0) { + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } @@ -1318,26 +1341,29 @@ test_compressdev_deflate_stateless_multi_op(void) for (i = 0; i < num_bufs; i++) buf_idx[i] = i; + struct interim_data_params int_data = { + compress_test_bufs, + num_bufs, + buf_idx, + &ts_params->def_comp_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 0, + ZLIB_DECOMPRESS + }; + /* Compress with compressdev, decompress with Zlib */ - if (test_deflate_comp_decomp(compress_test_bufs, num_bufs, - buf_idx, - &ts_params->def_comp_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_DECOMPRESS) < 0) + test_data.zlib_dir = ZLIB_DECOMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) return TEST_FAILED; /* Compress with Zlib, decompress with compressdev */ - if (test_deflate_comp_decomp(compress_test_bufs, num_bufs, - buf_idx, - &ts_params->def_comp_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_COMPRESS) < 0) + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) return TEST_FAILED; return TEST_SUCCESS; @@ -1347,7 +1373,6 @@ static int test_compressdev_deflate_stateless_multi_level(void) { struct comp_testsuite_params *ts_params = &testsuite_params; - const char *test_buffer; unsigned int level; uint16_t i; int ret; @@ -1364,20 +1389,31 @@ test_compressdev_deflate_stateless_multi_level(void) memcpy(compress_xform, ts_params->def_comp_xform, sizeof(struct rte_comp_xform)); + struct interim_data_params int_data = { + NULL, + 1, + NULL, + &compress_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 0, + ZLIB_DECOMPRESS + }; + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { - test_buffer = compress_test_bufs[i]; + int_data.test_bufs = &compress_test_bufs[i]; + int_data.buf_idx = &i; + for (level = RTE_COMP_LEVEL_MIN; level <= RTE_COMP_LEVEL_MAX; level++) { compress_xform->compress.level = level; /* Compress with compressdev, decompress with Zlib */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_DECOMPRESS) < 0) { + test_data.zlib_dir = ZLIB_DECOMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } @@ -1440,15 +1476,24 @@ test_compressdev_deflate_stateless_multi_xform(void) /* Use the same buffer in all sessions */ test_buffers[i] = compress_test_bufs[0]; } + + struct interim_data_params int_data = { + test_buffers, + num_bufs, + buf_idx, + compress_xforms, + decompress_xforms, + NUM_XFORMS + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 0, + ZLIB_DECOMPRESS + }; + /* Compress with compressdev, decompress with Zlib */ - if (test_deflate_comp_decomp(test_buffers, num_bufs, - buf_idx, - compress_xforms, - decompress_xforms, - NUM_XFORMS, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_DECOMPRESS) < 0) { + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } @@ -1468,7 +1513,6 @@ test_compressdev_deflate_stateless_sgl(void) { struct comp_testsuite_params *ts_params = &testsuite_params; uint16_t i; - const char *test_buffer; const struct rte_compressdev_capabilities *capab; capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); @@ -1477,28 +1521,33 @@ test_compressdev_deflate_stateless_sgl(void) if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0) return -ENOTSUP; + struct interim_data_params int_data = { + NULL, + 1, + NULL, + &ts_params->def_comp_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 1, + ZLIB_DECOMPRESS + }; + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { - test_buffer = compress_test_bufs[i]; + int_data.test_bufs = &compress_test_bufs[i]; + int_data.buf_idx = &i; + /* Compress with compressdev, decompress with Zlib */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &ts_params->def_comp_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 1, - ZLIB_DECOMPRESS) < 0) + test_data.zlib_dir = ZLIB_DECOMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) return TEST_FAILED; /* Compress with Zlib, decompress with compressdev */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &ts_params->def_comp_xform, - &ts_params->def_decomp_xform, - 1, - RTE_COMP_OP_STATELESS, - 1, - ZLIB_COMPRESS) < 0) + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) return TEST_FAILED; } @@ -1510,7 +1559,6 @@ static int test_compressdev_deflate_stateless_checksum(void) { struct comp_testsuite_params *ts_params = &testsuite_params; - const char *test_buffer; uint16_t i; int ret; const struct rte_compressdev_capabilities *capab; @@ -1549,25 +1597,36 @@ test_compressdev_deflate_stateless_checksum(void) memcpy(decompress_xform, ts_params->def_decomp_xform, sizeof(struct rte_comp_xform)); + struct interim_data_params int_data = { + NULL, + 1, + NULL, + &compress_xform, + &decompress_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 0, + ZLIB_DECOMPRESS + }; + /* Check if driver supports crc32 checksum and test */ if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM)) { compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32; decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { - test_buffer = compress_test_bufs[i]; + /* Compress with compressdev, decompress with Zlib */ + int_data.test_bufs = &compress_test_bufs[i]; + int_data.buf_idx = &i; /* Generate zlib checksum and test against selected * drivers decompression checksum */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &decompress_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_COMPRESS) < 0) { + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } @@ -1575,14 +1634,8 @@ test_compressdev_deflate_stateless_checksum(void) /* Generate compression and decompression * checksum of selected driver */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &decompress_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_NONE) < 0) { + test_data.zlib_dir = ZLIB_NONE; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } @@ -1595,33 +1648,22 @@ test_compressdev_deflate_stateless_checksum(void) decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { - test_buffer = compress_test_bufs[i]; + int_data.test_bufs = &compress_test_bufs[i]; + int_data.buf_idx = &i; /* Generate zlib checksum and test against selected * drivers decompression checksum */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &decompress_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_COMPRESS) < 0) { + test_data.zlib_dir = ZLIB_COMPRESS; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } /* Generate compression and decompression * checksum of selected driver */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &decompress_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_NONE) < 0) { + test_data.zlib_dir = ZLIB_NONE; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } @@ -1636,19 +1678,14 @@ test_compressdev_deflate_stateless_checksum(void) RTE_COMP_CHECKSUM_CRC32_ADLER32; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { - test_buffer = compress_test_bufs[i]; + int_data.test_bufs = &compress_test_bufs[i]; + int_data.buf_idx = &i; /* Generate compression and decompression * checksum of selected driver */ - if (test_deflate_comp_decomp(&test_buffer, 1, - &i, - &compress_xform, - &decompress_xform, - 1, - RTE_COMP_OP_STATELESS, - 0, - ZLIB_NONE) < 0) { + test_data.zlib_dir = ZLIB_NONE; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; } From patchwork Fri Jan 11 15:08:59 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Kovacevic, Marko" X-Patchwork-Id: 49729 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 484F11B9DD; Fri, 11 Jan 2019 16:09:12 +0100 (CET) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by dpdk.org (Postfix) with ESMTP id CF0A21B8C4 for ; Fri, 11 Jan 2019 16:09:09 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga106.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 11 Jan 2019 07:09:09 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,466,1539673200"; d="scan'208";a="125284344" Received: from silpixa00399502.ir.intel.com (HELO silpixa00399502.ger.corp.intel.com) ([10.237.222.111]) by orsmga002.jf.intel.com with ESMTP; 11 Jan 2019 07:09:08 -0800 From: "Kovacevic, Marko" To: dev@dpdk.org Cc: akhil.goyal@nxp.com, pablo.de.lara.guarch@intel.com, "Kovacevic, Marko" , Kovacevic@dpdk.org Date: Fri, 11 Jan 2019 15:08:59 +0000 Message-Id: <20190111150900.11429-3-marko.kovacevic@intel.com> X-Mailer: git-send-email 2.9.5 In-Reply-To: <20190111150900.11429-1-marko.kovacevic@intel.com> References: <20181220145824.37223-1-marko.kovacevic@intel.com> <20190111150900.11429-1-marko.kovacevic@intel.com> Subject: [dpdk-dev] [PATCH v3 2/3] test/compress: add out of space test 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" This patch adds new out of space testcase to check that the destination mbuf is smaller than required for the output of compression to ensure the driver doesn't crash and returns the valid error case. Signed-off-by: Kovacevic, Marko --- test/test/test_compressdev.c | 178 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 165 insertions(+), 13 deletions(-) diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c index 20895fc..1e41113 100644 --- a/test/test/test_compressdev.c +++ b/test/test/test_compressdev.c @@ -42,6 +42,8 @@ #define GZIP_HEADER_SIZE 10 #define GZIP_TRAILER_SIZE 8 +#define OUT_OF_SPACE_BUF 1 + const char * huffman_type_strings[] = { [RTE_COMP_HUFFMAN_DEFAULT] = "PMD default", @@ -81,6 +83,7 @@ struct test_data_params { enum rte_comp_op_type state; unsigned int sgl; enum zlib_direction zlib_dir; + unsigned int out_of_space; }; static struct comp_testsuite_params testsuite_params = { 0 }; @@ -677,6 +680,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, unsigned int num_xforms = int_data->num_xforms; enum rte_comp_op_type state = test_data->state; unsigned int sgl = test_data->sgl; + unsigned int out_of_space = test_data->out_of_space; enum zlib_direction zlib_dir = test_data->zlib_dir; int ret_status = -1; int ret; @@ -693,6 +697,12 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, unsigned int i; struct rte_mempool *buf_pool; uint32_t data_size; + /* Compressing with CompressDev */ + unsigned int oos_zlib_decompress = + (zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_DECOMPRESS); + /* Decompressing with CompressDev */ + unsigned int oos_zlib_compress = + (zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_COMPRESS); const struct rte_compressdev_capabilities *capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); char *contig_buf = NULL; @@ -749,8 +759,12 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, if (sgl) { for (i = 0; i < num_bufs; i++) { - data_size = strlen(test_bufs[i]) * - COMPRESS_BUF_SIZE_RATIO; + if (out_of_space == 1 && oos_zlib_decompress) { + data_size = OUT_OF_SPACE_BUF; + } else { + (data_size = strlen(test_bufs[i]) * + COMPRESS_BUF_SIZE_RATIO); + } if (prepare_sgl_bufs(NULL, comp_bufs[i], data_size, ts_params->small_mbuf_pool, @@ -761,8 +775,12 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, } else { for (i = 0; i < num_bufs; i++) { - data_size = strlen(test_bufs[i]) * - COMPRESS_BUF_SIZE_RATIO; + if (out_of_space == 1 && oos_zlib_decompress) { + data_size = OUT_OF_SPACE_BUF; + } else { + (data_size = strlen(test_bufs[i]) * + COMPRESS_BUF_SIZE_RATIO); + } rte_pktmbuf_append(comp_bufs[i], data_size); } } @@ -928,6 +946,18 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, * compress operation information is needed for the decompression stage) */ for (i = 0; i < num_bufs; i++) { + if (out_of_space && oos_zlib_decompress) { + if (ops_processed[i]->status != + RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) { + ret_status = -1; + + RTE_LOG(ERR, USER1, + "Out of Space operation was not successful\n"); + goto exit; + } else + continue; + } + if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) { RTE_LOG(ERR, USER1, "Some operations were not successful\n"); @@ -938,6 +968,11 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, uncomp_bufs[priv_data->orig_idx] = NULL; } + if (out_of_space && oos_zlib_decompress) { + ret_status = 0; + goto exit; + } + /* Allocate buffers for decompressed data */ ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs); if (ret < 0) { @@ -951,7 +986,12 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, for (i = 0; i < num_bufs; i++) { priv_data = (struct priv_op_data *) (ops_processed[i] + 1); - data_size = strlen(test_bufs[priv_data->orig_idx]) + 1; + if (out_of_space == 1 && oos_zlib_compress) + data_size = OUT_OF_SPACE_BUF; + else + data_size = + strlen(test_bufs[priv_data->orig_idx]) + 1; + if (prepare_sgl_bufs(NULL, uncomp_bufs[i], data_size, ts_params->small_mbuf_pool, @@ -964,7 +1004,12 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, for (i = 0; i < num_bufs; i++) { priv_data = (struct priv_op_data *) (ops_processed[i] + 1); - data_size = strlen(test_bufs[priv_data->orig_idx]) + 1; + if (out_of_space == 1 && oos_zlib_compress) + data_size = OUT_OF_SPACE_BUF; + else + data_size = + strlen(test_bufs[priv_data->orig_idx]) + 1; + rte_pktmbuf_append(uncomp_bufs[i], data_size); } } @@ -1125,6 +1170,18 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, * compress operation information is still needed) */ for (i = 0; i < num_bufs; i++) { + if (out_of_space && oos_zlib_compress) { + if (ops_processed[i]->status != + RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) { + ret_status = -1; + + RTE_LOG(ERR, USER1, + "Out of Space operation was not successful\n"); + goto exit; + } else + continue; + } + if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) { RTE_LOG(ERR, USER1, "Some operations were not successful\n"); @@ -1135,6 +1192,11 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, comp_bufs[priv_data->orig_idx] = NULL; } + if (out_of_space && oos_zlib_compress) { + ret_status = 0; + goto exit; + } + /* * Compare the original stream with the decompressed stream * (in size and the data) @@ -1232,7 +1294,8 @@ test_compressdev_deflate_stateless_fixed(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS + ZLIB_DECOMPRESS, + 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1301,7 +1364,8 @@ test_compressdev_deflate_stateless_dynamic(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS + ZLIB_DECOMPRESS, + 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1353,7 +1417,8 @@ test_compressdev_deflate_stateless_multi_op(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS + ZLIB_DECOMPRESS, + 0 }; /* Compress with compressdev, decompress with Zlib */ @@ -1401,7 +1466,8 @@ test_compressdev_deflate_stateless_multi_level(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS + ZLIB_DECOMPRESS, + 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1489,7 +1555,8 @@ test_compressdev_deflate_stateless_multi_xform(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS + ZLIB_DECOMPRESS, + 0 }; /* Compress with compressdev, decompress with Zlib */ @@ -1533,7 +1600,8 @@ test_compressdev_deflate_stateless_sgl(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, 1, - ZLIB_DECOMPRESS + ZLIB_DECOMPRESS, + 0 }; for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { @@ -1609,7 +1677,8 @@ test_compressdev_deflate_stateless_checksum(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS + ZLIB_DECOMPRESS, + 0 }; /* Check if driver supports crc32 checksum and test */ @@ -1700,6 +1769,87 @@ test_compressdev_deflate_stateless_checksum(void) return ret; } +static int +test_compressdev_out_of_space_buffer(void) +{ + struct comp_testsuite_params *ts_params = &testsuite_params; + int ret; + uint16_t i; + const struct rte_compressdev_capabilities *capab; + + RTE_LOG(INFO, 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"); + + if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0) + return -ENOTSUP; + + struct rte_comp_xform *compress_xform = + rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); + + if (compress_xform == NULL) { + RTE_LOG(ERR, USER1, + "Compress xform could not be created\n"); + ret = TEST_FAILED; + goto exit; + } + + struct interim_data_params int_data = { + &compress_test_bufs[0], + 1, + &i, + &ts_params->def_comp_xform, + &ts_params->def_decomp_xform, + 1 + }; + + struct test_data_params test_data = { + RTE_COMP_OP_STATELESS, + 0, + ZLIB_DECOMPRESS, + 1 + }; + /* 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 exit; + } + + /* 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 exit; + } + + if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { + /* Compress with compressdev, decompress with Zlib */ + test_data.zlib_dir = ZLIB_DECOMPRESS; + test_data.sgl = 1; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { + ret = TEST_FAILED; + goto exit; + } + + /* Compress with Zlib, decompress with compressdev */ + test_data.zlib_dir = ZLIB_COMPRESS; + test_data.sgl = 1; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { + ret = TEST_FAILED; + goto exit; + } + } + + ret = TEST_SUCCESS; + +exit: + rte_free(compress_xform); + return ret; +} + + static struct unit_test_suite compressdev_testsuite = { .suite_name = "compressdev unit test suite", .setup = testsuite_setup, @@ -1721,6 +1871,8 @@ static struct unit_test_suite compressdev_testsuite = { test_compressdev_deflate_stateless_sgl), TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, test_compressdev_deflate_stateless_checksum), + TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, + test_compressdev_out_of_space_buffer), TEST_CASES_END() /**< NULL terminate unit test array */ } }; From patchwork Fri Jan 11 15:09:00 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Kovacevic, Marko" X-Patchwork-Id: 49730 X-Patchwork-Delegate: gakhil@marvell.com Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id C9C0B1BA42; Fri, 11 Jan 2019 16:09:15 +0100 (CET) Received: from mga18.intel.com (mga18.intel.com [134.134.136.126]) by dpdk.org (Postfix) with ESMTP id 6A0401B9CB for ; Fri, 11 Jan 2019 16:09:11 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga106.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 11 Jan 2019 07:09:11 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,466,1539673200"; d="scan'208";a="125284350" Received: from silpixa00399502.ir.intel.com (HELO silpixa00399502.ger.corp.intel.com) ([10.237.222.111]) by orsmga002.jf.intel.com with ESMTP; 11 Jan 2019 07:09:09 -0800 From: "Kovacevic, Marko" To: dev@dpdk.org Cc: akhil.goyal@nxp.com, pablo.de.lara.guarch@intel.com, "Kovacevic, Marko" , Kovacevic@dpdk.org Date: Fri, 11 Jan 2019 15:09:00 +0000 Message-Id: <20190111150900.11429-4-marko.kovacevic@intel.com> X-Mailer: git-send-email 2.9.5 In-Reply-To: <20190111150900.11429-1-marko.kovacevic@intel.com> References: <20181220145824.37223-1-marko.kovacevic@intel.com> <20190111150900.11429-1-marko.kovacevic@intel.com> Subject: [dpdk-dev] [PATCH v3 3/3] test/compress: add varied buffer input/outputs 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" Added unit test to check if a SGL buffer was added as an input and a Linear Buffer as output and vice versa so we can test if the application would process the different buffers properly. Signed-off-by: Kovacevic, Marko --- test/test/test_compressdev.c | 123 ++++++++++++++++++++++++++++++------------- 1 file changed, 87 insertions(+), 36 deletions(-) diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c index 1e41113..9c43ed1 100644 --- a/test/test/test_compressdev.c +++ b/test/test/test_compressdev.c @@ -58,6 +58,13 @@ enum zlib_direction { ZLIB_ALL }; +enum varied_buff { + LB_BOTH = 0, /* both input and output are linear*/ + SGL_BOTH, /* both input and output are chained */ + SGL_TO_LB, /* input buffer is chained */ + LB_TO_SGL /* output buffer is chained */ +}; + struct priv_op_data { uint16_t orig_idx; }; @@ -81,7 +88,7 @@ struct interim_data_params { struct test_data_params { enum rte_comp_op_type state; - unsigned int sgl; + enum varied_buff buff_type; enum zlib_direction zlib_dir; unsigned int out_of_space; }; @@ -368,7 +375,7 @@ compress_zlib(struct rte_comp_op *op, } /* Assuming stateless operation */ - /* SGL */ + /* SGL Input */ if (op->m_src->nb_segs > 1) { single_src_buf = rte_malloc(NULL, rte_pktmbuf_pkt_len(op->m_src), 0); @@ -376,14 +383,10 @@ compress_zlib(struct rte_comp_op *op, RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); goto exit; } - single_dst_buf = rte_malloc(NULL, - rte_pktmbuf_pkt_len(op->m_dst), 0); - if (single_dst_buf == NULL) { - RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); - goto exit; - } - if (rte_pktmbuf_read(op->m_src, 0, - rte_pktmbuf_pkt_len(op->m_src), + + if (rte_pktmbuf_read(op->m_src, op->src.offset, + rte_pktmbuf_pkt_len(op->m_src) - + op->src.offset, single_src_buf) == NULL) { RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n"); @@ -392,15 +395,31 @@ compress_zlib(struct rte_comp_op *op, stream.avail_in = op->src.length; stream.next_in = single_src_buf; - stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst); - stream.next_out = single_dst_buf; } else { stream.avail_in = op->src.length; - stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *); + stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *, + op->src.offset); + } + /* SGL output */ + if (op->m_dst->nb_segs > 1) { + + single_dst_buf = rte_malloc(NULL, + rte_pktmbuf_pkt_len(op->m_dst), 0); + if (single_dst_buf == NULL) { + RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); + goto exit; + } + + stream.avail_out = op->m_dst->pkt_len; + stream.next_out = single_dst_buf; + + } else {/* linear output */ stream.avail_out = op->m_dst->data_len; - stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *); + stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *, + op->dst.offset); } + /* Stateless operation, all buffer will be compressed in one go */ zlib_flush = map_zlib_flush_flag(op->flush_flag); ret = deflate(&stream, zlib_flush); @@ -414,14 +433,14 @@ compress_zlib(struct rte_comp_op *op, goto exit; /* Copy data to destination SGL */ - if (op->m_src->nb_segs > 1) { + if (op->m_dst->nb_segs > 1) { uint32_t remaining_data = stream.total_out; uint8_t *src_data = single_dst_buf; struct rte_mbuf *dst_buf = op->m_dst; while (remaining_data > 0) { - uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf, - uint8_t *); + uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf, + uint8_t *, op->dst.offset); /* Last segment */ if (remaining_data < dst_buf->data_len) { memcpy(dst_data, src_data, remaining_data); @@ -438,12 +457,14 @@ compress_zlib(struct rte_comp_op *op, op->consumed = stream.total_in; if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) { rte_pktmbuf_adj(op->m_dst, ZLIB_HEADER_SIZE); - op->produced = stream.total_out - - (ZLIB_HEADER_SIZE + ZLIB_TRAILER_SIZE); + rte_pktmbuf_trim(op->m_dst, ZLIB_TRAILER_SIZE); + op->produced = stream.total_out - (ZLIB_HEADER_SIZE + + ZLIB_TRAILER_SIZE); } else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) { rte_pktmbuf_adj(op->m_dst, GZIP_HEADER_SIZE); - op->produced = stream.total_out - - (GZIP_HEADER_SIZE + GZIP_TRAILER_SIZE); + rte_pktmbuf_trim(op->m_dst, GZIP_TRAILER_SIZE); + op->produced = stream.total_out - (GZIP_HEADER_SIZE + + GZIP_TRAILER_SIZE); } else op->produced = stream.total_out; @@ -679,7 +700,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms; unsigned int num_xforms = int_data->num_xforms; enum rte_comp_op_type state = test_data->state; - unsigned int sgl = test_data->sgl; + unsigned int buff_type = test_data->buff_type; unsigned int out_of_space = test_data->out_of_space; enum zlib_direction zlib_dir = test_data->zlib_dir; int ret_status = -1; @@ -715,7 +736,7 @@ 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 (sgl) + if (buff_type == SGL_BOTH) buf_pool = ts_params->small_mbuf_pool; else buf_pool = ts_params->large_mbuf_pool; @@ -730,7 +751,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, goto exit; } - if (sgl) { + if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) { for (i = 0; i < num_bufs; i++) { data_size = strlen(test_bufs[i]) + 1; if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i], @@ -757,7 +778,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, goto exit; } - if (sgl) { + if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { for (i = 0; i < num_bufs; i++) { if (out_of_space == 1 && oos_zlib_decompress) { data_size = OUT_OF_SPACE_BUF; @@ -982,7 +1003,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data, goto exit; } - if (sgl) { + if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { for (i = 0; i < num_bufs; i++) { priv_data = (struct priv_op_data *) (ops_processed[i] + 1); @@ -1293,7 +1314,7 @@ test_compressdev_deflate_stateless_fixed(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 0, + LB_BOTH, ZLIB_DECOMPRESS, 0 }; @@ -1363,7 +1384,7 @@ test_compressdev_deflate_stateless_dynamic(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 0, + LB_BOTH, ZLIB_DECOMPRESS, 0 }; @@ -1416,7 +1437,7 @@ test_compressdev_deflate_stateless_multi_op(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 0, + LB_BOTH, ZLIB_DECOMPRESS, 0 }; @@ -1465,7 +1486,7 @@ test_compressdev_deflate_stateless_multi_level(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 0, + LB_BOTH, ZLIB_DECOMPRESS, 0 }; @@ -1554,7 +1575,7 @@ test_compressdev_deflate_stateless_multi_xform(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 0, + LB_BOTH, ZLIB_DECOMPRESS, 0 }; @@ -1599,7 +1620,7 @@ test_compressdev_deflate_stateless_sgl(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 1, + SGL_BOTH, ZLIB_DECOMPRESS, 0 }; @@ -1617,6 +1638,36 @@ test_compressdev_deflate_stateless_sgl(void) test_data.zlib_dir = ZLIB_COMPRESS; if (test_deflate_comp_decomp(&int_data, &test_data) < 0) return TEST_FAILED; + + if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_LB_OUT) { + /* Compress with compressdev, decompress with Zlib */ + test_data.zlib_dir = ZLIB_DECOMPRESS; + test_data.buff_type = SGL_TO_LB; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) + return TEST_FAILED; + + /* Compress with Zlib, decompress with compressdev */ + test_data.zlib_dir = ZLIB_COMPRESS; + test_data.buff_type = SGL_TO_LB; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) + return TEST_FAILED; + } + + if (capab->comp_feature_flags & RTE_COMP_FF_OOP_LB_IN_SGL_OUT) { + /* Compress with compressdev, decompress with Zlib */ + test_data.zlib_dir = ZLIB_DECOMPRESS; + test_data.buff_type = LB_TO_SGL; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) + return TEST_FAILED; + + /* Compress with Zlib, decompress with compressdev */ + test_data.zlib_dir = ZLIB_COMPRESS; + test_data.buff_type = LB_TO_SGL; + if (test_deflate_comp_decomp(&int_data, &test_data) < 0) + return TEST_FAILED; + } + + } return TEST_SUCCESS; @@ -1676,7 +1727,7 @@ test_compressdev_deflate_stateless_checksum(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 0, + LB_BOTH, ZLIB_DECOMPRESS, 0 }; @@ -1806,7 +1857,7 @@ test_compressdev_out_of_space_buffer(void) struct test_data_params test_data = { RTE_COMP_OP_STATELESS, - 0, + LB_BOTH, ZLIB_DECOMPRESS, 1 }; @@ -1827,7 +1878,7 @@ test_compressdev_out_of_space_buffer(void) if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { /* Compress with compressdev, decompress with Zlib */ test_data.zlib_dir = ZLIB_DECOMPRESS; - test_data.sgl = 1; + test_data.buff_type = SGL_BOTH; if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit; @@ -1835,7 +1886,7 @@ test_compressdev_out_of_space_buffer(void) /* Compress with Zlib, decompress with compressdev */ test_data.zlib_dir = ZLIB_COMPRESS; - test_data.sgl = 1; + test_data.buff_type = SGL_BOTH; if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { ret = TEST_FAILED; goto exit;