From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by dpdk.org (Postfix) with ESMTP id 9D4981B4D1 for ; Tue, 27 Nov 2018 11:31:12 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 27 Nov 2018 02:31:11 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,286,1539673200"; d="scan'208";a="93199635" Received: from silpixa00399501.ir.intel.com ([10.237.223.69]) by fmsmga008.fm.intel.com with ESMTP; 27 Nov 2018 02:31:10 -0800 From: Lee Daly To: fiona.trahe@intel.com Cc: dev@dpdk.org, Lee Daly Date: Tue, 27 Nov 2018 10:30:58 +0000 Message-Id: <1543314658-147566-1-git-send-email-lee.daly@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1532441167-101058-1-git-send-email-lee.daly@intel.com> References: <1532441167-101058-1-git-send-email-lee.daly@intel.com> Subject: [dpdk-dev] [PATCH v2] test/compress: add mbuf offset unit 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: , X-List-Received-Date: Tue, 27 Nov 2018 10:31:13 -0000 added mbuf offset test to compressdev test suite, which tests compression/ decompression with a mbuf containing an offset spanning across mulitple segments Signed-off-by: Lee Daly --- test/test/test_compressdev.c | 241 ++++++++++++++++++++++++++++++++++--------- 1 file changed, 193 insertions(+), 48 deletions(-) diff --git a/test/test/test_compressdev.c b/test/test/test_compressdev.c index 5d5e519..91dd636 100644 --- a/test/test/test_compressdev.c +++ b/test/test/test_compressdev.c @@ -35,6 +35,7 @@ #define NUM_MAX_XFORMS 16 #define NUM_MAX_INFLIGHT_OPS 128 #define CACHE_SIZE 0 +#define OFFSET 800 const char * huffman_type_strings[] = { @@ -93,7 +94,7 @@ testsuite_setup(void) for (i = 0; i < RTE_DIM(compress_test_bufs); i++) max_buf_size = RTE_MAX(max_buf_size, - strlen(compress_test_bufs[i]) + 1); + (strlen(compress_test_bufs[i]) + OFFSET + 1)); /* * Buffers to be used in compression and decompression. @@ -347,8 +348,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"); @@ -362,9 +364,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); @@ -384,9 +388,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); @@ -459,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"); @@ -474,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 */ @@ -496,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) { @@ -530,17 +571,19 @@ 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; char *buf_ptr; const char *data_ptr = test_buf; uint16_t i; - int ret; + int ret, remaining_offset; if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl) num_remaining_segs = limit_segs_in_sgl - 1; @@ -560,13 +603,14 @@ 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--; + remaining_offset = offset - data_size; /* * Allocate the rest of the segments, @@ -600,12 +644,21 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, rte_pktmbuf_free(next_seg); return -1; } - if (data_ptr != NULL) { + if (data_ptr != NULL && remaining_offset < (int)data_size) { /* 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 + remaining_offset, data_ptr, + data_size - remaining_offset); + data_ptr += data_size - remaining_offset; + remaining_data -= data_size - remaining_offset; + } else { + strncpy(buf_ptr, data_ptr, data_size); + data_ptr += data_size; + remaining_data -= data_size; + } } - remaining_data -= data_size; + if (remaining_data == total_data_size) + remaining_offset -= data_size; ret = rte_pktmbuf_chain(head_buf, next_seg); if (ret != 0) { @@ -631,7 +684,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; @@ -682,14 +736,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]); } } @@ -710,7 +767,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, + offset) < 0) goto exit; } @@ -718,7 +776,7 @@ test_deflate_comp_decomp(const char * const test_bufs[], for (i = 0; i < num_bufs; i++) { data_size = strlen(test_bufs[i]) * COMPRESS_BUF_SIZE_RATIO; - rte_pktmbuf_append(comp_bufs[i], data_size); + rte_pktmbuf_append(comp_bufs[i], data_size + offset); } } @@ -734,9 +792,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 { @@ -906,10 +964,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; } @@ -918,7 +977,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); } } @@ -935,13 +994,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 { @@ -1108,7 +1167,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[i]->dst.offset, ops_processed[i]->produced, contig_buf); if (compare_buffers(buf1, strlen(buf1) + 1, @@ -1178,7 +1238,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; } @@ -1191,7 +1252,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; } @@ -1244,7 +1306,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; } @@ -1257,7 +1320,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; } @@ -1289,7 +1353,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 */ @@ -1300,7 +1365,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; @@ -1340,7 +1406,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; } @@ -1411,7 +1478,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; } @@ -1450,7 +1518,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 */ @@ -1461,7 +1530,81 @@ 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)) { + + /* Test SGL with offset, which spans across multiple segments */ + 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; + } + } + + /* Test linear buffer with offset */ + 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; } @@ -1487,6 +1630,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 */ } }; -- 2.7.4