From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by dpdk.org (Postfix) with ESMTP id E46CB1B9CD for ; Fri, 14 Dec 2018 10:59:30 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 14 Dec 2018 01:59:30 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,352,1539673200"; d="scan'208";a="110349976" Received: from silpixa00399501.ir.intel.com ([10.237.223.69]) by orsmga003.jf.intel.com with ESMTP; 14 Dec 2018 01:59:29 -0800 From: Lee Daly To: akhil.goyal@nxp.com Cc: dev@dpdk.org, Lee Daly Date: Fri, 14 Dec 2018 09:59:23 +0000 Message-Id: <1544781564-63598-2-git-send-email-lee.daly@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1544781564-63598-1-git-send-email-lee.daly@intel.com> References: <11544697752-156863-1-git-send-email-lee.daly@intel.com> <1544781564-63598-1-git-send-email-lee.daly@intel.com> Subject: [dpdk-dev] [PATCH v4 2/3] test/compress: add checksum tests 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: , X-List-Received-Date: Fri, 14 Dec 2018 09:59:31 -0000 This patch adds a test which examines what type of checksum the PMD supports, adler, crc32 or alder32_crc32 and tests that feature if the PMD supports it. V2: Documentation Changes V3: Added Release note V4: Removed dependency on offset unit test Signed-off-by: Lee Daly Acked-by: Tomasz Jozwiak Acked-by: Fiona Trahe --- test/test/test_compressdev.c | 206 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 203 insertions(+), 3 deletions(-) diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c index dab3c12..2e70ca3 100644 --- a/test/test/test_compressdev.c +++ b/test/test/test_compressdev.c @@ -36,6 +36,12 @@ #define NUM_MAX_INFLIGHT_OPS 128 #define CACHE_SIZE 0 +#define ZLIB_CRC_CHECKSUM_WINDOW_BITS 31 +#define ZLIB_HEADER_SIZE 2 +#define ZLIB_TRAILER_SIZE 4 +#define GZIP_HEADER_SIZE 10 +#define GZIP_TRAILER_SIZE 8 + const char * huffman_type_strings[] = { [RTE_COMP_HUFFMAN_DEFAULT] = "PMD default", @@ -318,6 +324,10 @@ compress_zlib(struct rte_comp_op *op, * When doing raw DEFLATE, this number will be negative. */ window_bits = -(xform->compress.window_size); + if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) + window_bits *= -1; + else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) + window_bits = ZLIB_CRC_CHECKSUM_WINDOW_BITS; comp_level = xform->compress.level; @@ -401,8 +411,19 @@ compress_zlib(struct rte_comp_op *op, } op->consumed = stream.total_in; - op->produced = stream.total_out; + 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); + } 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); + } else + op->produced = stream.total_out; + op->status = RTE_COMP_OP_STATUS_SUCCESS; + op->output_chksum = stream.adler; deflateReset(&stream); @@ -436,7 +457,6 @@ decompress_zlib(struct rte_comp_op *op, * When doing raw DEFLATE, this number will be negative. */ window_bits = -(xform->decompress.window_size); - ret = inflateInit2(&stream, window_bits); if (ret != Z_OK) { @@ -652,6 +672,7 @@ test_deflate_comp_decomp(const char * const test_bufs[], const struct rte_compressdev_capabilities *capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); char *contig_buf = NULL; + uint64_t compress_checksum[num_bufs]; /* Initialize all arrays to NULL */ memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs); @@ -838,6 +859,7 @@ test_deflate_comp_decomp(const char * const test_bufs[], &ops_processed[num_total_deqd], num_bufs); num_total_deqd += num_deqd; deqd_retries++; + } while (num_total_deqd < num_enqd); deqd_retries = 0; @@ -871,6 +893,8 @@ test_deflate_comp_decomp(const char * const test_bufs[], ops_processed[i]->consumed == 0 ? 0 : (float)ops_processed[i]->produced / ops_processed[i]->consumed * 100); + if (compress_xform->chksum != RTE_COMP_CHECKSUM_NONE) + compress_checksum[i] = ops_processed[i]->output_chksum; ops[i] = NULL; } @@ -1106,11 +1130,23 @@ test_deflate_comp_decomp(const char * const test_bufs[], buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0, ops_processed[i]->produced, contig_buf); - if (compare_buffers(buf1, strlen(buf1) + 1, buf2, ops_processed[i]->produced) < 0) goto exit; + /* Test checksums */ + if (compress_xforms[0]->compress.chksum != + RTE_COMP_CHECKSUM_NONE) { + if (ops_processed[i]->output_chksum != + compress_checksum[i]) { + RTE_LOG(ERR, USER1, "The checksums differ\n" + "Compression Checksum: %" PRIu64 "\tDecompression " + "Checksum: %" PRIu64 "\n", compress_checksum[i], + ops_processed[i]->output_chksum); + goto exit; + } + } + rte_free(contig_buf); contig_buf = NULL; } @@ -1462,6 +1498,168 @@ test_compressdev_deflate_stateless_sgl(void) } return TEST_SUCCESS; + +} + +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; + + capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); + TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); + + /* Check if driver supports any checksum */ + if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) == 0 && + (capab->comp_feature_flags & + RTE_COMP_FF_ADLER32_CHECKSUM) == 0 && + (capab->comp_feature_flags & + RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) == 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; + } + + memcpy(compress_xform, ts_params->def_comp_xform, + sizeof(struct rte_comp_xform)); + + struct rte_comp_xform *decompress_xform = + rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); + if (decompress_xform == NULL) { + RTE_LOG(ERR, USER1, "Decompress xform could not be created\n"); + ret = TEST_FAILED; + goto exit; + } + + memcpy(decompress_xform, ts_params->def_decomp_xform, + sizeof(struct rte_comp_xform)); + + /* 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]; + + /* 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) < 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) < 0) { + ret = TEST_FAILED; + goto exit; + } + } + } + + /* Check if driver supports adler32 checksum and test */ + if ((capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM)) { + compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32; + decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32; + + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { + test_buffer = compress_test_bufs[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) < 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) < 0) { + ret = TEST_FAILED; + goto exit; + } + } + } + + /* Check if driver supports combined crc and adler checksum and test */ + if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)) { + compress_xform->compress.chksum = + RTE_COMP_CHECKSUM_CRC32_ADLER32; + decompress_xform->decompress.chksum = + RTE_COMP_CHECKSUM_CRC32_ADLER32; + + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { + test_buffer = compress_test_bufs[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) < 0) { + ret = TEST_FAILED; + goto exit; + } + } + } + + ret = TEST_SUCCESS; + +exit: + rte_free(compress_xform); + rte_free(decompress_xform); + return ret; } static struct unit_test_suite compressdev_testsuite = { @@ -1483,6 +1681,8 @@ static struct unit_test_suite compressdev_testsuite = { test_compressdev_deflate_stateless_multi_xform), TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, test_compressdev_deflate_stateless_sgl), + TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, + test_compressdev_deflate_stateless_checksum), TEST_CASES_END() /**< NULL terminate unit test array */ } }; -- 2.7.4