[dpdk-dev] [PATCH v2] test/compress: add mbuf offset unit test

[Lee Daly <lee.daly@intel.com>]

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 <lee.daly@intel.com>
---
 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