From patchwork Tue Jul 24 14:06:07 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Daly, Lee" X-Patchwork-Id: 43310 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 779552BF1; Tue, 24 Jul 2018 16:07:37 +0200 (CEST) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by dpdk.org (Postfix) with ESMTP id 28950160 for ; Tue, 24 Jul 2018 16:07:34 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga107.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 24 Jul 2018 07:07:33 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.51,398,1526367600"; d="scan'208";a="247925643" Received: from silpixa00399501.ir.intel.com ([10.237.223.69]) by fmsmga005.fm.intel.com with ESMTP; 24 Jul 2018 07:06:32 -0700 From: Lee Daly To: pablo.de.lara.guarch@intel.com Cc: fiona.trahe@intel.com, dev@dpdk.org, "Daly, Lee" Date: Tue, 24 Jul 2018 15:06:07 +0100 Message-Id: <1532441167-101058-1-git-send-email-lee.daly@intel.com> X-Mailer: git-send-email 2.7.4 Subject: [dpdk-dev] [PATCH] test/compress: add offset 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" From: "Daly, Lee" Added offset test, which tests compression/decompression with a buffer containing an offset spanning across multiple segments. Signed-off-by: Lee Daly --- test/test/test_compressdev.c | 233 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 189 insertions(+), 44 deletions(-) diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c index 8645388..a5f962f 100644 --- a/test/test/test_compressdev.c +++ b/test/test/test_compressdev.c @@ -34,6 +34,7 @@ #define NUM_MAX_XFORMS 16 #define NUM_MAX_INFLIGHT_OPS 128 #define CACHE_SIZE 0 +#define OFFSET 800 const char * huffman_type_strings[] = { @@ -346,8 +347,9 @@ compress_zlib(struct rte_comp_op *op, 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"); @@ -361,9 +363,11 @@ compress_zlib(struct rte_comp_op *op, } 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); 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); @@ -383,9 +387,26 @@ compress_zlib(struct rte_comp_op *op, uint8_t *src_data = single_dst_buf; struct rte_mbuf *dst_buf = op->m_dst; + uint32_t remaining_offset = op->dst.offset; + while (remaining_offset >= dst_buf->data_len) { + remaining_offset -= dst_buf->data_len; + dst_buf = dst_buf->next; + } + + /* First Segment */ + uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf, uint8_t *, + op->dst.offset % dst_buf->data_len); + memcpy(dst_data, src_data, dst_buf->data_len - + (op->dst.offset % dst_buf->data_len)); + remaining_data -= dst_buf->data_len - + (op->dst.offset % dst_buf->data_len); + src_data += dst_buf->data_len - + (op->dst.offset % dst_buf->data_len); + dst_buf = dst_buf->next; + + while (remaining_data > 0) { - uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf, - uint8_t *); + dst_data = rte_pktmbuf_mtod(dst_buf, uint8_t *); /* Last segment */ if (remaining_data < dst_buf->data_len) { memcpy(dst_data, src_data, remaining_data); @@ -414,6 +435,7 @@ compress_zlib(struct rte_comp_op *op, return ret; } + static int decompress_zlib(struct rte_comp_op *op, const struct rte_comp_xform *xform) @@ -458,8 +480,9 @@ decompress_zlib(struct rte_comp_op *op, 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"); @@ -473,9 +496,11 @@ decompress_zlib(struct rte_comp_op *op, } 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); 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 */ @@ -495,8 +520,25 @@ decompress_zlib(struct rte_comp_op *op, uint8_t *src_data = single_dst_buf; struct rte_mbuf *dst_buf = op->m_dst; + uint32_t remaining_offset = op->dst.offset; + while (remaining_offset >= dst_buf->data_len) { + remaining_offset -= dst_buf->data_len; + dst_buf = dst_buf->next; + } + + uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf, uint8_t *, + op->dst.offset % dst_buf->data_len); + memcpy(dst_data, src_data, dst_buf->data_len - + (op->dst.offset % dst_buf->data_len)); + remaining_data -= dst_buf->data_len - + (op->dst.offset % dst_buf->data_len); + src_data += dst_buf->data_len - + (op->dst.offset % dst_buf->data_len); + dst_buf = dst_buf->next; + + while (remaining_data > 0) { - uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf, + dst_data = rte_pktmbuf_mtod(dst_buf, uint8_t *); /* Last segment */ if (remaining_data < dst_buf->data_len) { @@ -529,10 +571,12 @@ 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 offset) { 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 + offset, + SMALL_SEG_SIZE); struct rte_mempool *pool; struct rte_mbuf *next_seg; uint32_t data_size; @@ -559,12 +603,12 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, return -1; } - if (data_ptr != NULL) { + if (data_ptr != NULL && offset < data_size) { /* Copy characters without NULL terminator */ - strncpy(buf_ptr, data_ptr, data_size); - data_ptr += data_size; + strncpy(buf_ptr + offset, data_ptr, data_size - offset); + data_ptr += data_size - offset; + remaining_data -= data_size - offset; } - remaining_data -= data_size; num_remaining_segs--; /* @@ -601,10 +645,21 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, } if (data_ptr != NULL) { /* Copy characters without NULL terminator */ - strncpy(buf_ptr, data_ptr, data_size); - data_ptr += data_size; + if (remaining_data == total_data_size) { + strncpy(buf_ptr + (offset % SMALL_SEG_SIZE), + data_ptr, + data_size - + (offset % SMALL_SEG_SIZE)); + data_ptr += data_size - + (offset % SMALL_SEG_SIZE); + remaining_data -= data_size - + (offset % SMALL_SEG_SIZE); + } else { + strncpy(buf_ptr, data_ptr, data_size); + data_ptr += data_size; + remaining_data -= data_size; + } } - remaining_data -= data_size; ret = rte_pktmbuf_chain(head_buf, next_seg); if (ret != 0) { @@ -630,7 +685,8 @@ test_deflate_comp_decomp(const char * const test_bufs[], unsigned int num_xforms, enum rte_comp_op_type state, unsigned int sgl, - enum zlib_direction zlib_dir) + enum zlib_direction zlib_dir, + uint16_t offset) { struct comp_testsuite_params *ts_params = &testsuite_params; int ret_status = -1; @@ -681,14 +737,17 @@ test_deflate_comp_decomp(const char * const test_bufs[], data_size, ts_params->small_mbuf_pool, ts_params->large_mbuf_pool, - MAX_SEGS) < 0) + MAX_SEGS, + offset) < 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]); + buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], + data_size + offset); + snprintf(buf_ptr + offset, data_size, "%s", + test_bufs[i]); } } @@ -709,7 +768,8 @@ test_deflate_comp_decomp(const char * const test_bufs[], data_size, ts_params->small_mbuf_pool, ts_params->large_mbuf_pool, - MAX_SEGS) < 0) + MAX_SEGS, + 0) < 0) goto exit; } @@ -733,9 +793,9 @@ test_deflate_comp_decomp(const char * const test_bufs[], for (i = 0; i < num_bufs; i++) { ops[i]->m_src = uncomp_bufs[i]; ops[i]->m_dst = comp_bufs[i]; - ops[i]->src.offset = 0; - ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]); - ops[i]->dst.offset = 0; + ops[i]->src.offset = offset; + ops[i]->src.length = strlen(test_bufs[i]) + 1; + ops[i]->dst.offset = offset; if (state == RTE_COMP_OP_STATELESS) { ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL; } else { @@ -898,10 +958,11 @@ test_deflate_comp_decomp(const char * const test_bufs[], (ops_processed[i] + 1); data_size = strlen(test_bufs[priv_data->orig_idx]) + 1; if (prepare_sgl_bufs(NULL, uncomp_bufs[i], - data_size, + data_size + offset, ts_params->small_mbuf_pool, ts_params->large_mbuf_pool, - MAX_SEGS) < 0) + MAX_SEGS, + 0) < 0) goto exit; } @@ -910,7 +971,7 @@ test_deflate_comp_decomp(const char * const test_bufs[], priv_data = (struct priv_op_data *) (ops_processed[i] + 1); data_size = strlen(test_bufs[priv_data->orig_idx]) + 1; - rte_pktmbuf_append(uncomp_bufs[i], data_size); + rte_pktmbuf_append(uncomp_bufs[i], data_size + offset); } } @@ -927,13 +988,13 @@ test_deflate_comp_decomp(const char * const test_bufs[], for (i = 0; i < num_bufs; i++) { ops[i]->m_src = ops_processed[i]->m_dst; ops[i]->m_dst = uncomp_bufs[i]; - ops[i]->src.offset = 0; + ops[i]->src.offset = offset; /* * Set the length of the compressed data to the * number of bytes that were produced in the previous stage */ ops[i]->src.length = ops_processed[i]->produced; - ops[i]->dst.offset = 0; + ops[i]->dst.offset = offset; if (state == RTE_COMP_OP_STATELESS) { ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL; } else { @@ -1094,7 +1155,8 @@ test_deflate_comp_decomp(const char * const test_bufs[], goto exit; } - buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0, + buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, + ops_processed[0]->dst.offset, ops_processed[i]->produced, contig_buf); if (compare_buffers(buf1, strlen(buf1) + 1, @@ -1164,7 +1226,8 @@ test_compressdev_deflate_stateless_fixed(void) 1, RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS) < 0) { + ZLIB_DECOMPRESS, + 0) < 0) { ret = TEST_FAILED; goto exit; } @@ -1177,7 +1240,8 @@ test_compressdev_deflate_stateless_fixed(void) 1, RTE_COMP_OP_STATELESS, 0, - ZLIB_COMPRESS) < 0) { + ZLIB_COMPRESS, + 0) < 0) { ret = TEST_FAILED; goto exit; } @@ -1230,7 +1294,8 @@ test_compressdev_deflate_stateless_dynamic(void) 1, RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS) < 0) { + ZLIB_DECOMPRESS, + 0) < 0) { ret = TEST_FAILED; goto exit; } @@ -1243,7 +1308,8 @@ test_compressdev_deflate_stateless_dynamic(void) 1, RTE_COMP_OP_STATELESS, 0, - ZLIB_COMPRESS) < 0) { + ZLIB_COMPRESS, + 0) < 0) { ret = TEST_FAILED; goto exit; } @@ -1275,7 +1341,8 @@ test_compressdev_deflate_stateless_multi_op(void) 1, RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS) < 0) + ZLIB_DECOMPRESS, + 0) < 0) return TEST_FAILED; /* Compress with Zlib, decompress with compressdev */ @@ -1286,7 +1353,8 @@ test_compressdev_deflate_stateless_multi_op(void) 1, RTE_COMP_OP_STATELESS, 0, - ZLIB_COMPRESS) < 0) + ZLIB_COMPRESS, + 0) < 0) return TEST_FAILED; return TEST_SUCCESS; @@ -1326,7 +1394,8 @@ test_compressdev_deflate_stateless_multi_level(void) 1, RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS) < 0) { + ZLIB_DECOMPRESS, + 0) < 0) { ret = TEST_FAILED; goto exit; } @@ -1397,7 +1466,8 @@ test_compressdev_deflate_stateless_multi_xform(void) NUM_XFORMS, RTE_COMP_OP_STATELESS, 0, - ZLIB_DECOMPRESS) < 0) { + ZLIB_DECOMPRESS, + 0) < 0) { ret = TEST_FAILED; goto exit; } @@ -1436,7 +1506,8 @@ test_compressdev_deflate_stateless_sgl(void) 1, RTE_COMP_OP_STATELESS, 1, - ZLIB_DECOMPRESS) < 0) + ZLIB_COMPRESS, + 0) < 0) return TEST_FAILED; /* Compress with Zlib, decompress with compressdev */ @@ -1447,7 +1518,79 @@ test_compressdev_deflate_stateless_sgl(void) 1, RTE_COMP_OP_STATELESS, 1, - ZLIB_COMPRESS) < 0) + ZLIB_DECOMPRESS, + 0) < 0) + return TEST_FAILED; + } + + return TEST_SUCCESS; +} + +static int +test_compressdev_deflate_stateless_offset(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); + TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); + + if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 1) { + + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { + test_buffer = compress_test_bufs[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, + OFFSET) < 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, + OFFSET) < 0) + return TEST_FAILED; + } + } + + for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { + test_buffer = compress_test_bufs[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, + 0, + ZLIB_DECOMPRESS, + OFFSET) < 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, + 0, + ZLIB_COMPRESS, + OFFSET) < 0) return TEST_FAILED; } @@ -1473,6 +1616,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_offset), TEST_CASES_END() /**< NULL terminate unit test array */ } };