From patchwork Wed Nov 28 10:41:46 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Daly, Lee" X-Patchwork-Id: 48383 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 BA37B1B484; Wed, 28 Nov 2018 11:42:06 +0100 (CET) Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) by dpdk.org (Postfix) with ESMTP id 936A71B3FD for ; Wed, 28 Nov 2018 11:42:02 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga008.jf.intel.com ([10.7.209.65]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 28 Nov 2018 02:42:01 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,290,1539673200"; d="scan'208";a="96154056" Received: from silpixa00399501.ir.intel.com ([10.237.223.69]) by orsmga008.jf.intel.com with ESMTP; 28 Nov 2018 02:42:00 -0800 From: Lee Daly To: fiona.trahe@intel.com, akhil.goyal@nxp.com Cc: dev@dpdk.org, Lee Daly Date: Wed, 28 Nov 2018 10:41:46 +0000 Message-Id: <1543401707-87314-2-git-send-email-lee.daly@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1543401707-87314-1-git-send-email-lee.daly@intel.com> References: <1539102109-9311-1-git-send-email-lee.daly@intel.com> <1543401707-87314-1-git-send-email-lee.daly@intel.com> Subject: [dpdk-dev] [PATCH v2 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: , Errors-To: dev-bounces@dpdk.org Sender: "dev" 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. 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 4b98001..2ca4c91 100644 --- a/test/test/test_compressdev.c +++ b/test/test/test_compressdev.c @@ -37,6 +37,12 @@ #define CACHE_SIZE 0 #define OFFSET 800 +#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", @@ -319,6 +325,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; @@ -422,8 +432,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); @@ -457,7 +478,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) { @@ -706,6 +726,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); @@ -896,6 +917,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; @@ -929,6 +951,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; } @@ -1166,11 +1190,23 @@ test_deflate_comp_decomp(const char * const test_bufs[], buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, ops_processed[i]->dst.offset, 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; } @@ -1605,6 +1641,168 @@ test_compressdev_deflate_stateless_offset(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 = { @@ -1628,6 +1826,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_offset), + TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, + test_compressdev_deflate_stateless_checksum), TEST_CASES_END() /**< NULL terminate unit test array */ } };